Sync ctx 648d9f6 (part 2)

GitHub commit: 648d9f6989ca91b93d26dd38fef42259cce4d7e2

qa/bug_smoke_status.csv

@@ -14,3 +14,14 @@ AUDIT-012,UX Bug,Dashboard wiki,pack mode local overlays and entity typing,src/c
 AUDIT-013,Tracker Hygiene,Canonical bug tracker,fixed-row next_action evidence,qa/bug_smoke_status.csv,local tracker audit found fixed rows still pointing at already completed PR or backlog actions,Low,Fixed and retested tracker rows should not tell future agents to rerun already completed PR or backlog actions.,manual tracker audit + csv parser validation,Retested Pass,Fixed rows included stale next_action values such as Run PR CI after commit and Continue dashboard/wiki backlog after PRs were merged,"Canonical tracker next_action text was stale for closed rows, making status summaries look unfinished.",Parse qa/bug_smoke_status.csv and inspect fixed rows whose next_action is not a closed-state instruction.,Normalize fixed-row next_action values to a closed discovery handoff and document this tracker cleanup row.,Fixed,.venv/bin/pytest src/tests/test_bug_smoke_tracker.py -q --tb=short,PASS: tracker parser enforces PASS retest evidence and closed next_action values.,2026-07-05,Codex,Reviewed by local static audit,Ponytail: tracker text only; no product behavior change.,Closed; continue repo-wide discovery.
 AUDIT-014,Tracker Hygiene,Feature status ledger,DIST-004 supporting tracker status,docs/qa/feature-user-story-status.csv; qa/feature_status.csv,parallel docs audit found docs tracker status Needs Fix while canonical row was Blocked/Human Decision,Low,Supporting feature tracker and canonical feature status should agree on human-owned blocked release states.,parallel docs tracker audit + csv parser validation,Retested Pass,docs tracker DIST-004 status drift from canonical status,Supporting docs tracker kept historical Needs Fix wording for human-owned HF token rotation.,Compare DIST-004 in docs/qa/feature-user-story-status.csv and qa/feature_status.csv before fix.,Align supporting DIST-004 status with canonical Blocked/Human Decision and remove the override contract.,Fixed,.venv/bin/pytest src/tests/test_feature_user_story_tracker.py -q --tb=short,PASS: DIST-004 supporting tracker now matches canonical Blocked/Human Decision.,2026-07-05,Codex,Reviewed by local static audit,Ponytail: tracker text only; human-owned HF token rotation remains out of scope.,Closed; continue repo-wide discovery.
 AUDIT-015,CI Gate,Public docs tracker,docs and publish workflows,.github/workflows/docs.yml; .github/workflows/publish.yml; src/tests/test_feature_user_story_tracker.py,parallel docs audit found docs and publish workflows ran only two of four public tracker suites,Medium,Public docs and release workflows should run the same four tracker suites as PR docs and local preflight.,parallel docs workflow audit + regression test,Retested Pass,docs/publish tracker commands omitted bug-smoke and toolbox suites,Docs deploy and publish canaries could miss bug tracker or toolbox tracker regressions.,Inspect workflow pytest commands and compare to PUBLIC_DOCS_TRACKER_TESTS.,Add bug-smoke and toolbox tracker suites to docs and publish workflow commands and enforce by regression.,Fixed,.venv/bin/pytest src/tests/test_feature_user_story_tracker.py src/tests/test_ci_preflight.py -q --tb=short,"PASS: workflows include bug-smoke, feature, dashboard, and toolbox tracker suites.",2026-07-05,Codex,Reviewed by local static audit,Ponytail: align duplicated workflow test lists with the established public tracker suites.,Closed; continue repo-wide discovery.
+AUDIT-016,CLI Bug,MCP ingest,malformed JSONL and checkpoint recovery,src/mcp_ingest.py; src/tests/test_mcp_ingest.py,Aquinas worker and local audit found malformed JSONL/non-object records were warned or skipped and corrupt scalar/nested checkpoint member shapes could poison checkpoint recovery.,Medium,"Malformed JSONL and non-object JSON should be current-run failures with a nonzero dry-run exit, while corrupt checkpoint scalar/nested member shapes reset fresh.",parallel worker audit + focused pytest,Retested Pass,malformed JSONL warned or skipped and corrupt checkpoint shapes could survive recovery before fix,MCP ingest could under-report malformed inputs and recover badly from corrupt checkpoint member shapes.,Run ctx-mcp-ingest dry-run against malformed JSONL/non-object JSON and corrupt checkpoint scalar/nested member shapes before the fix.,"Record malformed input as current-run failures, return nonzero in dry-run, and reset corrupt checkpoint member shapes fresh.",Fixed,.venv/bin/pytest src/tests/test_mcp_ingest.py -q --tb=short,PASS: integrated MCP ingest suite reported 30 passed; malformed input and checkpoint recovery regressions are covered.,2026-07-05,Codex,Reviewed by local tests + static audit,Ponytail: harden malformed input and checkpoint recovery only; no ingest feature expansion.,Closed; continue repo-wide discovery.
+AUDIT-017,Telemetry,Runtime lifecycle,token usage metric span correlation,src/ctx/adapters/generic/runtime_lifecycle.py; src/tests/test_harness_ctx_core.py,Planck trace-propagation audit found lifecycle token-usage metrics were emitted before the lifecycle telemetry span.,Medium,Lifecycle token-usage metrics should share the trace/span of the lifecycle event they describe.,parallel trace audit + focused pytest,Retested Pass,usage metric point could correlate to the parent CLI span instead of the lifecycle event span before fix,Runtime lifecycle usage metrics were not emitted inside the lifecycle event span.,Record token_usage through ctx__mark_entity_used and compare metric trace/span attributes with the lifecycle event before the fix.,Move usage metric recording into the existing lifecycle telemetry span while preserving exact/estimated/unavailable attribution.,Fixed,.venv/bin/pytest src/tests/test_harness_ctx_core.py -q --tb=short,PASS: runtime lifecycle focused suite reported 74 passed including lifecycle usage metric span correlation.,2026-07-05,Codex,Reviewed by local tests + static audit,Ponytail: correlate existing metric emission with the lifecycle span; no new token accounting model.,Closed; continue repo-wide discovery.
+AUDIT-018,Telemetry,CLI runtime,ctx run/resume early failure trace metadata,src/ctx/cli/run.py; src/tests/test_harness_cli_run.py,Rawls worker and Planck audit found ctx run/resume early failure paths could exit without failed CLI telemetry or previous trace correlation.,Medium,ctx run/resume should emit failed CLI telemetry inside a span for early failures and resume should include previous trace correlation when available.,parallel trace audit + focused pytest,Retested Pass,early validation/planner/session-create/session-load/session-attach/missing-model failures lacked complete CLI telemetry before fix,CLI early failures and resume flows had incomplete trace metadata.,Trigger ctx run validation/planner/session-create failures or ctx resume load/attach/missing-model failures before the fix and inspect ctx.cli.run/ctx.cli.resume telemetry.,"Wrap early failure exits in telemetry spans, hash/redact error payloads, persist initial_trace_id, and emit ctx.session.previous_trace_id on resume.",Fixed,.venv/bin/pytest src/tests/test_harness_cli_run.py -q --tb=short,PASS: focused CLI harness suite reported 73 passed and covered early failure/resume trace telemetry.,2026-07-05,Codex,Reviewed by local tests + static audit,Ponytail: telemetry-only hardening of existing failure paths; no CLI command behavior expansion.,Closed; continue repo-wide discovery.
+AUDIT-019,Telemetry,MCP runtime,external MCP tool call trace propagation,src/ctx/adapters/generic/tools/mcp_router.py; src/ctx/mcp_server/server.py; src/ctx/telemetry/__init__.py; src/tests/test_mcp_router.py; src/tests/test_enterprise_telemetry.py,Jason worker and Planck audit found external MCP tool calls lacked client-side telemetry and spawned server spans did not inherit the caller trace.,High,External MCP tool calls should emit ctx.mcp.external_tool_call telemetry and propagate W3C traceparent metadata so server spans parent to the client request trace.,parallel trace audit + focused pytest,Retested Pass,MCP JSON-RPC calls lacked traceparent metadata and client-side external-call events before fix,External MCP calls broke end-to-end trace correlation across the router/server boundary.,Call an external MCP tool inside an active telemetry span before the fix and inspect request _meta plus server span parentage.,"Emit safe external-call telemetry, inject _meta.traceparent and hashed session correlation, parse traceparent on the MCP server, and parent server spans to the caller trace.",Fixed,.venv/bin/pytest src/tests/test_mcp_router.py src/tests/test_enterprise_telemetry.py -q --tb=short,"PASS: focused MCP router and enterprise telemetry suites reported 115 passed with external-call event, traceparent injection, and server span parenting coverage.",2026-07-05,Codex,Reviewed by local tests + static audit,Ponytail: trace propagation and telemetry only; sync stdio router semantics preserved.,Closed; continue repo-wide discovery.
+AUDIT-020,Tracker Hygiene,Canonical feature tracker,stale post-merge validation prose,qa/feature_status.csv; docs/qa/feature-user-story-status.csv,Repo-wide audit found merged rows still using obsolete no-mistakes queue wording and old test-inventory prose after PR #238 and PR #239 merged.,Low,Canonical trackers should reflect current merged validation state and current README/docs test inventory without stale pending-gate prose.,manual tracker audit + rg/csv scan,Retested Pass,Rows referenced old gate-pending wording and old inventory after no-mistakes/CI/merge had completed.,Feature trackers had stale post-merge validation and inventory prose.,Scan qa/feature_status.csv and docs/qa/feature-user-story-status.csv for obsolete no-mistakes queue wording or old test-inventory references after PR #238/#239.,"Normalize affected validation/review notes to merged no-mistakes runs and current 4,473 inventory; keep human-owned HF token blocker status unchanged.",Fixed,.venv/bin/pytest src/tests/test_bug_smoke_tracker.py src/tests/test_feature_user_story_tracker.py -q --tb=short && .venv/bin/python src/update_repo_stats.py --check,PASS: tracker and stats checks passed for normalized post-merge tracker prose.,2026-07-05,Codex,Reviewed by local tracker audit,Ponytail: tracker text only; preserve human-owned HF token blocker and existing behavior.,Closed; continue repo-wide discovery.
+AUDIT-021,Privacy,MCP router,omitted resource URI summary,src/ctx/adapters/generic/tools/mcp_router.py; src/tests/test_mcp_router.py,Runtime audit found _flatten_content emitted raw MCP resource URIs in omitted resource summaries.,High,Omitted MCP resource blocks should not expose local paths or private URIs to model-facing tool output.,parallel runtime audit + focused pytest,Retested Pass,MCP resource summaries included raw file/private URI strings before fix.,Omitted MCP resources leaked resource identifiers in flattened tool output.,Call _flatten_content with a resource block whose URI is a private file URL before the fix.,Replace raw URI summaries with a stable omitted-resource marker and assert private URI text is absent.,Fixed,.venv/bin/python -m pytest src/tests/test_mcp_router.py::TestFlattenContent -q --tb=short,PASS: TestFlattenContent reported 7 passed with private URI omission regression.,2026-07-05,Codex,Reviewed by local tests + static audit,Ponytail: redact omitted resource summary only; preserve text image and unknown-block behavior.,Closed; continue repo-wide discovery.
+AUDIT-022,CLI Reliability,MCP ingest,JSONL replay preloads file,src/mcp_ingest.py; src/tests/test_mcp_ingest.py,Runtime audit found _iter_records_from used read_text().splitlines() despite the streaming JSONL contract.,Medium,ctx-mcp-ingest --from-jsonl should iterate line by line without preloading the full file.,parallel runtime audit + focused pytest,Retested Pass,JSONL file replay read the entire file before yielding records.,Large MCP catalogs could consume unnecessary memory during JSONL ingest.,Monkeypatch Path.read_text to fail and iterate --from-jsonl records before the fix.,Stream --from-jsonl with Path.open() and add a regression proving read_text is not called.,Fixed,.venv/bin/python -m pytest src/tests/test_mcp_ingest.py -q --tb=short,PASS: MCP ingest suite reported 32 passed with JSONL streaming regression.,2026-07-05,Codex,Reviewed by local tests + static audit,Ponytail: align implementation with existing streaming contract; no ingest behavior expansion.,Closed; continue repo-wide discovery.
+AUDIT-023,CLI UX,MCP ingest,--status creates wiki path,src/mcp_ingest.py; src/tests/test_mcp_ingest.py,Runtime audit found ctx-mcp-ingest --status called ensure_wiki before printing checkpoint status.,Medium,ctx-mcp-ingest --status should read checkpoint state and exit without creating a wiki for a mistyped or missing path.,parallel runtime audit + focused pytest,Retested Pass,--status created the wiki directory before reporting checkpoint status.,Read-only status command mutated the filesystem for missing wiki paths.,Run ctx-mcp-ingest --status with a missing --wiki path and inspect whether the path is created before the fix.,Handle --status before ensure_wiki and add a regression that the missing wiki path remains absent.,Fixed,.venv/bin/python -m pytest src/tests/test_mcp_ingest.py -q --tb=short,PASS: MCP ingest suite reported 32 passed with no-mutation status regression.,2026-07-05,Codex,Reviewed by local tests + static audit,Ponytail: reorder read-only status path only; normal ingest still initializes wiki.,Closed; continue repo-wide discovery.
+AUDIT-024,Security,Dashboard docs,entity-encoded active URL attributes,src/ctx/dashboard_docs.py; src/tests/test_security_hardening.py,Dashboard audit found entity-encoded active schemes survived docs sanitization in URL-bearing attributes.,High,Docs HTML sanitization should neutralize active URL schemes after entity decoding and control-character stripping.,parallel dashboard audit + focused pytest,Retested Pass,Entity-encoded javascript and data HTML schemes survived in href src xlink:href or formaction before fix.,Docs sanitization missed encoded active URL schemes in URL-bearing attributes.,Render sanitized docs HTML with entity-encoded active schemes in href src xlink:href and formaction before the fix.,Decode and normalize URL-bearing attribute values before active-scheme checks and cover the four attributes.,Fixed,.venv/bin/python -m pytest src/tests/test_security_hardening.py -q --tb=short,PASS: security hardening suite reported 41 passed with encoded active URL regressions.,2026-07-05,Codex,Reviewed by worker tests + local static audit,Ponytail: sanitize URL-bearing attributes only; preserve safe tabbed-input behavior.,Closed; continue repo-wide discovery.
+AUDIT-025,API Correctness,Monitor readonly API,HTML 404 for missing skill sidecar,src/ctx/monitor/api/readonly.py; src/tests/test_ctx_monitor.py,Dashboard audit found /api/skill/<slug>.json returned an HTML 404 body when the sidecar was missing.,Medium,JSON API routes should return JSON error payloads for missing resources.,parallel dashboard audit + focused pytest,Retested Pass,Missing skill sidecar API response had text/html content before fix.,Readonly skill API returned HTML for a JSON endpoint failure.,GET /api/skill/missing-sidecar.json before the fix and inspect status content type and body.,Return a JSON detail payload with 404 status for missing sidecars and add monitor regression coverage.,Fixed,.venv/bin/python -m pytest src/tests/test_ctx_monitor.py::test_skill_sidecar_api_missing_sidecar_returns_json_404 src/tests/test_ctx_monitor.py::test_skill_sidecar_api_reads_typed_sidecar -q,PASS: focused monitor API sidecar tests reported 2 passed.,2026-07-05,Codex,Reviewed by worker tests + local static audit,Ponytail: route-local JSON error only; no dispatcher refactor.,Closed; continue repo-wide discovery.
+AUDIT-026,Privacy,Core wiki tool,absolute wiki path in model-facing output,src/ctx/adapters/generic/ctx_core_tools.py; src/tests/test_harness_ctx_core.py,Runtime audit found ctx__wiki_get returned absolute wiki filesystem paths in success and missing-page outputs.,High,Model-facing wiki fetch results should expose wiki-relative paths or candidate labels without host absolute paths.,parallel runtime audit + focused pytest,Retested Pass,ctx__wiki_get success path and looked_in candidates included host absolute wiki paths before fix.,Wiki fetch tool leaked local filesystem layout into persisted tool results.,Call ctx__wiki_get for an existing page or missing slug under a temp wiki before the fix and inspect JSON output.,Return wiki-relative entity paths for success and missing candidates and assert temp absolute paths are absent.,Fixed,.venv/bin/python -m pytest src/tests/test_harness_ctx_core.py::TestWikiGet -q,PASS: TestWikiGet reported 6 passed with absolute-path privacy regressions.,2026-07-05,Codex,Reviewed by worker tests + local static audit,Ponytail: replace host paths with existing wiki-relative entity paths only.,Closed; continue repo-wide discovery.

qa/tool-selection-token-history/tracker.csv

@@ -3,8 +3,8 @@ US-001,API/CLI/UI,Tool recommendation selection,"As a programmer or AI engineer,
 US-002,API/CLI/UI,TLDR descriptions,"As a user, I can read a concise TLDR for each suggested tool before selecting it.","Each recommendation has a short description plus relevance reason; fallback uses safe existing metadata when description is absent.","src/ctx/core/resolve/recommendations.py; src/ctx/adapters/generic/ctx_core_tools.py; src/ctx/cli/recommend.py","pytest src/tests/test_recommendations.py src/tests/test_recommendation_surfaces_golden.py -q",Retested Pass,High,4,2026-07-02,"Phase 1 adds API/core tldr and reason fallbacks from existing row metadata; Phase 4A renders CLI tldr/reason; Phase 5B renders TLDR and reason text on the dashboard /recommend page; Phase 7 passed full pytest (4431 passed, 2 skipped) and ci_preflight --profile pr (19/19)."
 US-003,Knowledge Graph,Related recommendations after partial selection,"As a user, if I select only some suggestions, ctx proposes related tools.","Related rows are generated from graph/category/tag neighbors, exclude selected/rejected/unavailable/deprecated rows, and include reason text.","src/ctx/core/resolve/recommendations.py; src/ctx/api.py; src/ctx/adapters/generic/ctx_core_tools.py","pytest src/tests/test_recommendations.py src/tests/test_harness_recommendations.py -q",Retested Pass,High,6,2026-07-02,"Phase 2A adds ctx__recommend_related; Phase 2B1 adds public ctx.recommend_related with redacted selection telemetry; Phase 2B2 adds LoopFlow/agent-loop related_recommendations; Phase 4A adds CLI related recommendations; Phase 5B adds dashboard related suggestions for partial selections; Phase 7 passed full pytest (4431 passed, 2 skipped) and ci_preflight --profile pr (19/19)."
 US-004,Runtime Lifecycle,Tool activation tracking,"As a user, selected tool activation is recorded with session/system context.","Activation records include entity id/name/type, timestamp, privacy-safe session context, user-selected vs system-selected source, and source context.","src/ctx/adapters/generic/runtime_lifecycle.py; src/ctx/adapters/generic/ctx_core_tools.py","pytest src/tests/test_harness_ctx_core.py -q",Retested Pass,Critical,2,2026-07-02,"Phase 3A adds selected, selection_source, and sanitized source_context to load_entity/session_state and keeps local lifecycle history when telemetry is disabled; Phase 7 passed focused harness-core retest (70 passed), full pytest (4431 passed, 2 skipped), and ci_preflight --profile pr (19/19)."
-US-005,Telemetry,Token usage KPI,"As a user, I can see token usage per selected and activated tool.","Exact input/output/total tokens are recorded only with per-tool correlation; session totals stay session-level; estimated/unavailable values are labeled honestly with reason; API/dashboard expose the data.","src/ctx/adapters/generic/runtime_lifecycle.py; src/ctx/telemetry/__init__.py; src/ctx/cli/run.py","pytest src/tests/test_enterprise_telemetry.py src/tests/test_harness_cli_run.py -q",Retested Pass,Critical,4,2026-07-02,"Phase 3B adds token_usage to mark_entity_used with exact/estimated/unavailable attribution and emits OTel-style usage counters/histograms when metrics are enabled; Phase 4B labels ctx run usage as session-scoped/unavailable for per-tool attribution; Phase 5A exposes token totals/attribution on /runtime and /api/runtime.json; Phase 8 makes missing host token data a persisted unavailable usage record and adds explicit MCP telemetry/history coverage; Phase 7 telemetry enterprise gate passed (67 passed, 65 deselected)."
+US-005,Telemetry,Token usage KPI,"As a user, I can see token usage per selected and activated tool.",Exact input/output/total tokens are recorded only with per-tool correlation; session totals stay session-level; estimated/unavailable values are labeled honestly with reason; API/dashboard expose the data; lifecycle token-usage metrics share the lifecycle event trace/span.,src/ctx/adapters/generic/runtime_lifecycle.py; src/ctx/telemetry/__init__.py; src/ctx/cli/run.py,pytest src/tests/test_enterprise_telemetry.py src/tests/test_harness_cli_run.py src/tests/test_harness_ctx_core.py -q,Retested Pass,Critical,5,2026-07-05,Phase 3B adds token_usage to mark_entity_used with exact/estimated/unavailable attribution and emits OTel-style usage counters/histograms when metrics are enabled; Phase 4B labels ctx run usage as session-scoped/unavailable for per-tool attribution; Phase 5A exposes token totals/attribution on /runtime and /api/runtime.json; Phase 8 makes missing host token data a persisted unavailable usage record and adds explicit MCP telemetry/history coverage; Phase 9 correlates lifecycle usage metrics with the lifecycle event trace/span; focused lifecycle suite reported 74 passed.
 US-006,Persistence,Historical usage,"As a user, I can view historical token usage per tool over time.","Usage history persists across sessions and can be aggregated by tool, type, session, and source.","src/ctx/adapters/generic/runtime_lifecycle.py; src/ctx/monitor/services/runtime.py","pytest src/tests/test_harness_ctx_core.py src/tests/test_ctx_monitor.py -q",Retested Pass,High,3,2026-07-02,"Phase 3B persists per-entity token_usage summaries in runtime session_state; Phase 5A aggregates lifecycle history by selection source, active loads, token totals, attribution, and recent tool usage for dashboard/API consumers; Phase 8 pins MCP unavailable usage in by-tool/by-type/by-session/by-source history; Phase 7 passed full pytest (4431 passed, 2 skipped) and ci_preflight --profile pr (19/19)."
 US-007,Dashboard,Dashboard support,"As a user/admin, I can see tool-selection and token-history KPIs in the dashboard.","Dashboard shows totals, recent usage, history, user-vs-system selected source, and empty/error/unavailable states.","src/ctx/monitor/services/runtime.py; src/ctx/monitor/pages/activity.py; src/ctx/monitor/pages/ops.py; src/ctx/monitor/api/readonly.py","pytest src/tests/test_ctx_monitor.py src/tests/test_monitor_testing_api.py src/tests/test_dashboard_smoke.py -q",Retested Pass,High,3,2026-07-02,"Phase 5A extends the existing Runtime page/API with tool-selection totals, source split, token totals, attribution counts, and recent usage; Phase 5B adds dashboard recommendation selection and related-suggestion controls; Phase 7 browser monitor security gate passed (11 passed) and ci_preflight --profile pr passed 19/19."
 US-008,Parity,API/CLI/UI parity,"As a user, behavior is consistent across API, CLI, MCP/core toolbox, LoopFlow, and dashboard.","Shared semantics are reused; differences are documented only where necessary.","src/ctx/api.py; src/ctx/adapters/generic/ctx_core_tools.py; src/ctx/mcp_server/server.py; src/ctx/adapters/loopflow.py; docs","pytest src/tests/test_public_api.py src/tests/test_mcp_server.py src/tests/test_loopflow_adapter.py -q",Retested Pass,High,8,2026-07-02,"Phase 1 preserves recommend_bundle; Phase 2 adds MCP/core, Python API, and LoopFlow related recommendations; Phase 4A adds CLI parity for IDs, TLDR, reasons, selected/rejected inputs, and related rows; Phase 5A adds runtime dashboard/API parity for persisted selection and token usage; Phase 5B adds dashboard recommendation parity; Phase 7 passed full pytest (4431 passed, 2 skipped) and ci_preflight --profile pr (19/19)."
-QA-001,QA,Regression suite,"As a maintainer, I can ship without breaking existing recommendation/telemetry/dashboard behavior.","Focused milestone tests, ruff, mypy, full pytest, ci_preflight, and no-mistakes pass.","src/tests; scripts/ci_preflight.py; no-mistakes gate","python scripts/ci_preflight.py --profile pr; no-mistakes axi run --intent ...",Needs Validation,Critical,11,2026-07-02,"Phase 2 slices passed; Phase 3A passed: 142 passed; Phase 3B usage persistence/metrics slice passed: 70 passed plus ruff, format, and mypy; Phase 4A CLI selection slice passed: 6 passed plus ruff, format, and mypy; Phase 4B runtime attribution slice passed: 72 passed plus ruff, format, and mypy; Phase 5A dashboard slice passed: 3 focused tests, 8 runtime monitor tests, 5 dashboard smoke/API tests plus ruff, format, and mypy; Phase 5B dashboard recommendation slice passed: 4 focused tests, full monitor 180 passed, ruff, format, and mypy; Phase 7 passed ruff format/check, mypy, full pytest (4431 passed, 2 skipped), ci_preflight --profile pr (19/19), stats check, docs build, and public tracker tests; no-mistakes remains deferred until after the canonical feature loop."
+QA-001,QA,Regression suite,"As a maintainer, I can ship without breaking existing recommendation/telemetry/dashboard behavior.","Focused milestone tests, ruff, mypy, full pytest, ci_preflight, and no-mistakes pass.","src/tests; scripts/ci_preflight.py; no-mistakes gate","python scripts/ci_preflight.py --profile pr; no-mistakes axi run --intent ...",Retested Pass,Critical,11,2026-07-05,"Phase 2 slices passed; Phase 3A passed: 142 passed; Phase 3B usage persistence/metrics slice passed: 70 passed plus ruff, format, and mypy; Phase 4A CLI selection slice passed: 6 passed plus ruff, format, and mypy; Phase 4B runtime attribution slice passed: 72 passed plus ruff, format, and mypy; Phase 5A dashboard slice passed: 3 focused tests, 8 runtime monitor tests, 5 dashboard smoke/API tests plus ruff, format, and mypy; Phase 5B dashboard recommendation slice passed: 4 focused tests, full monitor 180 passed, ruff, format, and mypy; Phase 7 passed ruff format/check, mypy, full pytest (4431 passed, 2 skipped), ci_preflight --profile pr (19/19), stats check, docs build, public tracker tests, and final no-mistakes validation in run 01KWSCY4EF01EXWSHYB5SGS4BC; post-merge inventory cleanup PR #239 also passed."

src/ctx/adapters/generic/ctx_core_tools.py

@@ -474,7 +474,8 @@ class CtxCoreToolbox:
                 name=f"{_NAMESPACE}wiki_get",
                 description=(
                     "Fetch a single wiki entity page by slug. Returns "
-                    "the full frontmatter (as a dict) and body text. "
+                    "the full frontmatter (as a dict), body text, and "
+                    "wiki-relative path. "
                     "Use after recommend_bundle / wiki_search to read "
                     "the detail of a specific candidate."
                 ),
@@ -878,7 +879,10 @@ class CtxCoreToolbox:
         return json.dumps(
             {
                 "error": f"no entity page found for slug {slug!r}",
-                "looked_in": [str(p) for _, p, _ in candidates],
+                "looked_in": [
+                    _wiki_entity_relpath(candidate_type, slug)
+                    for candidate_type, _, _ in candidates
+                ],
             }
         )
 
@@ -1003,7 +1007,7 @@ class CtxCoreToolbox:
                 "slug": path.stem,
                 "entity_type": entity_type,
                 "wikilink": wikilink,
-                "path": str(path),
+                "path": _wiki_entity_relpath(entity_type, path.stem),
                 "frontmatter": fm,
                 "body": body,
             },

src/ctx/adapters/generic/runtime_lifecycle.py

@@ -1,4 +1,10 @@
-"""Host-neutral runtime lifecycle logging for generic ctx integrations."""
+"""Host-neutral runtime lifecycle logging for generic ctx integrations.
+
+Runtime lifecycle events are local operational records, but user- or
+host-provided free text is still privacy-sensitive. The store redacts secrets
+and local paths from top-level lifecycle text, nested payloads, source context,
+and security-scan details before appending events.
+"""
 
 from __future__ import annotations
 
@@ -33,6 +39,7 @@ _ESCALATION_STATUSES = {"open", "resolved", "ignored"}
 _SELECTION_SOURCES = {"user", "system", "host", "unknown"}
 _TOKEN_ATTRIBUTIONS = {"exact", "estimated", "unavailable"}
 _LIFECYCLE_SANITIZER_CONFIG = {"enabled": True, "mode": "local_redacted"}
+_LIFECYCLE_FREE_TEXT_FIELDS = ("reason", "evidence", "command", "summary", "trigger", "status")
 _PATH_SEGMENT_RE = r"[^/\s'\"`<>|:;,\)\]]+"
 _UNIX_ABSOLUTE_PATH_RE = re.compile(rf"(?<![\w./-])/(?:{_PATH_SEGMENT_RE}/)+{_PATH_SEGMENT_RE}")
 _TILDE_PATH_RE = re.compile(rf"(?<![\w./-])~/(?:{_PATH_SEGMENT_RE}/)*{_PATH_SEGMENT_RE}")
@@ -52,7 +59,7 @@ _SECURITY_SCAN_STATUSES = {
 
 @dataclass(frozen=True)
 class RuntimeLifecycleStore:
-    """Append-only lifecycle event store for custom/API/local harnesses."""
+    """Append-only, privacy-redacted event store for custom/API/local harnesses."""
 
     root: Path | None = None
 
@@ -353,15 +360,23 @@ def _sanitize_lifecycle_event(event: dict[str, Any]) -> dict[str, Any]:
     security_scan = redacted.get("security_scan")
     if isinstance(security_scan, dict):
         redacted["security_scan"] = _sanitize_security_scan(security_scan)
+    for field in _LIFECYCLE_FREE_TEXT_FIELDS:
+        value = redacted.get(field)
+        if isinstance(value, str):
+            redacted[field] = _sanitize_free_text(value)
     cwd = redacted.pop("cwd", None)
     if isinstance(cwd, str) and cwd:
         redacted["cwd_hash"] = hash_identifier(cwd)
     return redacted
 
 
+def _sanitize_free_text(text: str) -> str:
+    return _redact_path_text(redact_secret_text(text))
+
+
 def _sanitize_security_scan(raw: Any) -> Any:
     if isinstance(raw, str):
-        return _redact_path_text(redact_secret_text(raw))
+        return _sanitize_free_text(raw)
     if isinstance(raw, list):
         return [_sanitize_security_scan(item) for item in raw]
     if isinstance(raw, tuple):
@@ -388,14 +403,10 @@ def _validate_session_id(raw: str) -> str:
 def _record_runtime_lifecycle_telemetry(event: dict[str, Any]) -> None:
     token_usage = event.get("token_usage")
     usage_attribution: str | None = None
+    total_tokens: Any = None
     if isinstance(token_usage, dict):
         usage_attribution = str(token_usage.get("attribution") or "unavailable")
         total_tokens = token_usage.get("total_tokens")
-        _record_token_usage_metrics(
-            event,
-            attribution=usage_attribution,
-            total_tokens=total_tokens if isinstance(total_tokens, int) else None,
-        )
     payload: dict[str, Any] = {
         "ctx.lifecycle.action": str(event.get("action") or ""),
         "ctx.payload.present": bool(event.get("payload")),
@@ -430,10 +441,16 @@ def _record_runtime_lifecycle_telemetry(event: dict[str, Any]) -> None:
         payload["ctx.usage.cost_usd"] = (
             float(cost_value) if isinstance(cost_value, (int, float)) else None
         )
-    if not telemetry_enabled():
-        return
     try:
         with telemetry_span():
+            if isinstance(token_usage, dict) and usage_attribution is not None:
+                _record_token_usage_metrics(
+                    event,
+                    attribution=usage_attribution,
+                    total_tokens=total_tokens if isinstance(total_tokens, int) else None,
+                )
+            if not telemetry_enabled():
+                return
             record_event(
                 "ctx.runtime_lifecycle.record",
                 source="ctx-runtime-lifecycle",

src/ctx/adapters/generic/tools/mcp_router.py

@@ -50,6 +50,13 @@ from dataclasses import dataclass, field
 from typing import Any, Iterator
 
 from ctx.adapters.generic.providers.base import ToolDefinition
+from ctx.telemetry import (
+    hash_identifier,
+    record_event,
+    telemetry_enabled,
+    telemetry_span,
+    traceparent_from_span,
+)
 
 _logger = logging.getLogger(__name__)
 
@@ -90,6 +97,69 @@ _TOKEN_VALUE_RE = re.compile(
 )
 
 
+def _duration_ms(started: float) -> float:
+    return (time.perf_counter() - started) * 1000.0
+
+
+def _current_trace_metadata(session_id: str | None) -> dict[str, str]:
+    if not telemetry_enabled():
+        return {}
+    meta: dict[str, str] = {}
+    traceparent = traceparent_from_span()
+    if traceparent is not None:
+        meta["traceparent"] = traceparent
+    if session_id:
+        meta["ctx.session.hash"] = hash_identifier(session_id)
+    return meta
+
+
+def _params_with_metadata(
+    params: dict[str, Any] | None,
+    *,
+    session_id: str | None,
+) -> dict[str, Any]:
+    out = dict(params or {})
+    meta = _current_trace_metadata(session_id)
+    if not meta:
+        return out
+    existing = out.get("_meta")
+    merged = dict(existing) if isinstance(existing, dict) else {}
+    merged.update(meta)
+    out["_meta"] = merged
+    return out
+
+
+def _record_mcp_client_tool_call(
+    *,
+    server: str,
+    tool: str,
+    session_id: str | None,
+    outcome: str,
+    duration_ms: float,
+    error_kind: str | None = None,
+) -> None:
+    payload: dict[str, Any] = {
+        "rpc.system": "jsonrpc",
+        "rpc.method": "tools/call",
+        "mcp.server.name": server,
+        "mcp.tool.name": tool,
+        "otel.status_code": "ERROR" if outcome == "error" else "OK",
+    }
+    try:
+        record_event(
+            "ctx.mcp.external_tool_call",
+            source="ctx-mcp-router",
+            transport="mcp-jsonrpc",
+            session_id=session_id,
+            outcome=outcome,
+            duration_ms=duration_ms,
+            error_kind=error_kind,
+            payload=payload,
+        )
+    except Exception:  # noqa: BLE001 - telemetry must never break tool execution.
+        pass
+
+
 def _default_child_env() -> dict[str, str]:
     """Return parent env entries that are process plumbing, not credentials."""
     child_env: dict[str, str] = {}
@@ -254,8 +324,9 @@ class McpClient:
     ``call_tool`` calls on the same client are serialized by a lock.
     """
 
-    def __init__(self, config: McpServerConfig) -> None:
+    def __init__(self, config: McpServerConfig, *, session_id: str | None = None) -> None:
         self._config = config
+        self._session_id = str(session_id or "").strip() or None
         self._proc: subprocess.Popen[bytes] | None = None
         self._lock = threading.Lock()
         self._next_id = 0
@@ -404,16 +475,48 @@ class McpClient:
 
         Raises ``McpServerError`` when the server reports an error.
         """
-        result = self._request(
-            "tools/call",
-            {"name": name, "arguments": arguments},
-        )
-        if result.get("isError"):
-            content = _flatten_content(result.get("content", []))
-            raise McpServerError(
-                f"tool '{name}' on '{self._config.name}' reported isError: {content}"
+        started = time.perf_counter()
+        recorded = False
+        with telemetry_span():
+            try:
+                result = self._request(
+                    "tools/call",
+                    {"name": name, "arguments": arguments},
+                )
+                if result.get("isError"):
+                    content = _flatten_content(result.get("content", []))
+                    _record_mcp_client_tool_call(
+                        server=self._config.name,
+                        tool=name,
+                        session_id=self._session_id,
+                        outcome="error",
+                        duration_ms=_duration_ms(started),
+                        error_kind="tool_error",
+                    )
+                    recorded = True
+                    raise McpServerError(
+                        f"tool '{name}' on '{self._config.name}' reported isError: {content}"
+                    )
+                output = _flatten_content(result.get("content", []))
+            except Exception as exc:
+                if not recorded:
+                    _record_mcp_client_tool_call(
+                        server=self._config.name,
+                        tool=name,
+                        session_id=self._session_id,
+                        outcome="error",
+                        duration_ms=_duration_ms(started),
+                        error_kind=type(exc).__name__,
+                    )
+                raise
+            _record_mcp_client_tool_call(
+                server=self._config.name,
+                tool=name,
+                session_id=self._session_id,
+                outcome="ok",
+                duration_ms=_duration_ms(started),
             )
-        return _flatten_content(result.get("content", []))
+            return output
 
     # ── JSON-RPC plumbing ─────────────────────────────────────────────────
 
@@ -434,7 +537,7 @@ class McpClient:
                 "jsonrpc": "2.0",
                 "id": request_id,
                 "method": method,
-                "params": params or {},
+                "params": _params_with_metadata(params, session_id=self._session_id),
             }
             try:
                 self._write_frame(request)
@@ -580,8 +683,14 @@ class McpRouter:
     distinguishes them.
     """
 
-    def __init__(self, configs: list[McpServerConfig]) -> None:
+    def __init__(
+        self,
+        configs: list[McpServerConfig],
+        *,
+        session_id: str | None = None,
+    ) -> None:
         self._configs = list(configs)
+        self._session_id = str(session_id or "").strip() or None
         self._clients: dict[str, McpClient] = {}
         self._started = False
 
@@ -594,7 +703,7 @@ class McpRouter:
             for cfg in self._configs:
                 if cfg.name in self._clients:
                     raise ValueError(f"duplicate MCP server name {cfg.name!r}")
-                client = McpClient(cfg)
+                client = McpClient(cfg, session_id=self._session_id)
                 client.start()
                 self._clients[cfg.name] = client
                 spawned.append(cfg.name)
@@ -680,8 +789,8 @@ def _flatten_content(content: list[Any] | None) -> str:
     """Concatenate a MCP tool-result content array into a single string.
 
     Text blocks pass through verbatim. Non-text blocks (image/resource)
-    are summarised with a short tag; the harness loop can grow
-    multi-modal tool results in a later phase.
+    are summarised with a short tag; resource URIs are deliberately
+    omitted so local paths and private identifiers do not leak.
     """
     if not content:
         return ""
@@ -697,8 +806,7 @@ def _flatten_content(content: list[Any] | None) -> str:
             mime = block.get("mimeType", "image/*")
             parts.append(f"[{mime} image omitted]")
         elif btype == "resource":
-            uri = block.get("resource", {}).get("uri", "<no-uri>")
-            parts.append(f"[resource: {uri}]")
+            parts.append("[resource omitted]")
         else:
             parts.append(f"[{btype or 'unknown'} block omitted]")
     return "".join(parts)

src/ctx/api.py

@@ -334,7 +334,8 @@ def wiki_get(
     ``entity_type`` optionally disambiguates duplicate slugs across
     skills, agents, MCP servers, and harnesses.
 
-    Result dict on hit: ``slug``, ``path``, ``frontmatter``, ``body``.
+    Result dict on hit: ``slug``, wiki-relative ``path``,
+    ``frontmatter``, ``body``.
     Errors (invalid slug, traversal attempt, file missing) all map to
     ``None`` — library callers get a simple "exists or not" contract.
     """

src/ctx/cli/run.py

@@ -28,6 +28,7 @@ import json
 import logging
 import math
 import os
+import re
 import shlex
 import sys
 import time
@@ -68,6 +69,7 @@ _GITHUB_MCP_CREDENTIAL_ENV = (
     "GITHUB_TOKEN",
     "GH_TOKEN",
 )
+_TRACE_ID_RE = re.compile(r"^[0-9a-f]{32}$")
 
 
 # ── Provider key-env defaults ───────────────────────────────────────────────
@@ -561,6 +563,45 @@ def _run_start_payload(
     }
 
 
+def _run_setup_failure_payload(args: argparse.Namespace, *, stage: str) -> dict[str, Any]:
+    model = args.model if isinstance(args.model, str) and args.model else None
+    provider_prefix = _model_provider_prefix(model) if model else None
+    payload: dict[str, Any] = {
+        "ctx.task.length": len(str(args.task or "")),
+        "ctx.ctx_tools.enabled": not args.no_ctx_tools,
+        "ctx.planner.enabled": bool(args.planner),
+        "ctx.evaluator.enabled": bool(args.evaluator),
+        "ctx.contract.enabled": bool(args.contract),
+        "ctx.run.failure_stage": stage,
+    }
+    if model:
+        payload["ctx.model"] = model
+    provider = args.provider or provider_prefix
+    if provider:
+        payload["ctx.provider"] = provider
+    if provider_prefix:
+        payload["ctx.provider_prefix"] = provider_prefix
+    return payload
+
+
+def _session_initial_trace_id(meta: dict[str, Any]) -> str | None:
+    value = meta.get("initial_trace_id") or meta.get("trace_id")
+    if not isinstance(value, str):
+        return None
+    if not _TRACE_ID_RE.fullmatch(value) or value == "0" * 32:
+        return None
+    return value
+
+
+def _with_previous_trace_id(
+    payload: dict[str, Any],
+    previous_trace_id: str | None,
+) -> dict[str, Any]:
+    if previous_trace_id:
+        payload["ctx.session.previous_trace_id"] = previous_trace_id
+    return payload
+
+
 def _resume_start_payload(
     args: argparse.Namespace,
     *,
@@ -571,8 +612,9 @@ def _resume_start_payload(
     restored_mcp_count: int,
     allow_count: int,
     deny_count: int,
+    previous_trace_id: str | None = None,
 ) -> dict[str, Any]:
-    return {
+    payload = {
         "ctx.model": model,
         "ctx.task.length": len(str(args.task or "")),
         "ctx.ctx_tools.enabled": use_ctx_tools,
@@ -582,6 +624,22 @@ def _resume_start_payload(
         "ctx.tool_policy.allow_count": allow_count,
         "ctx.tool_policy.deny_count": deny_count,
     }
+    return _with_previous_trace_id(payload, previous_trace_id)
+
+
+def _resume_setup_failure_payload(
+    args: argparse.Namespace,
+    *,
+    stage: str,
+    previous_trace_id: str | None = None,
+) -> dict[str, Any]:
+    payload: dict[str, Any] = {
+        "ctx.task.length": len(str(args.task or "")),
+        "ctx.run.failure_stage": stage,
+    }
+    if args.model:
+        payload["ctx.model"] = args.model
+    return _with_previous_trace_id(payload, previous_trace_id)
 
 
 def _loop_result_payload(result: Any) -> dict[str, Any]:
@@ -952,11 +1010,21 @@ def _build_parser() -> argparse.ArgumentParser:
 
 
 def _cmd_run(args: argparse.Namespace) -> int:
+    telemetry_started = time.perf_counter()
     profile_error = _apply_model_profile_defaults(args)
     if profile_error:
         print(profile_error, file=sys.stderr)
+        with telemetry_span():
+            _record_cli_telemetry(
+                "ctx.cli.run",
+                session_id=args.session_id,
+                phase="failed",
+                payload=_run_setup_failure_payload(args, stage="validation"),
+                outcome="error",
+                duration_ms=_duration_ms(telemetry_started),
+                error_kind="ValueError",
+            )
         return 2
-    telemetry_started = time.perf_counter()
 
     sdir = Path(args.sessions_dir) if args.sessions_dir else default_sessions_dir()
 
@@ -969,7 +1037,21 @@ def _cmd_run(args: argparse.Namespace) -> int:
     )
 
     session_id = args.session_id or new_session_id()
-    system_prompt = _resolve_system_prompt(args.system_prompt)
+    try:
+        system_prompt = _resolve_system_prompt(args.system_prompt)
+    except Exception as exc:
+        with telemetry_span():
+            _record_cli_telemetry(
+                "ctx.cli.run",
+                session_id=session_id,
+                phase="failed",
+                payload=_run_setup_failure_payload(args, stage="validation"),
+                outcome="error",
+                duration_ms=_duration_ms(telemetry_started),
+                error_kind=type(exc).__name__,
+                exc=exc,
+            )
+        raise
 
     # Planner pass (opt-in, SOLO path only — when --evaluator is set,
     # run_with_evaluation owns the planner call so the P/G/E agents
@@ -984,7 +1066,21 @@ def _cmd_run(args: argparse.Namespace) -> int:
             provider,
             model=args.planner_model or args.model,
         )
-        plan_artifact = planner.plan(args.task)
+        try:
+            plan_artifact = planner.plan(args.task)
+        except Exception as exc:
+            with telemetry_span():
+                _record_cli_telemetry(
+                    "ctx.cli.run",
+                    session_id=session_id,
+                    phase="failed",
+                    payload=_run_setup_failure_payload(args, stage="planner"),
+                    outcome="error",
+                    duration_ms=_duration_ms(telemetry_started),
+                    error_kind=type(exc).__name__,
+                    exc=exc,
+                )
+            raise
         system_prompt = augmented_system_prompt(system_prompt, plan_artifact)
         if not args.quiet:
             status = "ok" if plan_artifact.parsed_ok else "unstructured"
@@ -999,11 +1095,25 @@ def _cmd_run(args: argparse.Namespace) -> int:
     if ctx_tools_enabled:
         system_prompt = _with_ctx_session_instructions(system_prompt, session_id)
 
-    mcp_configs = _apply_mcp_env_overlays(
-        [_parse_mcp_spec(spec) for spec in args.mcp],
-        args.mcp_env,
-    )
-    router = McpRouter(mcp_configs) if mcp_configs else None
+    try:
+        mcp_configs = _apply_mcp_env_overlays(
+            [_parse_mcp_spec(spec) for spec in args.mcp],
+            args.mcp_env,
+        )
+    except Exception as exc:
+        with telemetry_span():
+            _record_cli_telemetry(
+                "ctx.cli.run",
+                session_id=session_id,
+                phase="failed",
+                payload=_run_setup_failure_payload(args, stage="validation"),
+                outcome="error",
+                duration_ms=_duration_ms(telemetry_started),
+                error_kind=type(exc).__name__,
+                exc=exc,
+            )
+        raise
+    router = McpRouter(mcp_configs, session_id=session_id) if mcp_configs else None
 
     # ctx-core tools.
     lifecycle = RuntimeLifecycleStore()
@@ -1034,52 +1144,73 @@ def _cmd_run(args: argparse.Namespace) -> int:
             "use --overwrite-session to replace it or ctx resume to continue it.",
             file=sys.stderr,
         )
+        with telemetry_span():
+            _record_cli_telemetry(
+                "ctx.cli.run",
+                session_id=session_id,
+                phase="failed",
+                payload=_run_setup_failure_payload(args, stage="session_create"),
+                outcome="error",
+                duration_ms=_duration_ms(telemetry_started),
+                error_kind="FileExistsError",
+            )
         return 1
     except ValueError as exc:
         print(f"error: {exc}", file=sys.stderr)
+        with telemetry_span():
+            _record_cli_telemetry(
+                "ctx.cli.run",
+                session_id=session_id,
+                phase="failed",
+                payload=_run_setup_failure_payload(args, stage="session_create"),
+                outcome="error",
+                duration_ms=_duration_ms(telemetry_started),
+                error_kind=type(exc).__name__,
+            )
         return 1
-    metadata = {
-        "task": args.task,
-        "model": args.model,
-        "provider": args.provider or _model_provider_prefix(args.model),
-        "provider_prefix": _model_provider_prefix(args.model),
-        "api_key_env": api_key_env or "",
-        "base_url": args.base_url or "",
-        "system_prompt": system_prompt,
-        "temperature": args.temperature,
-        "max_tokens": args.max_tokens,
-        "provider_timeout": args.provider_timeout,
-        "max_iterations": args.max_iterations,
-        "budget_usd": args.budget_usd,
-        "budget_tokens": args.budget_tokens,
-        "mcp": [
-            {
-                "name": c.name,
-                "command": c.command,
-                "args": list(c.args),
-                "credential_env": list(c.credential_env),
-            }
-            for c in mcp_configs
-        ],
-        "ctx_tools_enabled": ctx_tools_enabled,
-        "tool_policy": {"allow": list(allow_tools), "deny": list(deny_tools)},
-        "planner_used": plan_artifact is not None,
-        "contract_used": bool(args.evaluator and args.contract),
-        "evaluator_used": args.evaluator,
-        "evaluator_max_rounds": args.evaluator_rounds if args.evaluator else None,
-        "plan": plan_artifact.to_dict() if plan_artifact else None,
-        "plan_usage": (
-            {
-                "input_tokens": plan_artifact.usage.input_tokens,
-                "output_tokens": plan_artifact.usage.output_tokens,
-                "cost_usd": plan_artifact.usage.cost_usd,
-            }
-            if plan_artifact
-            else None
-        ),
-    }
-    observer = JsonlObserver(store, session_metadata=metadata)
-    with telemetry_span():
+    with telemetry_span() as span:
+        metadata = {
+            "task": args.task,
+            "model": args.model,
+            "provider": args.provider or _model_provider_prefix(args.model),
+            "provider_prefix": _model_provider_prefix(args.model),
+            "api_key_env": api_key_env or "",
+            "base_url": args.base_url or "",
+            "system_prompt": system_prompt,
+            "temperature": args.temperature,
+            "max_tokens": args.max_tokens,
+            "provider_timeout": args.provider_timeout,
+            "max_iterations": args.max_iterations,
+            "budget_usd": args.budget_usd,
+            "budget_tokens": args.budget_tokens,
+            "initial_trace_id": span.trace_id,
+            "mcp": [
+                {
+                    "name": c.name,
+                    "command": c.command,
+                    "args": list(c.args),
+                    "credential_env": list(c.credential_env),
+                }
+                for c in mcp_configs
+            ],
+            "ctx_tools_enabled": ctx_tools_enabled,
+            "tool_policy": {"allow": list(allow_tools), "deny": list(deny_tools)},
+            "planner_used": plan_artifact is not None,
+            "contract_used": bool(args.evaluator and args.contract),
+            "evaluator_used": args.evaluator,
+            "evaluator_max_rounds": args.evaluator_rounds if args.evaluator else None,
+            "plan": plan_artifact.to_dict() if plan_artifact else None,
+            "plan_usage": (
+                {
+                    "input_tokens": plan_artifact.usage.input_tokens,
+                    "output_tokens": plan_artifact.usage.output_tokens,
+                    "cost_usd": plan_artifact.usage.cost_usd,
+                }
+                if plan_artifact
+                else None
+            ),
+        }
+        observer = JsonlObserver(store, session_metadata=metadata)
         if ctx_tools_enabled:
             _record_lifecycle_safely(
                 lifecycle,
@@ -1131,6 +1262,18 @@ def _cmd_run(args: argparse.Namespace) -> int:
                 if args.contract and not args.planner:
                     # Contracts refine planner output; without a plan
                     # they'd have no prior spec to refine.
+                    _record_cli_telemetry(
+                        "ctx.cli.run",
+                        session_id=session_id,
+                        phase="failed",
+                        payload=_run_setup_failure_payload(
+                            args,
+                            stage="validation",
+                        ),
+                        outcome="error",
+                        duration_ms=_duration_ms(telemetry_started),
+                        error_kind="SystemExit",
+                    )
                     raise SystemExit(
                         "error: --contract requires --planner (the contract "
                         "refines the planner's success_criteria into "
@@ -1300,19 +1443,47 @@ def _load_session_for_cli(session_id: str, sessions_dir: Path) -> Any | None:
 
 
 def _cmd_resume(args: argparse.Namespace) -> int:
+    telemetry_started = time.perf_counter()
     sdir = Path(args.sessions_dir) if args.sessions_dir else default_sessions_dir()
     state = _load_session_for_cli(args.session_id, sdir)
     if state is None:
+        with telemetry_span():
+            _record_cli_telemetry(
+                "ctx.cli.resume",
+                session_id=args.session_id,
+                phase="failed",
+                payload=_resume_setup_failure_payload(
+                    args,
+                    stage="session_load",
+                ),
+                outcome="error",
+                duration_ms=_duration_ms(telemetry_started),
+                error_kind="SessionLoadError",
+            )
         return 1
-    telemetry_started = time.perf_counter()
 
     meta = state.metadata
+    previous_trace_id = _session_initial_trace_id(meta)
     model = args.model or meta.get("model")
     if not model:
         print(
             f"error: session {args.session_id!r} has no recorded model; pass --model explicitly.",
             file=sys.stderr,
         )
+        with telemetry_span():
+            _record_cli_telemetry(
+                "ctx.cli.resume",
+                session_id=args.session_id,
+                phase="failed",
+                payload=_resume_setup_failure_payload(
+                    args,
+                    stage="validation",
+                    previous_trace_id=previous_trace_id,
+                ),
+                outcome="error",
+                duration_ms=_duration_ms(telemetry_started),
+                error_kind="ValueError",
+            )
         return 1
 
     use_ctx_tools = bool(meta.get("ctx_tools_enabled", True))
@@ -1348,7 +1519,25 @@ def _cmd_resume(args: argparse.Namespace) -> int:
         timeout=provider_timeout,
     )
 
-    store = SessionStore.attach(args.session_id, sessions_dir=sdir)
+    try:
+        store = SessionStore.attach(args.session_id, sessions_dir=sdir)
+    except (FileNotFoundError, OSError, ValueError) as exc:
+        with telemetry_span():
+            _record_cli_telemetry(
+                "ctx.cli.resume",
+                session_id=args.session_id,
+                phase="failed",
+                payload=_resume_setup_failure_payload(
+                    args,
+                    stage="session_attach",
+                    previous_trace_id=previous_trace_id,
+                ),
+                outcome="error",
+                duration_ms=_duration_ms(telemetry_started),
+                error_kind=type(exc).__name__,
+                exc=exc,
+            )
+        raise
     observer = JsonlObserver(
         store,
         session_metadata={},
@@ -1362,7 +1551,7 @@ def _cmd_resume(args: argparse.Namespace) -> int:
     # transcript unless the user explicitly opts in for this resume.
     recorded_mcp_configs = _mcp_configs_from_metadata(meta)
     mcp_configs = recorded_mcp_configs if args.restore_session_mcp else []
-    router = McpRouter(mcp_configs) if mcp_configs else None
+    router = McpRouter(mcp_configs, session_id=args.session_id) if mcp_configs else None
 
     lifecycle = RuntimeLifecycleStore()
     extra_tools: list[ToolDefinition] = []
@@ -1424,6 +1613,7 @@ def _cmd_resume(args: argparse.Namespace) -> int:
                 restored_mcp_count=len(mcp_configs),
                 allow_count=len(allow_tools),
                 deny_count=len(deny_tools),
+                previous_trace_id=previous_trace_id,
             ),
             outcome="ok",
             duration_ms=_duration_ms(telemetry_started),
@@ -1464,7 +1654,10 @@ def _cmd_resume(args: argparse.Namespace) -> int:
                 "ctx.cli.resume",
                 session_id=args.session_id,
                 phase="failed",
-                payload=_loop_result_payload(result),
+                payload=_with_previous_trace_id(
+                    _loop_result_payload(result),
+                    previous_trace_id,
+                ),
                 outcome="error",
                 duration_ms=_duration_ms(telemetry_started),
                 error_kind=type(exc).__name__,
@@ -1488,7 +1681,10 @@ def _cmd_resume(args: argparse.Namespace) -> int:
             "ctx.cli.resume",
             session_id=args.session_id,
             phase="finished",
-            payload=_loop_result_payload(result),
+            payload=_with_previous_trace_id(
+                _loop_result_payload(result),
+                previous_trace_id,
+            ),
             outcome=outcome,
             duration_ms=_duration_ms(telemetry_started),
             error_kind=error_kind,

src/ctx/dashboard_docs.py

@@ -572,6 +572,20 @@ def sanitize_docs_html(rendered_html: str) -> str:
             return tag_html
         return html.escape(tag_html)
 
+    def has_active_url_scheme(value: str) -> bool:
+        normalised = re.sub(r"[\x00-\x20\x7f]+", "", html.unescape(value)).lower()
+        return normalised.startswith(("javascript:", "data:text/html"))
+
+    def neutralise_active_url_attr(match: re.Match[str]) -> str:
+        attr_name = match.group(1)
+        raw_value = match.group(2)
+        value = raw_value.strip()
+        if len(value) >= 2 and value[0] == value[-1] and value[0] in {"'", '"'}:
+            value = value[1:-1]
+        if has_active_url_scheme(value):
+            return f' {attr_name}="#"'
+        return match.group(0)
+
     for tag in dangerous_blocks:
         rendered_html = re.sub(
             rf"<\s*{tag}\b[^>]*>.*?<\s*/\s*{tag}\s*>",
@@ -608,8 +622,8 @@ def sanitize_docs_html(rendered_html: str) -> str:
         flags=re.IGNORECASE,
     )
     rendered_html = re.sub(
-        r"\s+(href|src)\s*=\s*(?:\"\s*(?:javascript:|data:text/html)[^\"]*\"|'\s*(?:javascript:|data:text/html)[^']*'|(?:javascript:|data:text/html)[^\s>]*)",
-        lambda match: f' {match.group(1)}="#"',
+        r"\s+(href|src|xlink:href|formaction)\s*=\s*(\"[^\"]*\"|'[^']*'|[^\s>]*)",
+        neutralise_active_url_attr,
         rendered_html,
         flags=re.IGNORECASE,
     )

src/ctx/mcp_server/server.py

@@ -69,7 +69,13 @@ from typing import Any, BinaryIO
 
 from ctx.adapters.generic.ctx_core_tools import CtxCoreToolbox
 from ctx.adapters.generic.providers import ToolCall
-from ctx.telemetry import hash_identifier, record_event, record_exception, telemetry_span
+from ctx.telemetry import (
+    hash_identifier,
+    parse_traceparent,
+    record_event,
+    record_exception,
+    telemetry_span,
+)
 
 
 _logger = logging.getLogger(__name__)
@@ -290,6 +296,39 @@ def _safe_mcp_payload(
     return payload
 
 
+def _jsonrpc_metadata(frame: dict[str, Any], params: object) -> dict[str, Any]:
+    metadata: dict[str, Any] = {}
+    for value in (frame.get("metadata"), frame.get("_meta")):
+        if isinstance(value, dict):
+            metadata.update(value)
+    if isinstance(params, dict) and isinstance(params.get("_meta"), dict):
+        metadata.update(params["_meta"])
+    return metadata
+
+
+def _trace_context_from_metadata(
+    frame: dict[str, Any],
+    params: object,
+) -> tuple[str | None, str | None]:
+    metadata = _jsonrpc_metadata(frame, params)
+    raw_traceparent = metadata.get("traceparent")
+    parsed = parse_traceparent(raw_traceparent) if isinstance(raw_traceparent, str) else None
+    if parsed is None:
+        return None, None
+    return parsed
+
+
+def _safe_metadata_payload(frame: dict[str, Any], params: object) -> dict[str, Any]:
+    metadata = _jsonrpc_metadata(frame, params)
+    payload: dict[str, Any] = {}
+    if isinstance(metadata.get("traceparent"), str):
+        payload["ctx.traceparent.received"] = parse_traceparent(metadata["traceparent"]) is not None
+    session_hash = metadata.get("ctx.session.hash")
+    if isinstance(session_hash, str) and session_hash.startswith("sha256:"):
+        payload["ctx.session.hash"] = session_hash
+    return payload
+
+
 def _mcp_result_payload(method: str, result: dict[str, Any]) -> dict[str, Any]:
     payload: dict[str, Any] = {}
     if method == "tools/list":
@@ -464,6 +503,8 @@ def _process_line(
         response_emitted=not is_notification,
         request_id_type=_request_id_type(frame),
     )
+    base_payload.update(_safe_metadata_payload(frame, params))
+    trace_id, parent_span_id = _trace_context_from_metadata(frame, params)
 
     if not isinstance(method, str) or not method:
         if not is_notification:
@@ -481,7 +522,7 @@ def _process_line(
             )
         return
 
-    with telemetry_span():
+    with telemetry_span(trace_id=trace_id, parent_span_id=parent_span_id):
         if is_notification:
             # Per spec we accept (and ignore) unknown notifications rather
             # than erroring — it lets hosts send progress/ping/cancel

src/ctx/monitor/api/readonly.py

@@ -109,7 +109,7 @@ def handle_readonly_route(
         slug = params["slug"]
         sidecar = deps.load_sidecar(slug, query.get("type"))
         if sidecar is None:
-            return ReadOnlyApiResponse(None, status=404, not_found_detail=f"no sidecar for {slug}")
+            return ReadOnlyApiResponse({"detail": f"no sidecar for {slug}"}, status=404)
         return ReadOnlyApiResponse(sidecar)
     if name == "api_graph":
         slug = params["slug"]

src/ctx/telemetry/__init__.py

@@ -439,19 +439,58 @@ def current_telemetry_span() -> TelemetrySpan | None:
     return _CURRENT_SPAN.get()
 
 
+def _valid_trace_id(value: str) -> bool:
+    return len(value) == 32 and value != "0" * 32 and all(ch in "0123456789abcdef" for ch in value)
+
+
+def _valid_span_id(value: str) -> bool:
+    return len(value) == 16 and value != "0" * 16 and all(ch in "0123456789abcdef" for ch in value)
+
+
+def traceparent_from_span(span: TelemetrySpan | None = None) -> str | None:
+    """Return a W3C traceparent header for ``span`` or the active span."""
+
+    resolved = span if span is not None else _CURRENT_SPAN.get()
+    if resolved is None:
+        return None
+    if not _valid_trace_id(resolved.trace_id) or not _valid_span_id(resolved.span_id):
+        return None
+    return f"00-{resolved.trace_id}-{resolved.span_id}-01"
+
+
+def parse_traceparent(value: str) -> tuple[str, str] | None:
+    """Parse W3C traceparent into ``(trace_id, parent_span_id)``."""
+
+    parts = value.strip().split("-")
+    if len(parts) != 4:
+        return None
+    version, trace_id, span_id, flags = parts
+    if version != "00" or len(flags) != 2:
+        return None
+    if not _valid_trace_id(trace_id) or not _valid_span_id(span_id):
+        return None
+    return trace_id, span_id
+
+
 @contextmanager
 def telemetry_span(
     *,
     trace_id: str | None = None,
     span_id: str | None = None,
+    parent_span_id: str | None = None,
 ) -> Iterator[TelemetrySpan]:
-    """Start a nested telemetry span using OpenTelemetry-compatible IDs."""
+    """Start a telemetry span using OpenTelemetry-compatible IDs.
+
+    An active span is always the parent. ``parent_span_id`` is used only when
+    importing an external trace, such as MCP ``traceparent`` metadata, with no
+    active local span.
+    """
 
     parent = _CURRENT_SPAN.get()
     span = TelemetrySpan(
         trace_id=trace_id or (parent.trace_id if parent is not None else uuid.uuid4().hex),
         span_id=span_id or secrets.token_hex(8),
-        parent_span_id=parent.span_id if parent is not None else None,
+        parent_span_id=parent.span_id if parent is not None else parent_span_id,
     )
     token = _CURRENT_SPAN.set(span)
     try: