Sync ctx 0f61777 (part 2)

GitHub commit: 0f617779a5a1f11f8714c8f61087eb80c1c492b4

qa/bug_smoke_status.csv

@@ -36,3 +36,20 @@ AUDIT-034,Security,Backup config,unsafe top_files entries,src/backup_config.py;
 AUDIT-035,Security,ctx run MCP inline specs,inline secret argv persistence,src/ctx/cli/run.py; src/tests/test_harness_cli_run.py,Hegel runtime audit found --mcp specs accepted token-looking argv that could be persisted in session metadata.,High,ctx run --mcp inline commands should reject secret-looking argv and direct users to --mcp-env.,parallel runtime audit + focused pytest,Retested Pass,Inline MCP command args accepted --token and ghp_ values before fix.,MCP secrets could be embedded in command args and session metadata.,Parse an --mcp spec containing --token or ghp_ before fix and inspect parsed args.,Use existing secret scanner in _parse_mcp_spec and fail with --mcp-env guidance.,Fixed,.venv/bin/python -m pytest src/tests/test_backup_config.py src/tests/test_backup_mirror.py src/tests/test_harness_cli_run.py -q --tb=short,PASS: runtime safety focused suite reported 154 passed and integrated bundle reported 500 passed.,2026-07-06,Codex,Reviewed by worker + local validation,Ponytail: block inline secret-looking args only; --mcp-env remains the supported credential path.,Closed; continue repo-wide discovery.
 AUDIT-036,Security,Wiki queue artifact promotion,arbitrary target_path overwrite,src/ctx/core/wiki/wiki_queue_worker.py; src/tests/test_wiki_queue_worker.py,Turing graph audit found queued artifact promotion trusted payload target_path and could replace arbitrary files.,High,Queued artifact promotion should only promote known graph and wiki artifact targets from sibling staged files.,parallel graph audit + focused pytest,Retested Pass,ARTIFACT_PROMOTION_JOB payload could promote /tmp/staged to /tmp/outside before fix.,Queue worker could overwrite files outside allowed graph artifact locations.,Enqueue artifact promotion with outside target_path and inspect overwritten outside file before fix.,Resolve paths validate exact allowed target names and require staged_path to equal target sibling .staged before promotion.,Fixed,.venv/bin/python -m pytest src/tests/test_wiki_queue_worker.py src/tests/test_wiki_queue.py src/tests/test_wiki_queue_producers.py src/tests/test_artifact_promotion.py -q --tb=short,PASS: wiki queue and artifact promotion suites reported 50 passed and integrated bundle reported 500 passed.,2026-07-06,Codex,Reviewed by worker + local validation,Ponytail: restrict promotion boundary only; known graph and wiki artifact promotions still work.,Closed; continue repo-wide discovery.
 AUDIT-037,CI Gate,Windows pytest matrix,no-mistakes POSIX shell wrapper tests,src/tests/test_no_mistakes_env.py; .github/workflows/test.yml; scripts/ci_required.py,Post-merge Tests run 28808683083 failed only on windows-latest py3.11 and py3.12 with WSL bash and no installed distributions.,High,CI shell-wrapper tests should run only where their POSIX contract is available and CI workflow changes should run the full OS pytest matrix before merge.,GitHub Actions log audit + focused regression tests,Retested Pass,Windows pytest executed POSIX no-mistakes shell-wrapper tests through a bash command that resolved to WSL without a distro.,Post-merge main CI failed after PR checks were green because pull_request skipped the full test matrix and CI required allowed that skip unconditionally.,Inspect run 28808683083 failed logs and compare pull_request test job condition to push matrix behavior.,Skip POSIX-only no-mistakes shell-wrapper tests on Windows and require the full pytest OS matrix for PRs that change CI workflow files.,Fixed,.venv/bin/python -m pytest src/tests/test_no_mistakes_env.py src/tests/test_ci_classifier.py -q --tb=short,PASS: focused no-mistakes env and CI classifier regressions pass locally; GitHub PR matrix will verify Windows.,2026-07-06,Codex,Reviewed by local CI audit,Ponytail: preserve fast PR skips for normal changes while pulling Windows matrix forward for CI changes.,Closed; continue repo-wide discovery.
+AUDIT-038,CI Gate,No-test policy,no-tests-needed label bypass,scripts/ci_no_test_policy.py; .github/workflows/test.yml; src/tests/test_ci_classifier.py,Workbench QA pair and CTO probe showed the no-tests-needed label exemption is implemented but missing focused test coverage and workflow exemption prose.,Medium,No-test policy exemptions should be explicit in workflow prose and covered by regression tests.,agent-reviewer workbench plus local policy probe,Retested Pass,2026-07-07,No-test label bypass is not documented in the workflow exemption comment and has no focused regression.,Call evaluate_policy for scripts/ci_classifier.py with no test file and the no-tests-needed label; it passes while rg finds no no-tests-needed assertion in focused tests.,Add focused regression for the label exemption and update the workflow policy comment.,Fixed,.venv/bin/python -m pytest src/tests/test_ci_classifier.py src/tests/test_ci_preflight.py -q --tb=short,PASS: no-test policy regression/prose covered; .venv/bin/python -m pytest src/tests/test_ci_classifier.py src/tests/test_ci_preflight.py src/tests/test_public_api.py -q --tb=short -> 127 passed; combined focused integration suite -> 487 passed.,2026-07-08,Codex,Reviewed by workbench agent pair + integration retest,Fixed in parallel backlog batch and retested with focused lane checks plus combined integration pytest.,Closed; keep covered by local-fast/no-mistakes gates.
+AUDIT-039,API Contract,Runtime/API public exports,documented adapter helpers not exported,src/ctx/api.py; src/ctx/__init__.py; src/tests/test_public_api.py,Runtime/API pair and CTO probe showed ctx_core_tool_names and recommendation_graph exist in ctx.api but are absent from ctx.api.__all__ and top-level ctx.,Medium,Public helper names documented as adapter API should have an explicit export contract or docs should stop presenting them as public imports.,agent-reviewer workbench plus import/export probe,Retested Pass,2026-07-07,Documented adapter helpers are not exported by ctx.api.__all__ or ctx.__all__.,Run PYTHONPATH=src import probe for ctx_core_tool_names and recommendation_graph; api_attr is true while api_all ctx_attr and ctx_all are false.,Either export the helpers with tests or narrow the public API documentation.,Fixed,.venv/bin/python -m pytest src/tests/test_public_api.py src/tests/test_loopflow_adapter.py -q --tb=short,PASS: adapter-helper public contract pinned as module-level adapter support; public API tests passed in 127-test gate and combined focused integration suite -> 487 passed.,2026-07-08,Codex,Reviewed by workbench agent pair + integration retest,Fixed in parallel backlog batch and retested with focused lane checks plus combined integration pytest.,Closed; keep covered by local-fast/no-mistakes gates.
+AUDIT-040,Privacy,MCP lifecycle output,absolute events_path in tool output,src/ctx/adapters/generic/runtime_lifecycle.py; src/ctx/adapters/generic/ctx_core_tools.py; src/ctx/mcp_server/server.py,Runtime/API pair and CTO probe showed ctx__load_entity returns an absolute events_path through the generic toolbox lifecycle dispatch.,Medium,MCP-facing lifecycle tool output should not expose local filesystem paths unless the caller explicitly asks for a local diagnostics field.,agent-reviewer workbench plus lifecycle dispatch probe,Retested Pass,2026-07-07,ctx__load_entity records successfully but returns an absolute events_path in model-facing JSON.,Dispatch ToolCall id 1 name ctx__load_entity through CtxCoreToolbox with temp lifecycle_dir and inspect payload events_path; it is absolute and exists.,Remove events_path from lifecycle tool responses while preserving local append-only recording.,Fixed,.venv/bin/python -m pytest src/tests/test_harness_ctx_core.py::TestRuntimeLifecycle src/tests/test_mcp_server.py -q --tb=short,PASS: 48 lifecycle and MCP server tests passed; lifecycle write responses omit events_path and temp roots while events.jsonl is still appended.,2026-07-07,Codex,Reviewed by Runtime/API actor/critic pair + local tests,Direct store output no longer serializes local path; toolbox and MCP payloads prove the path is not model-facing.,Closed; continue Phase 3 after approval.
+AUDIT-041,Tracker Hygiene,Feature tracker duplicate route rows,blank parent linkage for duplicate dashboard API routes,qa/feature_status.csv,Feature Mapper pair and CTO CSV probe found 14 same surface plus entrypoint groups with all parent_feature_id blank including API and DASH-API route rows.,Medium,Duplicate canonical feature rows for the same route should be parent-linked or explicitly allowed so reviewers do not update stale parallel rows.,agent-reviewer workbench plus CSV duplicate probe,Retested Pass,2026-07-07,Dashboard API route coverage appears as parallel canonical rows instead of parent-linked source coverage.,Parse qa/feature_status.csv group by lowercased surface and entrypoint_or_route and filter groups with all blank parent_feature_id; observe 14 groups.,Link dashboard-specific rows to canonical API parents or add a tracker hygiene allowlist for intentional duplicates.,Fixed,.venv/bin/python -m pytest src/tests/test_feature_user_story_tracker.py -q --tb=short,PASS: canonical tracker now parent-links duplicate Dashboard API route rows; src/tests/test_feature_user_story_tracker.py covered duplicate modeling; combined focused integration suite -> 487 passed.,2026-07-08,Codex,Reviewed by workbench agent pair + integration retest,Fixed in parallel backlog batch and retested with focused lane checks plus combined integration pytest.,Closed; keep covered by local-fast/no-mistakes gates.
+AUDIT-042,Tracker Hygiene,Harness CLI safety coverage,missing feature tracking for opt-in execution flags,qa/feature_status.csv; src/harness_install.py; docs/entity-onboarding.md; src/tests/test_harness_install.py,Feature Mapper pair found harness install safety flags in source docs and tests but not in qa/feature_status.csv.,High,Safety-critical harness install flags should be explicitly tracked in user-story coverage.,agent-reviewer workbench plus rg coverage probe,Retested Pass,2026-07-07,ctx-harness-install approve-commands run-verify and keep-files behavior is not named in the canonical feature tracker.,Run rg for --approve-commands --run-verify --keep-files across qa docs source and tests; source docs and tests hit but qa/feature_status.csv does not.,Add B-HAR-013 child feature row under CLI-048 and pin the three safety flags in the tracker coverage test.,Fixed,.venv/bin/python -m pytest src/tests/test_feature_user_story_tracker.py src/tests/test_harness_install.py -q --tb=short,PASS: tracker and harness install tests cover --approve-commands --run-verify and --keep-files as explicit safety behavior.,2026-07-08,Codex,Reviewed by Feature Mapper actor/critic pair + local tests,Tracker-only fix; behavior already existed in code docs and tests but now has first-class canonical story coverage.,Closed; continue Phase 4 after approval.
+AUDIT-043,Tracker Hygiene,Public docs tracker evidence,shared build evidence for per-page DOC-NAV rows,qa/feature_status.csv; src/tests/test_feature_user_story_tracker.py,Feature Mapper pair and CTO CSV probe showed all 27 DOC-NAV rows share the same mkdocs/nav evidence while promising page-specific behavior.,Medium,Per-page docs feature rows should either have page-specific evidence or be collapsed into one navigation/build feature row.,agent-reviewer workbench plus DOC-NAV CSV probe,Retested Pass,2026-07-07,DOC-NAV rows have unique stories but identical renderability evidence.,Parse qa/feature_status.csv for feature_id starting DOC-NAV; observe 27 rows with one unique evidence string and one unique test command string.,Collapse DOC-NAV rows or add page-specific content anchors and checks for each promised behavior.,Fixed,.venv/bin/python -m pytest src/tests/test_feature_user_story_tracker.py && .venv/bin/python -m mkdocs build --strict,PASS: DOC-NAV canonical rows now name page-specific evidence; src/tests/test_feature_user_story_tracker.py covered per-page evidence; combined focused integration suite -> 487 passed.,2026-07-08,Codex,Reviewed by workbench agent pair + integration retest,Fixed in parallel backlog batch and retested with focused lane checks plus combined integration pytest.,Closed; keep covered by local-fast/no-mistakes gates.
+AUDIT-044,Permission Model,Loopflow MCP handoff,no read-only subgroup scope for ctx MCP tools,src/ctx/adapters/loopflow.py; src/ctx/adapters/generic/ctx_core_tools.py; docs/harness/loopflow-adapter-demo.md,Loopflow pair and CTO probe showed ctx-mcp-server appears only when all capability groups are granted and then includes lifecycle write tools.,Medium,Loopflow should be able to request read-only ctx recommendation/wiki MCP tools without also granting lifecycle write tools.,agent-reviewer workbench plus loopflow permission probe,Retested Pass,2026-07-07,Loopflow MCP handoff is all-or-nothing and all grants expose lifecycle tools such as ctx__load_entity and ctx__record_validation.,Monkeypatch ctx_core_tool_names then call recommend_for_loop for mcps only skills+agents+mcps and all grants; only all grants returns ctx-mcp-server with lifecycle tools.,Split read-only recommendation/wiki tools from lifecycle/session-write tools behind explicit permission scope.,Fixed,.venv/bin/python -m pytest src/tests/test_loopflow_adapter.py src/tests/test_mcp_server.py -q --tb=short,PASS: Loopflow MCP handoff exposes read-only ctx tools for mcps grant and lifecycle tools only with all grants; loopflow/MCP tests passed; combined focused integration suite -> 487 passed.,2026-07-08,Codex,Reviewed by workbench agent pair + integration retest,Fixed in parallel backlog batch and retested with focused lane checks plus combined integration pytest.,Closed; keep covered by local-fast/no-mistakes gates.
+AUDIT-045,Permission Model,Loopflow harness ownership,implicit harness enablement from model metadata,src/ctx/adapters/loopflow.py; docs/harness/loopflow-adapter-demo.md,Loopflow pair and CTO probe showed own_llm false still returns harness recommendations when model_provider or model is supplied.,Medium,Harness recommendations should require explicit user model ownership consent rather than inferring ownership from ranking metadata.,agent-reviewer workbench plus loopflow harness probe,Retested Pass,2026-07-07,Passing model_provider or model unlocks dry-run harness recommendations even when own_llm is false.,Monkeypatch recommend_harnesses then call recommend_for_loop with permissions harnesses and own_llm false plus model_provider or model; harness_install is returned.,Make own_llm or explicit model_ownership authoritative and treat model fields as ranking metadata unless consent is set.,Fixed,.venv/bin/python -m pytest src/tests/test_loopflow_adapter.py -q --tb=short,PASS: harness recommendations require explicit own_llm consent; model/provider metadata alone stays blocked; loopflow tests passed; combined focused integration suite -> 487 passed.,2026-07-08,Codex,Reviewed by workbench agent pair + integration retest,Fixed in parallel backlog batch and retested with focused lane checks plus combined integration pytest.,Closed; keep covered by local-fast/no-mistakes gates.
+AUDIT-046,DSL Feature Gap,Loopflow .loop permissions,DSL cannot grant ctx capability groups,src/ctx/adapters/loopflow.py; docs/harness/loopflow-adapter-demo.md,Loopflow pair and CTO parse probe showed parse_loop_file ignores permissions and ctx permissions lines despite the owner ask for .loop capability grants.,Medium,Loopflow DSL files should be able to express ctx capability grants if the integration proposal promises DSL-native subgroup selection.,agent-reviewer workbench plus parse_loop_file probe,Retested Pass,2026-07-07,.loop files cannot grant capability groups today because parse_loop_file returns only source goal look_at and done_when fields.,Parse a temp .loop file containing permissions and ctx permissions lines; returned dict has no permissions field.,Add a small documented permission syntax and precedence between DSL grants and CLI/API grants.,Fixed,.venv/bin/python -m pytest src/tests/test_loopflow_adapter.py -q --tb=short,PASS: parse_loop_file supports ctx grants and CLI/API permissions override file grants; loopflow tests passed; combined focused integration suite -> 487 passed.,2026-07-08,Codex,Reviewed by workbench agent pair + integration retest,Fixed in parallel backlog batch and retested with focused lane checks plus combined integration pytest.,Closed; keep covered by local-fast/no-mistakes gates.
+AUDIT-047,Privacy,Telemetry redaction,raw host paths in arbitrary payload string values,src/ctx/telemetry/__init__.py; src/tests/test_enterprise_telemetry.py; docs/telemetry.md,Telemetry pair and CTO repro showed local_redacted hashes sensitive-looking keys but leaves a /Users path inside a safe_note string in spool and local export.,High,Local-redacted telemetry should not persist raw host paths inside arbitrary string payload values.,agent-reviewer workbench plus temp-spool telemetry probe,Retested Pass,2026-07-07,Payload value text can carry raw host paths into local telemetry and exported local_jsonl records.,Record event with payload safe_note containing /Users/example/private-repo/app.py then export to local_jsonl; raw and export both contain the path.,Hash local host path substrings in arbitrary payload string values and add spool/local export regression coverage.,Fixed,.venv/bin/python -m pytest src/tests/test_enterprise_telemetry.py -q,PASS: 67 enterprise telemetry tests passed; arbitrary safe_note and nested strings now contain path_hash markers and no raw host paths.,2026-07-07,Codex,Reviewed by Telemetry actor/critic pair + local tests,Exporter-boundary sanitization keeps local JSONL and OTLP payloads privacy-safe.,Closed; continue Phase 2 after approval.
+AUDIT-048,Privacy,Telemetry OTLP export,legacy raw payload exported remotely,src/ctx/telemetry/__init__.py; src/tests/test_enterprise_telemetry.py; docs/telemetry.md,Telemetry pair and CTO repro showed OTLP export trusts an existing local_redacted record with raw payload query and path values.,High,Remote exporters should re-sanitize legacy or manually repaired local telemetry before sending payload attributes.,agent-reviewer workbench plus monkeypatched OTLP export probe,Retested Pass,2026-07-07,Legacy local event payloads with raw query and path are serialized into OTLP attributes.,Write a TelemetryEvent JSONL record with privacy_mode local_redacted and raw payload query/path then monkeypatch _post_otlp_http and export_events; captured payload contains both values.,Re-sanitize event payloads and metric attributes at exporter boundary before local_jsonl or OTLP serialization.,Fixed,.venv/bin/python -m pytest src/tests/test_enterprise_telemetry.py -q,PASS: 67 enterprise telemetry tests passed; legacy raw event payload and metric attributes are re-sanitized before OTLP export.,2026-07-07,Codex,Reviewed by Telemetry actor/critic pair + local tests,Exporter boundary now protects legacy local repairs and older raw records before remote send.,Closed; continue Phase 2 after approval.
+AUDIT-049,Telemetry Export,Continuous checkpointing,backlog skipped after continuous export,src/ctx/telemetry/__init__.py; src/tests/test_enterprise_telemetry.py,Telemetry pair and CTO repro showed continuous event and metric export advances checkpoint to the newest record while older backlog remains unexported.,High,Enabling continuous export after a local backlog should not checkpoint past older unexported event or metric records.,agent-reviewer workbench plus event and metric checkpoint probes,Retested Pass,2026-07-07,Continuous export of the second record causes later batch export to skip the first event and first metric.,Record first event/metric with export disabled then second with export enabled and run batch export; later result is noop and first id is missing from exported JSONL.,Continuous export now drains pending event and metric spool ranges before checkpointing newest exported record.,Fixed,.venv/bin/python -m pytest src/tests/test_enterprise_telemetry.py -q,PASS: 67 enterprise telemetry tests passed; continuous event and metric export writes backlog in order checkpoints newest record and later batch export is noop.,2026-07-07,Codex,Reviewed by Telemetry actor/critic pair + local tests,Events and metrics now reuse pending-spool checkpoint semantics for continuous export.,Closed; continue Phase 2 after approval.
+AUDIT-050,UX,Dashboard home audit links,entity type omitted from wiki href,src/ctx/monitor/pages/home.py; src/ctx/monitor/compat.py; src/tests/test_ctx_monitor.py,Dashboard UX pair and CTO render probe showed Home latest audit rows link to /wiki/<slug> without preserving subject_type.,Medium,Dashboard audit links should include entity type when available so duplicate slugs navigate to the intended wiki entity.,agent-reviewer workbench plus render_home probe,Retested Pass,2026-07-07,Home audit links drop subject_type for agent MCP and harness rows.,Render home with recent_audit subject_type agent and subject shared-slug; output contains /wiki/shared-slug and not /wiki/shared-slug?type=agent.,Build typed audit hrefs using subject_type or event prefix and add focused dashboard test.,Fixed,.venv/bin/python -m pytest src/tests/test_ctx_monitor.py src/tests/test_dashboard_user_story_tracker.py -q --tb=short,PASS: dashboard home audit links include typed wiki hrefs when subject_type is present; monitor/dashboard tests passed; combined focused integration suite -> 487 passed.,2026-07-08,Codex,Reviewed by workbench agent pair + integration retest,Fixed in parallel backlog batch and retested with focused lane checks plus combined integration pytest.,Closed; keep covered by local-fast/no-mistakes gates.
+AUDIT-051,Graph Artifacts,Promotion metadata,stale current hash and size for graph tarballs,graph/wiki-graph.tar.gz.promotion.json; graph/wiki-graph-runtime.tar.gz.promotion.json; src/validate_graph_artifacts.py,Graph/Wiki pair and CTO artifact probe showed hydrated graph tarballs match stats but sibling promotion current metadata has stale size and sha256 values.,Medium,Promotion metadata should match current hydrated graph artifacts or validation should flag stale current metadata.,agent-reviewer workbench plus artifact hash probe,Retested Pass,2026-07-07,Graph promotion JSON current entries do not match actual wiki graph tarball size and sha256.,Compare actual size and sha256 for graph/wiki-graph.tar.gz and graph/wiki-graph-runtime.tar.gz to sibling promotion JSON current fields; both mismatch.,Refresh promotion metadata and add validator coverage for promotion current metadata drift.,Fixed,.venv/bin/python src/validate_graph_artifacts.py --graph-dir graph,PASS: validator rejects stale promotion current metadata and local ignored promotion JSON now matches tarball size/sha256; validate_graph_artifacts passed; combined focused integration suite -> 487 passed.,2026-07-08,Codex,Reviewed by workbench agent pair + integration retest,Fixed in parallel backlog batch and retested with focused lane checks plus combined integration pytest.,Closed; keep covered by local-fast/no-mistakes gates.
+AUDIT-052,Security,Wiki pack manifest,non-hex checksum accepted,src/ctx/core/wiki/wiki_packs.py; src/ctx/core/graph/graph_packs.py; src/tests/test_wiki_packs.py,Graph/Wiki pair and CTO manifest probe showed wiki pack checksums accept any 64-character string while graph packs require SHA-256 hex shape.,Low,Wiki pack manifest checksum validation should reject non-hex digest strings consistently with graph pack manifests.,agent-reviewer workbench plus manifest parser probe,Retested Pass,2026-07-07,WikiPackManifest accepts pages.jsonl checksum z repeated 64 times.,Call WikiPackManifest.from_mapping with a valid base manifest and checksums pages.jsonl z*64; it accepts while GraphPackManifest rejects graph.json z*64.,Use SHA-256 hex regex in wiki pack checksum validation and add regression test.,Fixed,.venv/bin/python -m pytest src/tests/test_wiki_packs.py src/tests/test_graph_packs.py -q,PASS: WikiPackManifest rejects non-hex SHA-256 checksums; wiki/graph pack tests passed; combined focused integration suite -> 487 passed.,2026-07-08,Codex,Reviewed by workbench agent pair + integration retest,Fixed in parallel backlog batch and retested with focused lane checks plus combined integration pytest.,Closed; keep covered by local-fast/no-mistakes gates.
+AUDIT-053,Docs,Dashboard route reference,missing supported routes and APIs,docs/dashboard.md; src/ctx/monitor/routes.py; src/tests/test_ctx_monitor.py,Docs/Runbook pair and CTO route diff showed dashboard docs omit /skillspector and APIs for skillspector grades and sidecars even though routes expose them.,Medium,Dashboard reference docs should list supported navigation routes and API routes that operators can use.,agent-reviewer workbench plus route-doc diff,Retested Pass,2026-07-07,Dashboard route reference omits SkillSpector and several supported JSON API routes.,Compare docs/dashboard.md text against ctx.monitor.routes; /skillspector /api/skillspector.json /api/grades.json and /api/sidecars.json are in routes but absent from docs.,Update docs/dashboard.md route and API reference and keep tracker tests passing.,Fixed,.venv/bin/python -m pytest src/tests/test_ctx_monitor.py src/tests/test_dashboard_user_story_tracker.py -q && .venv/bin/python -m mkdocs build --strict,PASS: dashboard docs now include SkillSpector and grades/sidecars/skillspector APIs; mkdocs build passed and combined focused integration suite -> 487 passed.,2026-07-08,Codex,Reviewed by workbench agent pair + integration retest,Fixed in parallel backlog batch and retested with focused lane checks plus combined integration pytest.,Closed; keep covered by local-fast/no-mistakes gates.
+AUDIT-054,Docs,Knowledge graph pre-ship gates,docs say two gates but list three shipped gates,docs/knowledge-graph.md; pyproject.toml; src/tests/test_package_scaffold.py,Docs/Runbook pair and CTO help probes showed docs/knowledge-graph.md says two advisory pre-ship gates while pyproject exposes three related gate commands.,Low,Knowledge graph runbook wording should match the shipped pre-ship gate commands.,agent-reviewer workbench plus CLI help probes,Retested Pass,2026-07-07,Knowledge graph docs say two advisory gates while ctx-dedup-check ctx-tag-backfill and ctx-skillspector-audit are all shipped commands.,Read docs/knowledge-graph.md pre-ship gates section and run help for all three console modules; all three commands print usage.,Change wording to three advisory gates or split SkillSpector into a separate release audit section.,Fixed,.venv/bin/python -m mkdocs build --strict,PASS: knowledge graph docs now describe three advisory gates; mkdocs build passed and combined focused integration suite -> 487 passed.,2026-07-08,Codex,Reviewed by workbench agent pair + integration retest,Fixed in parallel backlog batch and retested with focused lane checks plus combined integration pytest.,Closed; keep covered by local-fast/no-mistakes gates.

qa/tool-selection-token-history/SPEC.md

@@ -30,7 +30,7 @@ Supported recommendable entity types are shared through `ctx.core.entity_types.R
 - `mcp-server`
 - `harness`
 
-The current `ctx__recommend_bundle` core tool recommends `skill`, `agent`, and `mcp-server`. Harnesses are recommended as companion rows when model/provider context exists, and LoopFlow can request harness recommendations when `own_llm`, `model_provider`, or `model` is supplied.
+The current `ctx__recommend_bundle` core tool recommends `skill`, `agent`, and `mcp-server`. Harnesses are recommended as companion rows when model/provider context exists, and LoopFlow can request harness recommendations only when explicit user-owned model consent is supplied through `own_llm`; `model_provider` and `model` are ranking metadata.
 
 ## Existing Knowledge Graph Model
 

src/ctx/adapters/generic/ctx_core_tools.py

@@ -39,6 +39,11 @@ deciding how to place selected entities into context. Per-entity
 token usage is recorded only when the host supplies explicit
 ``ctx__mark_entity_used.token_usage`` attribution.
 
+Hosts that need a narrower permission surface can construct
+``CtxCoreToolbox`` with ``allowed_tool_names`` and ``allowed_entity_types``.
+That filters both tool discovery and read/query results before a model sees
+them.
+
 Plan 001 Phase H6.
 """
 
@@ -49,7 +54,7 @@ import json
 import logging
 import time
 from pathlib import Path
-from typing import Any, Callable, Mapping
+from typing import Any, Callable, Iterable, Mapping
 
 from ctx.adapters.generic.providers import ToolCall, ToolDefinition
 from ctx.adapters.generic.runtime_lifecycle import RuntimeLifecycleStore
@@ -59,6 +64,7 @@ from ctx.core.entity_types import (
     entity_relpath,
     entity_page_path,
     entity_wikilink,
+    normalize_entity_type,
 )
 from ctx.telemetry import hash_identifier, record_event, record_exception, telemetry_span
 
@@ -298,11 +304,15 @@ class CtxCoreToolbox:
         graph_path: Path | None = None,
         lifecycle_dir: Path | None = None,
         bound_session_id: str | None = None,
+        allowed_tool_names: Iterable[str] | None = None,
+        allowed_entity_types: Iterable[str] | None = None,
     ) -> None:
         self._wiki_dir = wiki_dir
         self._graph_path = graph_path
         self._lifecycle = RuntimeLifecycleStore(lifecycle_dir)
         self._bound_session_id = str(bound_session_id or "").strip() or None
+        self._allowed_tool_names = _normalise_allowed_tool_names(allowed_tool_names)
+        self._allowed_entity_types = _normalise_allowed_entity_types(allowed_entity_types)
         self._graph: Any | None = None  # networkx.Graph
         self._pages: list[Any] | None = None  # list[SkillPage]
         self._graph_signature: GraphSignature | None = None
@@ -499,6 +509,8 @@ class CtxCoreToolbox:
             ),
         ]
         definitions.extend(_lifecycle_tool_definitions(self._bound_session_id))
+        if self._allowed_tool_names is not None:
+            definitions = [td for td in definitions if td.name in self._allowed_tool_names]
         return definitions
 
     def dispatch(self, call: ToolCall) -> str:
@@ -511,6 +523,8 @@ class CtxCoreToolbox:
         """
         if not call.name.startswith(_NAMESPACE):
             raise ValueError(f"CtxCoreToolbox got a non-ctx call {call.name!r}")
+        if self._allowed_tool_names is not None and call.name not in self._allowed_tool_names:
+            raise ValueError(f"ctx-core tool not allowed: {call.name!r}")
         local_name = call.name[len(_NAMESPACE) :]
         args = call.arguments or {}
         started = time.perf_counter()
@@ -579,6 +593,10 @@ class CtxCoreToolbox:
         """True when this toolbox is the dispatcher for the given name."""
         return tool_name.startswith(_NAMESPACE)
 
+    def allows(self, tool_name: str) -> bool:
+        """True when this toolbox is allowed to expose the given ctx tool."""
+        return self._allowed_tool_names is None or tool_name in self._allowed_tool_names
+
     # ── Individual dispatchers ──────────────────────────────────────────
 
     def _dispatch_recommend(self, args: dict[str, Any]) -> str:
@@ -619,12 +637,22 @@ class CtxCoreToolbox:
         if use_semantic_query:
             self._refresh_semantic_cache_signature()
             semantic_cache_dir = _semantic_cache_dir(self._wiki_dir_resolved())
+        entity_types = tuple(
+            entity_type
+            for entity_type in ("skill", "agent", "mcp-server")
+            if self._entity_type_allowed(entity_type)
+        )
+        if not entity_types:
+            return _encode_response(
+                {"query": query, "tags": tags, "results": [], "companion_harnesses": []},
+                _response_format_from_args(args),
+            )
         raw = recommend_by_tags(
             graph,
             tags,
             top_n=top_k,
             query=query,
-            entity_types=("skill", "agent", "mcp-server"),
+            entity_types=entity_types,
             min_normalized_score=cfg.recommendation_min_normalized_score,
             use_semantic_query=use_semantic_query,
             semantic_cache_dir=semantic_cache_dir,
@@ -662,7 +690,7 @@ class CtxCoreToolbox:
                 model_provider=model_provider,
                 model=model,
             )
-            if model_provider or model
+            if (model_provider or model) and self._entity_type_allowed("harness")
             else []
         )
         return _encode_response(
@@ -714,6 +742,8 @@ class CtxCoreToolbox:
         )
         results: list[dict[str, Any]] = []
         for r in raw:
+            if not self._entity_type_allowed(str(r.get("type") or "")):
+                continue
             candidate_keys = _recommendation_selection_keys(
                 [_recommendation_identity(r), str(r.get("name") or "")]
             )
@@ -780,6 +810,7 @@ class CtxCoreToolbox:
                 "via": r.get("via", []),
             }
             for r in raw
+            if self._entity_type_allowed(str(r.get("type") or ""))
         ]
         return _encode_response(
             {"seeds": seeds, "results": results},
@@ -792,7 +823,11 @@ class CtxCoreToolbox:
             return json.dumps({"error": "query must be non-empty", "results": []})
         top_n = _clamp_int(args.get("top_n"), default=15, lo=1, hi=100)
 
-        pages = self._ensure_pages()
+        pages = [
+            page
+            for page in self._ensure_pages()
+            if self._entity_type_allowed(str(page.entity_type))
+        ]
         if not pages:
             return json.dumps(
                 {
@@ -836,6 +871,8 @@ class CtxCoreToolbox:
                     ),
                 }
             )
+        if entity_type and not self._entity_type_allowed(entity_type):
+            return json.dumps({"error": f"entity_type {entity_type!r} is not allowed"})
 
         # Validate — ctx-core's validator rejects traversal shapes.
         from ctx.core.wiki.wiki_utils import validate_skill_name  # noqa: PLC0415
@@ -849,7 +886,18 @@ class CtxCoreToolbox:
         if wiki is None:
             return json.dumps({"error": "wiki_dir not configured"})
 
-        candidates = _wiki_get_candidates(wiki, slug, entity_type or None)
+        candidate_entity_types = (
+            (entity_type,)
+            if entity_type
+            else tuple(
+                allowed_type
+                for allowed_type in RECOMMENDABLE_ENTITY_TYPES
+                if self._entity_type_allowed(allowed_type)
+            )
+        )
+        if not candidate_entity_types:
+            return json.dumps({"error": "no entity types are allowed"})
+        candidates = _wiki_get_candidates(wiki, slug, candidate_entity_types)
         try:
             pack_pages = _wiki_pack_pages(wiki)
         except Exception as exc:  # noqa: BLE001 - surface corrupt pack state to callers.
@@ -886,6 +934,9 @@ class CtxCoreToolbox:
             }
         )
 
+    def _entity_type_allowed(self, entity_type: str) -> bool:
+        return self._allowed_entity_types is None or entity_type in self._allowed_entity_types
+
     def _dispatch_lifecycle(self, args: dict[str, Any], name: str) -> str:
         try:
             session_id = self._lifecycle_session_id(args)
@@ -1107,15 +1158,39 @@ def _wiki_entity_link(slug: str, entity_type: str) -> str:
 def _wiki_get_candidates(
     wiki: Path,
     slug: str,
-    entity_type: str | None,
+    entity_types: Iterable[str],
 ) -> list[tuple[str, Path, str]]:
-    entity_types = [entity_type] if entity_type else list(RECOMMENDABLE_ENTITY_TYPES)
     return [
         (typ, _wiki_entity_path(wiki, slug, typ), _wiki_entity_link(slug, typ))
         for typ in entity_types
     ]
 
 
+def _normalise_allowed_tool_names(
+    tool_names: Iterable[str] | None,
+) -> frozenset[str] | None:
+    if tool_names is None:
+        return None
+    return frozenset(str(name).strip() for name in tool_names if str(name).strip())
+
+
+def _normalise_allowed_entity_types(
+    entity_types: Iterable[str] | None,
+) -> frozenset[str] | None:
+    if entity_types is None:
+        return None
+    normalised: list[str] = []
+    for raw in entity_types:
+        entity_type = normalize_entity_type(raw, allowed=RECOMMENDABLE_ENTITY_TYPES)
+        if entity_type is None:
+            raise ValueError(
+                "allowed_entity_types must contain only " + ", ".join(RECOMMENDABLE_ENTITY_TYPES)
+            )
+        if entity_type not in normalised:
+            normalised.append(entity_type)
+    return frozenset(normalised)
+
+
 def _wiki_pack_pages(wiki: Path) -> dict[str, str] | None:
     packs_dir = wiki / "wiki-packs"
     if not packs_dir.is_dir():

src/ctx/adapters/generic/runtime_lifecycle.py

@@ -321,7 +321,7 @@ class RuntimeLifecycleStore:
         with path.open("a", encoding="utf-8") as fh:
             fh.write(json.dumps(event, sort_keys=True) + "\n")
         _record_runtime_lifecycle_telemetry(event)
-        return {"ok": True, "event": event, "events_path": str(path), "recorded": True}
+        return {"ok": True, "event": event, "recorded": True}
 
     def _events_for_session(self, session_id: str) -> list[dict[str, Any]]:
         path = self.events_path

src/ctx/adapters/loopflow.py

@@ -30,8 +30,18 @@ _PERMISSION_ALIASES = {
 }
 _ENTITY_TO_GROUP = {"agent": "agents", "mcp-server": "mcps", "skill": "skills"}
 _GROUP_TO_ENTITY = {"skills": "skill", "agents": "agent", "mcps": "mcp-server"}
+_MCP_SCOPE_ENTITY_BY_GROUP = {"skills": "skill", "agents": "agent", "mcps": "mcp-server"}
 _CAPABILITY_KEYS = ("skills", "agents", "mcps", "harnesses")
 _ALL_CAPABILITY_GRANTS = frozenset(_CAPABILITY_KEYS)
+_READ_ONLY_MCP_TOOL_NAMES = frozenset(
+    {
+        "ctx__recommend_bundle",
+        "ctx__graph_query",
+        "ctx__recommend_related",
+        "ctx__wiki_search",
+        "ctx__wiki_get",
+    }
+)
 _HARNESS_REQUIREMENT_FLAGS = {
     "runtime": "--harness-runtime",
     "autonomy": "--harness-autonomy",
@@ -65,6 +75,10 @@ def _parse_permissions(values: list[str] | None) -> set[str]:
     return permissions
 
 
+def _ordered_permissions(permissions: set[str]) -> list[str]:
+    return [key for key in _CAPABILITY_KEYS if key in permissions]
+
+
 def parse_loop_file(path: Path) -> dict[str, Any]:
     """Extract the LoopFlow fields ctx needs from a .loop file.
 
@@ -88,6 +102,11 @@ def parse_loop_file(path: Path) -> dict[str, Any]:
     ]
     if done_when:
         fields["done_when"] = done_when
+    permission_grants: set[str] = set()
+    for match in re.finditer(r"^\s*ctx\s+grants?\s*:\s*(.+)$", text, flags=re.MULTILINE):
+        permission_grants.update(_parse_permissions([match.group(1)]))
+    if permission_grants:
+        fields["permissions"] = _ordered_permissions(permission_grants)
     return fields
 
 
@@ -272,9 +291,28 @@ def _harness_command(
 
 
 def _ctx_mcp_tool_names(permissions: set[str]) -> list[str]:
-    if not _ALL_CAPABILITY_GRANTS <= permissions:
+    if "mcps" not in permissions:
         return []
-    return ctx_api.ctx_core_tool_names()
+    tool_names = ctx_api.ctx_core_tool_names()
+    if _ALL_CAPABILITY_GRANTS <= permissions:
+        return tool_names
+    return [name for name in tool_names if name in _READ_ONLY_MCP_TOOL_NAMES]
+
+
+def _ctx_mcp_server_args(permissions: set[str], tool_names: list[str]) -> list[str]:
+    if not tool_names or _ALL_CAPABILITY_GRANTS <= permissions:
+        return []
+    entity_types = [
+        entity_type
+        for group, entity_type in _MCP_SCOPE_ENTITY_BY_GROUP.items()
+        if group in permissions
+    ]
+    return [
+        "--allow-tools",
+        ",".join(tool_names),
+        "--entity-types",
+        ",".join(entity_types),
+    ]
 
 
 def _normalize_harness_requirements(
@@ -407,11 +445,11 @@ def recommend_for_loop(
         warnings.append(
             "ignored unknown harness requirement(s): " + ", ".join(unknown_requirement_keys)
         )
-    should_recommend_harness = "harnesses" in granted and (
-        own_llm or bool(model_provider) or bool(model)
-    )
+    should_recommend_harness = "harnesses" in granted and own_llm
     if "harnesses" in granted and not should_recommend_harness:
-        warnings.append("harnesses permission granted but no user-owned LLM/model was declared")
+        warnings.append(
+            "harnesses permission granted but --own-llm/user-owned model consent was not declared"
+        )
     if should_recommend_harness:
         harness_query_parts = [
             goal or ranking_query,
@@ -444,6 +482,7 @@ def recommend_for_loop(
     if skill_names:
         use_skills = "use skills: " + ", ".join(skill_names)
     mcp_server_tools = _ctx_mcp_tool_names(granted)
+    mcp_server_args = _ctx_mcp_server_args(granted, mcp_server_tools)
     use_tools = 'use tools from the "ctx" server' if mcp_server_tools else None
     mcp_server_command = "ctx-mcp-server" if mcp_server_tools else None
 
@@ -463,6 +502,7 @@ def recommend_for_loop(
         "mcp_server": {
             "name": "ctx",
             "command": mcp_server_command,
+            "args": mcp_server_args,
             "tools": mcp_server_tools,
         },
         "capabilities": capability_bundle,
@@ -514,7 +554,10 @@ def _build_parser() -> argparse.ArgumentParser:
     parser.add_argument(
         "--permissions",
         action="append",
-        help="Comma-separated capability grants: skills, agents, mcps, harnesses.",
+        help=(
+            "Comma-separated capability grants: skills, agents, mcps, harnesses. "
+            "Overrides ctx grants in a .loop file."
+        ),
     )
     parser.add_argument(
         "--loop-kind",
@@ -540,8 +583,9 @@ def _build_parser() -> argparse.ArgumentParser:
 def main(argv: list[str] | None = None) -> int:
     parser = _build_parser()
     args = parser.parse_args(argv)
+    cli_permissions_provided = args.permissions is not None
     try:
-        permissions = _parse_permissions(args.permissions)
+        permissions = _parse_permissions(args.permissions) if cli_permissions_provided else set()
     except ValueError as exc:
         parser.error(str(exc))
 
@@ -551,6 +595,10 @@ def main(argv: list[str] | None = None) -> int:
             loop_fields = parse_loop_file(args.loop_file)
         except OSError as exc:
             parser.error(f"could not read --loop-file {args.loop_file}: {exc}")
+        except ValueError as exc:
+            parser.error(f"could not parse --loop-file {args.loop_file}: {exc}")
+    if not cli_permissions_provided:
+        permissions = set(loop_fields.get("permissions", []))
     goal = args.goal or str(loop_fields.get("goal") or "")
     if not goal:
         parser.error("--goal or a loop file with goal: is required")

src/ctx/api.py

@@ -53,7 +53,7 @@ Public functions:
         by default) — lets callers pre-build a custom CtxCoreToolbox
         pointed at a non-default location.
 
-Adapter support helpers:
+Adapter support helpers, not part of the stable public import contract:
 
     ctx_core_tool_names()
         Return ctx-core tool names exposed by the shared toolbox.
@@ -61,6 +61,11 @@ Adapter support helpers:
     recommendation_graph()
         Return the shared recommendation graph for adapter-side ranking.
 
+These remain module-level support for first-party adapters. They are
+intentionally omitted from ``__all__`` and from top-level ``ctx``
+re-exports; third-party callers that need adapter plumbing should use
+``CtxCoreToolbox`` directly.
+
 Plan 001 Phase H9.
 """
 

src/ctx/core/wiki/wiki_packs.py

@@ -11,6 +11,7 @@ from __future__ import annotations
 import argparse
 import hashlib
 import json
+import re
 import sys
 from dataclasses import dataclass
 from datetime import UTC, datetime
@@ -22,6 +23,7 @@ from ctx.utils._fs_utils import atomic_write_text
 WIKI_PACK_MANIFEST = "wiki-pack-manifest.json"
 WIKI_PACK_SCHEMA_VERSION = 1
 WIKI_PACK_TYPES = frozenset({"base", "overlay"})
+_SHA256_RE = re.compile(r"^[0-9a-f]{64}$")
 
 WikiPackType = Literal["base", "overlay"]
 
@@ -663,7 +665,7 @@ def _checksums(value: object) -> dict[str, str]:
             raise WikiPackManifestError("wiki pack manifest checksum names must be strings")
         name = raw_name.replace("\\", "/").strip()
         _validate_relative_name(name, "checksum name")
-        if not isinstance(raw_digest, str) or len(raw_digest) != 64:
+        if not isinstance(raw_digest, str) or not _SHA256_RE.match(raw_digest):
             raise WikiPackManifestError(
                 f"wiki pack manifest checksum for {name} must be a SHA-256 hex digest"
             )

src/ctx/mcp_server/__init__.py

@@ -18,6 +18,8 @@ Tools exposed:
       runtime lifecycle records and session state
 
 Console script: ``ctx-mcp-server``.
+Use ``--allow-tools`` and ``--entity-types`` to expose a scoped subset for
+permissioned adapters.
 
 Host examples that can attach this server:
   Claude Code:        claude mcp add ctx-wiki -- ctx-mcp-server

src/ctx/mcp_server/server.py

@@ -22,6 +22,9 @@ Install into any MCP-aware host:
 
     <host-specific config pointing at the ``ctx-mcp-server`` binary>
 
+Permissioned adapters can pass ``--allow-tools`` and ``--entity-types`` to
+expose only selected ctx tools and entity types.
+
 Tools exposed (same as ctx.adapters.generic.ctx_core_tools — that
 module is the source of truth for the tool catalogue):
 
@@ -60,15 +63,17 @@ Plan 001 Phase H8.
 
 from __future__ import annotations
 
+import argparse
 import json
 import logging
 import sys
 import time
 from dataclasses import dataclass
-from typing import Any, BinaryIO
+from typing import Any, BinaryIO, Iterable
 
 from ctx.adapters.generic.ctx_core_tools import CtxCoreToolbox
 from ctx.adapters.generic.providers import ToolCall
+from ctx.core.entity_types import RECOMMENDABLE_ENTITY_TYPES, normalize_entity_type
 from ctx.telemetry import (
     hash_identifier,
     parse_traceparent,
@@ -100,10 +105,15 @@ class _ServerState:
 
     initialized: bool = False
     toolbox: CtxCoreToolbox | None = None
+    allowed_tool_names: frozenset[str] | None = None
+    allowed_entity_types: frozenset[str] | None = None
 
     def ensure_toolbox(self) -> CtxCoreToolbox:
         if self.toolbox is None:
-            self.toolbox = CtxCoreToolbox()
+            self.toolbox = CtxCoreToolbox(
+                allowed_tool_names=self.allowed_tool_names,
+                allowed_entity_types=self.allowed_entity_types,
+            )
         return self.toolbox
 
 
@@ -166,7 +176,7 @@ def _handle_tools_call(state: _ServerState, params: dict[str, Any]) -> dict[str,
     if not isinstance(arguments, dict):
         raise _JsonRpcError(_ErrorCode.INVALID_PARAMS, "params.arguments must be an object")
 
-    if not toolbox.owns(name):
+    if not toolbox.owns(name) or not toolbox.allows(name):
         raise _JsonRpcError(
             _ErrorCode.METHOD_NOT_FOUND,
             f"tool not found: {name!r}. Known prefix: ctx__",
@@ -390,6 +400,40 @@ def _record_mcp_request(
         pass
 
 
+def _csv_items(values: Iterable[str] | None) -> list[str]:
+    if values is None:
+        return []
+    items: list[str] = []
+    for value in values:
+        items.extend(piece.strip() for piece in value.split(",") if piece.strip())
+    return items
+
+
+def _normalise_allowed_tool_names(
+    tool_names: Iterable[str] | None,
+) -> frozenset[str] | None:
+    if tool_names is None:
+        return None
+    return frozenset(str(name).strip() for name in tool_names if str(name).strip())
+
+
+def _normalise_allowed_entity_types(
+    entity_types: Iterable[str] | None,
+) -> frozenset[str] | None:
+    if entity_types is None:
+        return None
+    normalised: list[str] = []
+    for raw in entity_types:
+        entity_type = normalize_entity_type(raw, allowed=RECOMMENDABLE_ENTITY_TYPES)
+        if entity_type is None:
+            raise ValueError(
+                "allowed entity types must be one of " + ", ".join(RECOMMENDABLE_ENTITY_TYPES)
+            )
+        if entity_type not in normalised:
+            normalised.append(entity_type)
+    return frozenset(normalised)
+
+
 class _JsonRpcError(Exception):
     """Raised inside a handler to emit an RPC-level error response."""
 
@@ -406,6 +450,9 @@ class _JsonRpcError(Exception):
 def run_server(
     stdin: BinaryIO | None = None,
     stdout: BinaryIO | None = None,
+    *,
+    allowed_tool_names: Iterable[str] | None = None,
+    allowed_entity_types: Iterable[str] | None = None,
 ) -> int:
     """Read JSON-RPC frames from ``stdin`` until EOF, write to ``stdout``.
 
@@ -418,7 +465,10 @@ def run_server(
     """
     in_stream: BinaryIO = stdin if stdin is not None else sys.stdin.buffer
     out_stream: BinaryIO = stdout if stdout is not None else sys.stdout.buffer
-    state = _ServerState()
+    state = _ServerState(
+        allowed_tool_names=_normalise_allowed_tool_names(allowed_tool_names),
+        allowed_entity_types=_normalise_allowed_entity_types(allowed_entity_types),
+    )
 
     try:
         while True:
@@ -635,8 +685,29 @@ def _write_error(
 # ── CLI entry ─────────────────────────────────────────────────────────────
 
 
-def main() -> int:
+def main(argv: list[str] | None = None) -> int:
     """Entry point for the ``ctx-mcp-server`` console script."""
+    parser = argparse.ArgumentParser(description="Run the ctx MCP stdio server.")
+    parser.add_argument(
+        "--allow-tools",
+        action="append",
+        help="Comma-separated ctx tool names to expose. Omit to expose all ctx tools.",
+    )
+    parser.add_argument(
+        "--entity-types",
+        action="append",
+        help=(
+            "Comma-separated entity types allowed in read/query results. "
+            "Omit to expose every recommendable entity type."
+        ),
+    )
+    args = parser.parse_args(argv)
+    allowed_entity_types = _csv_items(args.entity_types) if args.entity_types is not None else None
+    try:
+        _normalise_allowed_entity_types(allowed_entity_types)
+    except ValueError as exc:
+        parser.error(str(exc))
+
     # Keep logging on stderr so it doesn't corrupt the stdout JSON-RPC
     # stream. Level defaults to WARNING — hosts typically don't want
     # debug noise unless the user opts in.
@@ -645,7 +716,10 @@ def main() -> int:
         level=logging.WARNING,
         format="%(asctime)s ctx-mcp-server %(levelname)s %(message)s",
     )
-    return run_server()
+    return run_server(
+        allowed_tool_names=_csv_items(args.allow_tools) if args.allow_tools is not None else None,
+        allowed_entity_types=allowed_entity_types,
+    )
 
 
 if __name__ == "__main__":

src/ctx/monitor/pages/home.py

@@ -5,11 +5,19 @@ from __future__ import annotations
 import html
 from collections.abc import Callable
 from typing import Any
+from urllib.parse import quote
 
 LayoutFn = Callable[[str, str], str]
 FormatCountFn = Callable[[int], str]
 
 
+def _audit_subject_href(row: dict[str, Any]) -> str:
+    subject = str(row.get("subject") or "")
+    subject_type = str(row.get("subject_type") or "")
+    suffix = f"?type={quote(subject_type)}" if subject_type else ""
+    return f"/wiki/{quote(subject)}{suffix}"
+
+
 def render_home(
     *,
     manifest: dict[str, Any],
@@ -49,7 +57,7 @@ def render_home(
     audit_rows = "".join(
         f"<tr><td class='muted'>{html.escape((row.get('ts') or '')[-8:])}</td>"
         f"<td><span class='pill'>{html.escape(row.get('event', ''))}</span></td>"
-        f"<td><a href='/wiki/{html.escape(row.get('subject', ''))}'><code>{html.escape(row.get('subject', ''))}</code></a></td>"
+        f"<td><a href='{html.escape(_audit_subject_href(row))}'><code>{html.escape(row.get('subject', ''))}</code></a></td>"
         "</tr>"
         for row in reversed(recent_audit)
     )

src/ctx/telemetry/__init__.py

@@ -13,13 +13,14 @@ import ipaddress
 import json
 import math
 import os
+import re
 import secrets
 import sys
 import traceback
 import uuid
 from contextlib import contextmanager
 from contextvars import ContextVar
-from dataclasses import asdict, dataclass, field
+from dataclasses import asdict, dataclass, field, replace
 from datetime import datetime, timedelta, timezone
 from importlib.metadata import PackageNotFoundError, version as package_version
 from pathlib import Path
@@ -131,6 +132,20 @@ _RAW_VALUE_KEY_SUFFIXES = (
     "_project_url",
 )
 _SCALAR_TYPES = (str, int, float, bool, type(None))
+_PATH_TEXT_SEGMENT_RE = r"[^/\\\s'\"`<>|:;,\)\]]+"
+_POSIX_LOCAL_HOST_PATH_RE = re.compile(
+    rf"(?<![\w./-])/(?:Users|home|private|tmp|var)(?:/{_PATH_TEXT_SEGMENT_RE})+"
+)
+_TILDE_LOCAL_HOST_PATH_RE = re.compile(rf"(?<![\w./-])~(?:/{_PATH_TEXT_SEGMENT_RE})+")
+_WINDOWS_LOCAL_HOST_PATH_RE = re.compile(
+    r"(?<![\w./-])[A-Za-z]:[\\/](?:[^/\\\s'\"`<>|:;,\)\]]+[\\/])*"
+    r"[^/\\\s'\"`<>|:;,\)\]]+"
+)
+_LOCAL_HOST_PATH_PATTERNS = (
+    _POSIX_LOCAL_HOST_PATH_RE,
+    _TILDE_LOCAL_HOST_PATH_RE,
+    _WINDOWS_LOCAL_HOST_PATH_RE,
+)
 
 
 def _raw_value_key_like(normalized_key: str) -> bool:
@@ -594,38 +609,38 @@ def record_event(
         return None
     if settings["export_enabled"]:
         started_at = _now_iso()
-        result = _export_events([event], settings=settings, trusted_root=trusted_root)
-        checkpoint_path = _export_checkpoint_path(
-            settings,
-            source_path=target,
-            trusted_root=trusted_root,
-        )
-        checkpoint_before_event_id = _read_export_checkpoint(
-            checkpoint_path,
+        pending = _events_pending_export(
+            target,
             settings=settings,
-            source_path=target,
+            trusted_root=trusted_root,
+            include_exported=False,
         )
+        last_event = pending.events[-1] if pending.events else None
+        result = _export_events(pending.events, settings=settings, trusted_root=trusted_root)
+        checkpoint_path = pending.checkpoint_path
+        checkpoint_before_event_id = pending.checkpoint_before_event_id
         checkpoint_after_event_id = checkpoint_before_event_id
         checkpoint_advanced = False
         last_success_at = None
         last_success_event_id = None
-        if result.failed == 0 and result.exported:
-            _write_export_checkpoint(
-                settings,
-                source_path=target,
-                event=event,
-                trusted_root=trusted_root,
-            )
-            checkpoint_after_event_id = event.event_id
-            checkpoint_advanced = checkpoint_after_event_id != checkpoint_before_event_id
+        if result.failed == 0 and result.exported and last_event is not None:
             last_success_at = _now_iso()
-            last_success_event_id = event.event_id
+            last_success_event_id = last_event.event_id
+            if pending.malformed_pending_records == 0:
+                _write_export_checkpoint(
+                    settings,
+                    source_path=target,
+                    event=last_event,
+                    trusted_root=trusted_root,
+                )
+                checkpoint_after_event_id = last_event.event_id
+                checkpoint_advanced = checkpoint_after_event_id != checkpoint_before_event_id
         status_path = _export_status_path(
             settings,
             source_path=target,
             trusted_root=trusted_root,
         )
-        status = "failed" if result.failed else ("ok" if result.exported else "noop")
+        status = _export_status(result, pending=pending)
         final_result = ExportResult(
             attempted=result.attempted,
             exported=result.exported,
@@ -635,11 +650,15 @@ def record_event(
             error_kind=result.error_kind,
             checkpoint_path=str(checkpoint_path),
             last_event_id=checkpoint_after_event_id,
+            malformed_records=pending.malformed_total_records,
+            malformed_pending_records=pending.malformed_pending_records,
+            malformed_first_line=pending.malformed_first_line,
+            malformed_last_line=pending.malformed_last_line,
             status_path=str(status_path),
             checkpoint_before_event_id=checkpoint_before_event_id,
             checkpoint_after_event_id=checkpoint_after_event_id,
             checkpoint_advanced=checkpoint_advanced,
-            checkpoint_found=checkpoint_before_event_id is not None,
+            checkpoint_found=pending.checkpoint_found,
             destination_hash=_export_destination_hash(settings),
             last_success_at=last_success_at,
             last_success_event_id=last_success_event_id,
@@ -1904,6 +1923,38 @@ def _is_forbidden_otlp_ip(host: str) -> bool:
     )
 
 
+def _sanitize_event_for_export(
+    event: TelemetryEvent,
+    settings: Mapping[str, Any],
+) -> TelemetryEvent:
+    payload = _sanitize_payload(
+        dict(event.payload),
+        privacy_mode=event.privacy_mode,
+        hash_salt=settings["hash_salt"],
+        max_keys=int(settings["max_payload_keys"]),
+        max_value_len=int(settings["max_payload_value_chars"]),
+    )
+    if payload == dict(event.payload):
+        return event
+    return replace(event, payload=payload)
+
+
+def _sanitize_metric_for_export(
+    metric: TelemetryMetric,
+    settings: Mapping[str, Any],
+) -> TelemetryMetric:
+    attributes = _sanitize_payload(
+        dict(metric.attributes),
+        privacy_mode=metric.privacy_mode,
+        hash_salt=settings["hash_salt"],
+        max_keys=int(settings["max_payload_keys"]),
+        max_value_len=int(settings["max_payload_value_chars"]),
+    )
+    if attributes == dict(metric.attributes):
+        return metric
+    return replace(metric, attributes=attributes)
+
+
 def _export_events(
     events: list[TelemetryEvent],
     *,
@@ -1914,10 +1965,15 @@ def _export_events(
     if not events:
         return ExportResult(attempted=0, exported=0, failed=0, sink=sink)
     try:
+        sanitized_events = [_sanitize_event_for_export(event, settings) for event in events]
         if sink == "local_jsonl":
-            _export_local_jsonl(events, Path(str(settings["export_path"])), trusted_root)
+            _export_local_jsonl(
+                sanitized_events,
+                Path(str(settings["export_path"])),
+                trusted_root,
+            )
         elif sink == "otlp_http":
-            _post_otlp_http(_otlp_logs_payload(events, settings), settings)
+            _post_otlp_http(_otlp_logs_payload(sanitized_events, settings), settings)
         else:
             return ExportResult(
                 attempted=len(events),
@@ -1946,38 +2002,38 @@ def _export_recorded_metric(
     trusted_root: Path | None,
 ) -> None:
     started_at = _now_iso()
-    result = _export_metrics([metric], settings=settings, trusted_root=trusted_root)
-    checkpoint_path = _metric_export_checkpoint_path(
-        settings,
-        source_path=source_path,
-        trusted_root=trusted_root,
-    )
-    checkpoint_before_metric_id = _read_metric_export_checkpoint(
-        checkpoint_path,
+    pending = _metrics_pending_export(
+        source_path,
         settings=settings,
-        source_path=source_path,
+        trusted_root=trusted_root,
+        include_exported=False,
     )
+    last_metric = pending.metrics[-1] if pending.metrics else None
+    result = _export_metrics(pending.metrics, settings=settings, trusted_root=trusted_root)
+    checkpoint_path = pending.checkpoint_path
+    checkpoint_before_metric_id = pending.checkpoint_before_metric_id
     checkpoint_after_metric_id = checkpoint_before_metric_id
     checkpoint_advanced = False
     last_success_at = None
     last_success_metric_id = None
-    if result.failed == 0 and result.exported:
-        _write_metric_export_checkpoint(
-            settings,
-            source_path=source_path,
-            metric=metric,
-            trusted_root=trusted_root,
-        )
-        checkpoint_after_metric_id = metric.metric_id
-        checkpoint_advanced = checkpoint_after_metric_id != checkpoint_before_metric_id
+    if result.failed == 0 and result.exported and last_metric is not None:
         last_success_at = _now_iso()
-        last_success_metric_id = metric.metric_id
+        last_success_metric_id = last_metric.metric_id
+        if pending.malformed_pending_records == 0:
+            _write_metric_export_checkpoint(
+                settings,
+                source_path=source_path,
+                metric=last_metric,
+                trusted_root=trusted_root,
+            )
+            checkpoint_after_metric_id = last_metric.metric_id
+            checkpoint_advanced = checkpoint_after_metric_id != checkpoint_before_metric_id
     status_path = _metric_export_status_path(
         settings,
         source_path=source_path,
         trusted_root=trusted_root,
     )
-    status = "failed" if result.failed else ("ok" if result.exported else "noop")
+    status = _metric_export_status(result, pending=pending)
     final_result = MetricExportResult(
         attempted=result.attempted,
         exported=result.exported,
@@ -1987,11 +2043,15 @@ def _export_recorded_metric(
         error_kind=result.error_kind,
         checkpoint_path=str(checkpoint_path),
         last_metric_id=checkpoint_after_metric_id,
+        malformed_records=pending.malformed_total_records,
+        malformed_pending_records=pending.malformed_pending_records,
+        malformed_first_line=pending.malformed_first_line,
+        malformed_last_line=pending.malformed_last_line,
         status_path=str(status_path),
         checkpoint_before_metric_id=checkpoint_before_metric_id,
         checkpoint_after_metric_id=checkpoint_after_metric_id,
         checkpoint_advanced=checkpoint_advanced,
-        checkpoint_found=checkpoint_before_metric_id is not None,
+        checkpoint_found=pending.checkpoint_found,
         destination_hash=_metric_export_destination_hash(settings),
         last_success_at=last_success_at,
         last_success_metric_id=last_success_metric_id,
@@ -2016,14 +2076,15 @@ def _export_metrics(
     if not metrics:
         return MetricExportResult(attempted=0, exported=0, failed=0, sink=sink)
     try:
+        sanitized_metrics = [_sanitize_metric_for_export(metric, settings) for metric in metrics]
         if sink == "local_jsonl":
             _export_local_metrics_jsonl(
-                metrics,
+                sanitized_metrics,
                 Path(str(settings["metric_export_path"])),
                 trusted_root,
             )
         elif sink == "otlp_http":
-            _post_otlp_http(_otlp_metrics_payload(metrics, settings), settings)
+            _post_otlp_http(_otlp_metrics_payload(sanitized_metrics, settings), settings)
         else:
             return MetricExportResult(
                 attempted=len(metrics),
@@ -2562,7 +2623,11 @@ def _otlp_metrics_payload(
                     {
                         "scope": {"name": "ctx.telemetry", "version": METRIC_SCHEMA_VERSION},
                         "metrics": [
-                            _otlp_metric_record(metric, settings=settings) for metric in metrics
+                            _otlp_metric_record(
+                                _sanitize_metric_for_export(metric, settings),
+                                settings=settings,
+                            )
+                            for metric in metrics
                         ],
                     }
                 ],
@@ -2661,6 +2726,13 @@ def _otlp_log_record(event: TelemetryEvent, *, settings: Mapping[str, Any]) -> d
     session_hash = event.session_hash
     if session_hash is None and event.session_id:
         session_hash = hash_identifier(event.session_id, salt=settings["hash_salt"])
+    payload = _sanitize_payload(
+        dict(event.payload),
+        privacy_mode=event.privacy_mode,
+        hash_salt=settings["hash_salt"],
+        max_keys=int(settings["max_payload_keys"]),
+        max_value_len=int(settings["max_payload_value_chars"]),
+    )
     attributes = {
         "event.name": event.event_name,
         "ctx.schema_version": event.schema_version,
@@ -2668,7 +2740,7 @@ def _otlp_log_record(event: TelemetryEvent, *, settings: Mapping[str, Any]) -> d
         "ctx.source": event.source,
         "ctx.outcome": event.outcome,
         "ctx.privacy_mode": event.privacy_mode,
-        **{f"ctx.payload.{key}": value for key, value in event.payload.items()},
+        **{f"ctx.payload.{key}": value for key, value in payload.items()},
     }
     optional = {
         "ctx.session.hash": session_hash,
@@ -2723,6 +2795,21 @@ def _otlp_value(value: Any) -> dict[str, Any]:
     return {"stringValue": json.dumps(value, sort_keys=True, default=str)}
 
 
+def _redact_local_host_paths(
+    text: str,
+    *,
+    hash_salt: str | bytes | None,
+) -> str:
+    redacted = text
+
+    def replacement(match: re.Match[str]) -> str:
+        return f"[path_hash:{hash_identifier(match.group(0), salt=hash_salt)}]"
+
+    for pattern in _LOCAL_HOST_PATH_PATTERNS:
+        redacted = pattern.sub(replacement, redacted)
+    return redacted
+
+
 def _sanitize_payload(
     payload: Mapping[str, Any],
     *,
@@ -2769,6 +2856,8 @@ def _sanitize_value(
     if isinstance(value, _SCALAR_TYPES):
         if isinstance(value, str):
             text = redact_secret_text(value)
+            if privacy_mode == DEFAULT_PRIVACY_MODE:
+                text = _redact_local_host_paths(text, hash_salt=hash_salt)
             if len(text) > max_value_len:
                 return text[:max_value_len] + "...[truncated]"
             return text