@event4u/agent-config 14.2.0 → 14.5.0

package/src/scripts/hook_manifest.yaml

@@ -19,6 +19,7 @@ concerns:
     args: [hook-dispatch]
     fail_closed: false
     severity: advisory
+    needs_payload_bodies: [result]
   # Hot-context working-memory cache (road-to-second-brain Phase 1).
   # stop: deterministic, redacted 400-word overwrite of
   # agents/runtime/state/hot-context.md from the chat-history JSONL.
@@ -43,11 +44,30 @@ concerns:
     args: []
     fail_closed: false
     severity: advisory
+  # Debounced since road-to-per-turn-hook-economy step 3.1 (D-3). It used to
+  # re-shell the dashboard regenerator through tsx on EVERY roadmap write — a
+  # cold tsx start per write, in exactly the roadmap-heavy workflow this repo
+  # runs. It now APPENDS the touched repo roots to a ledger on post_tool_use and
+  # regenerates ONCE from `stop` / `session_end`, which is why it is bound on
+  # three slots rather than one.
+  #
+  # The two extra bindings are paid for, not free additions to a capped chain:
+  # they REPLACE an unbounded number of per-write spawns with one per turn, and
+  # the flush path costs a read of one small JSON file when nothing is dirty.
+  # No flush binding on windsurf, deliberately — it has no post_tool_use surface,
+  # so nothing there ever marks the ledger.
+  #
+  # The ledger lives under `--project-dir`, not beside the edited file: a touched
+  # root may be a sibling worktree and `stop` carries no roadmap path, so a
+  # marker written at the target would be unfindable at flush time. A ledger that
+  # cannot be written makes the hook regenerate inline, so a broken state
+  # directory costs latency rather than a silently stale dashboard.
   roadmap-progress:
     script: src/scripts/roadmap_progress_hook.ts
     args: []
     fail_closed: false
     severity: advisory
+    needs_payload_bodies: [input]
   onboarding-gate:
     script: src/scripts/onboarding_gate_hook.ts
     args: []
@@ -71,6 +91,7 @@ concerns:
     args: []
     fail_closed: false
     severity: advisory
+    needs_payload_bodies: [input, result]
   # Phase 5 — Tier-1 hook for the minimal-safe-diff rule. Counts unique
   # files touched per turn into agents/runtime/state/minimal-safe-diff.json and
   # flips warning=true past hooks.minimal_safe_diff.threshold.
@@ -89,11 +110,13 @@ concerns:
     args: []
     fail_closed: false
     severity: advisory
+    needs_payload_bodies: [input]
   minimal-safe-diff:
     script: src/scripts/minimal_safe_diff_hook.ts
     args: []
     fail_closed: false
     severity: advisory
+    needs_payload_bodies: [input]
   # road-to-security-pillar.md P3.2 — PostToolUse prompt-injection scanner.
   # Warn-in-context (exit 2), never blocks. Default-OFF: no-ops unless
   # hooks.injection_scan.enabled is true in .agent-settings.yml. The runtime
@@ -103,6 +126,7 @@ concerns:
     args: []
     fail_closed: false
     severity: advisory
+    needs_payload_bodies: [input, result]
   # road-to-security-hardening Phase 3 — PreToolUse guard turning the
   # git-history-discipline Iron Law into a deterministic gate. Blocks
   # `git … --no-verify` / `-n` and `git -c core.hooksPath=…` (which would
@@ -115,6 +139,7 @@ concerns:
     args: []
     fail_closed: true
     severity: blocking
+    needs_payload_bodies: [input]
   # road-to-ai-employee-borrowings Phase 1 — kernel immutability Layer 1.
   # PreToolUse guard: DENIES Write/Edit/NotebookEdit (and cross-platform
   # equivalents) whose target path is a kernel rule file — the source tree
@@ -131,6 +156,7 @@ concerns:
     args: []
     fail_closed: true
     severity: blocking
+    needs_payload_bodies: [input]
   # road-to-renewal-leverage Phase 2 — "fix the code, not the config".
   # PreToolUse guard over the recorded allowlist-growth antipattern
   # (autonomous-execution § Antipattern): warns as an allowlist grows within a
@@ -146,6 +172,7 @@ concerns:
     args: []
     fail_closed: false
     severity: blocking
+    needs_payload_bodies: [input]
   # token-saving Phase 3 — PreToolUse RTK-wrap nudge. DETERMINISTIC: keys off a
   # live `which rtk` probe (not the self-reported flag). When rtk is installed
   # and the agent is about to run a single verbose CLI command that is NOT
@@ -159,6 +186,7 @@ concerns:
     args: []
     fail_closed: false
     severity: advisory
+    needs_payload_bodies: [input]
   # road-to-anti-slop-detector Phase 3 — OPTIONAL PreToolUse anti-slop nudge.
   # Runs the lint_design_slop registry against about-to-be-written UI content
   # and WARNS (exit 2) on P0/P1 aesthetic tells. Never blocks (flags, not
@@ -171,6 +199,7 @@ concerns:
     args: []
     fail_closed: false
     severity: advisory
+    needs_payload_bodies: [input]
   # road-to-frontend-skill-application Phase 4 — OPTIONAL PreToolUse UI-route
   # nudge. On a Write/Edit to a UI surface with no design consultation latched
   # this session, WARNS (exit 2) naming the route; a read or search touching a
@@ -186,6 +215,7 @@ concerns:
     args: []
     fail_closed: false
     severity: advisory
+    needs_payload_bodies: [input]
   # ADR-124 Phase 4 — OPTIONAL PreToolUse code-graph nudge. When a code-graph
   # source is present and the agent is about to search/read source, WARNS
   # (exit 2) once per session to query the graph first (or rebuild if stale,
@@ -216,6 +246,7 @@ concerns:
     # correct is the right trade, and the cheap filter is reserved for advisory
     # concerns whose set is provable from their own source.
     tools: [Grep, Glob, Read]
+    needs_payload_bodies: [input]
   # road-to-reachable-code-memory Phase 4 — session_end learning-sidecar
   # aggregation. Joins the EXISTING session_end concern set (no new platform
   # wiring). Aggregates agents/memory/intake/*.jsonl through the learning
@@ -293,6 +324,7 @@ concerns:
     args: []
     fail_closed: false
     severity: advisory
+    needs_payload_bodies: [input, result]
   # Language-mirror pin — carries the ONE fact the transcript cannot express:
   # which language the human actually typed. 47 skill/slash-command bodies were
   # measured arriving in the `user` role across 21 of 30 audited sessions, and
@@ -321,6 +353,7 @@ concerns:
     args: []
     fail_closed: true
     severity: blocking
+    needs_payload_bodies: [input]
   # Evaluator independence. Gates EVALUATION dispatches only. Two branches with
   # DIFFERENT severities, per the tier rule in
   # docs/contracts/hook-architecture-v1.md (§ What a concern may block on):
@@ -343,6 +376,7 @@ concerns:
     args: []
     fail_closed: false
     severity: blocking
+    needs_payload_bodies: [input]
   # Canary injection — deterministic carrier for the
   # session-canary rule (greet-by-name at task start + reply-close markers
   # as a user-observable context-degradation signal). Gated on
@@ -376,6 +410,19 @@ concerns:
     args: []
     fail_closed: false
     severity: advisory
+  # Org-telemetry disclosure (road-to-org-telemetry Phase 3.2; ADR-233 § D5).
+  # `org-pack` is the only consent class in this suite granted by somebody
+  # OTHER than the person it binds — an org administrator, once, for every
+  # install the pack reaches. Telling that person is what makes the grant
+  # legitimate rather than a courtesy on top of it. Emits once per
+  # (org_id, endpoint) pair and re-discloses when either changes, because a
+  # new sink is a new fact. An inactive install prints nothing and writes
+  # nothing. Advisory: it informs, it never blocks a session start.
+  telemetry-disclosure:
+    script: src/scripts/telemetry_disclosure_hook.ts
+    args: []
+    fail_closed: false
+    severity: advisory
   # Self-repair intake (road-to-self-repair Phase 1). Two slots, one queue:
   # user_prompt_submit opens a record when the user states the agent worked
   # wrongly and injects the open-queue line; stop runs the deterministic
@@ -432,6 +479,57 @@ concerns:
     fail_closed: false
     severity: advisory
     tools: [Agent, Task]
+    needs_payload_bodies: [input, result]
+  # road-to-org-telemetry Phase 1 (step 1.2) — Class-A usage capture. Fires
+  # only on a `Skill` tool-use completion, the event Phase 0's first spike
+  # confirmed carries the invoked skill name (`tool_input.skill`, present on
+  # 164 of 164 real invocations). Exists because the regex collector is blind
+  # to consumer installs by construction — spike 3 measured 0 of 89
+  # invocations detected on the set it reads.
+  #
+  # DEFAULT-OFF and then some: `read_remote_settings` activates only when
+  # `telemetry.remote.enabled` is true AND the org pack supplied an endpoint,
+  # an org id, and a salt. A clone of this repository carries the key names
+  # and no values, so it cannot reach the write path. Inactive ⇒ zero
+  # telemetry file operations and zero network calls.
+  #
+  # It appends to a LOCAL JSONL file and stops — no outbound call exists in
+  # this concern. Transport is Phase 2 (blocked on `sink-choice`); org-wide
+  # enablement is Phase 3 (blocked on `dpo-signoff`).
+  #
+  # BOUND ON SIX PLATFORMS, INERT ON MOST OF THEM — and that asymmetry is a
+  # reading caveat for Phase 4, not a defect to fix by unbinding. A `Skill`
+  # tool is a Claude-family surface; on a host that has none, this concern
+  # never fires and the org's record set carries no rows for it. A zero from
+  # such a host therefore means "no instrument", NOT "no adoption" — which is
+  # precisely the blind-zero class this roadmap exists to remove, so it must
+  # not be read as a measurement. Every record carries `host`, so the
+  # denominator is reconstructable per host; unbinding would convert a
+  # readable absence into a guaranteed one.
+  #
+  # Silent on every path (never writes to stdout); exit 0 always, including a
+  # malformed envelope or a write failure. Carries no hook-token-budget row —
+  # it emits nothing, same as orchestration-record. fail_closed: false.
+  #
+  # Concern-budget note: this takes all six `post_tool_use` cells from 10 to
+  # 11 against a `max_per_event: 8` that is warn-only (`hard_fail: false`)
+  # and was already exceeded by 2 before this change. The threshold is a
+  # placeholder awaiting session evidence, per its own comment in the
+  # settings template — not a bar this concern is the first to cross.
+  telemetry-usage:
+    script: src/scripts/hooks/telemetry_usage_hook.ts
+    args: []
+    fail_closed: false
+    severity: advisory
+    # Provable from the hook's own source: the only branch surface is
+    # `extractToolName(payload) !== SKILL_TOOL_NAME`.
+    tools: [Skill]
+    # `[input]` only, and provable by reading the hook: it takes the skill
+    # name from `tool_input.skill` and the host/session from the envelope.
+    # It never touches `tool_response` — a skill invocation's RESULT body is
+    # the large one, and this concern records a usage FACT rather than an
+    # outcome, so the result class would be paid for and discarded.
+    needs_payload_bodies: [input]
   # road-to-orchestrator-discipline-carriers Phase 4 (F3-lite) — conditional
   # delegation nudge. Extracts cheap structural signals from the SUBMITTED
   # prompt (enumerated file lists, "for each"/"alle …" shapes, explicit slice
@@ -444,11 +542,32 @@ concerns:
   # enumerated signal → no injection at all. Never blocks the turn — see the
   # hook's file header for the `host_semantics.emitFor` proof. fail_closed:
   # false.
+  # `nudge_rank` (road-to-standing-context-40k Phase 4 step 4.2) — nudge-class
+  # exclusivity. At most ONE ranked nudge leaves per slot; the LOWEST rank wins
+  # and the dispatcher records every suppression as a `nudge_interference_drop`
+  # dispatch issue. A concern without the field is not nudge-class and is never
+  # suppressed by this policy.
+  #
+  # Measured before the policy was written, so the overlap is a fact rather than
+  # a hypothesis: the prompt "Use when starting parallel work in isolation from
+  # the current branch — spawn a git worktree … for src/a.ts, src/b.ts, src/c.ts
+  # and src/d.ts, each independently" fires delegation-nudge AND skill-route
+  # together on `user_prompt_submit`. Pinned by tests/eval/nudge-interference/.
+  #
+  # WHY delegation-nudge OUTRANKS skill-route, stated because the order is a
+  # decision and not an accident: the delegation verdict changes the SHAPE of
+  # the work (dispatch vs in-session), while a skill pointer is a hint the model
+  # may ignore — and the suppressed half has a first-class recovery path that
+  # the suppressed delegation verdict would not, because `suggest_skill_for_task`
+  # ranks the same catalogue on demand (see the missing-skill-recovery rule).
+  # Losing the pointer costs one tool call; losing the delegation verdict costs
+  # the plan.
   delegation-nudge:
     script: src/scripts/hooks/delegation_nudge_hook.ts
     args: []
     fail_closed: false
     severity: advisory
+    nudge_rank: 1
   # road-to-inbox-harvest-2026-08-d-runtime-skill-routing Phase 2 — binds the
   # deterministic task→skill ranker, which had shipped with ZERO production
   # callers: `score_skill_relevance.rank` and its `suggest_skill_for_task`
@@ -471,6 +590,7 @@ concerns:
     args: []
     fail_closed: false
     severity: advisory
+    nudge_rank: 2
   # road-to-orchestrator-discipline-carriers Phase 5 (F4-lite) — end-review
   # nudge. Fires ONLY when the session mutated tracked+untracked, non-doc
   # files beyond MUTATION_LINE_THRESHOLD (50 lines; untracked files added
@@ -545,6 +665,7 @@ concerns:
     # `toolName !== 'Write'` — same cheap-filter discipline as
     # `orchestration-record`'s [Agent, Task].
     tools: [Write]
+    needs_payload_bodies: [input]
   # road-to-token-economy-cache Phase 6.1/6.2 — re-read guard + post-edit
   # scope hint. PreToolUse, ADVISORY ONLY (never exit 1 — a stale-ledger
   # false positive on a block would corrupt work): a full-file Read of a
@@ -563,6 +684,7 @@ concerns:
     severity: advisory
     # Provable from the hook's own source: READ_TOOLS ∪ WRITE_TOOLS.
     tools: [Read, Edit, Write]
+    needs_payload_bodies: [input]
   # road-to-token-economy-recycling Phases 1.1 / 3.2 / 4.2 — session
   # end-of-life instrument + recycle advisory. Every Stop, incrementally
   # folds the transcript's newly appended lines (payload `transcript_path`,
@@ -582,6 +704,31 @@ concerns:
     args: []
     fail_closed: false
     severity: advisory
+  # road-to-long-horizon-execution Phase 1 (H-1) — the stop slot's first
+  # WORK-REMAINING concern. No-op unless this session claimed a roadmap
+  # (`sessions:claim`) whose frontmatter says `execution.mode: autonomous`;
+  # then compares the claimed roadmap's open checkboxes against the run and
+  # BLOCKS the stop with a continuation naming the next step + its `verify:`
+  # line, under a termination ladder (max 25 iterations, 4 h wall clock,
+  # 3-engagement stall → allow). Registered AFTER turn-end-gate on purpose:
+  # concerns run sequentially, so a gate refusal for this turn is on disk
+  # first and this concern defers to it — quality gates outrank continuation,
+  # always. Events: agents/runtime/state/run-continuation.jsonl. Kill switch:
+  # AGENT_CONFIG_NO_RUN_CONTINUATION=1. fail_closed: false — the only block
+  # it ever emits is the one carrying its own continuation text.
+  run-continuation:
+    script: src/scripts/hooks/run_continuation_hook.ts
+    args: []
+    fail_closed: false
+    # `blocking`, and the R2 review is why. The concern shipped `advisory`,
+    # which the dispatcher enforces as a CEILING: `_is_advisory` downgrades any
+    # EXIT_BLOCK to EXIT_WARN, and `host_semantics.emitFor` maps stop+warn to
+    # exit 0 + additionalContext. The concern's `return EXIT_BLOCK`, this
+    # comment block's "BLOCKS the stop", and the hook's own docblock therefore
+    # all described behaviour the declaration forbade — the whole re-engagement
+    # mechanism was inert on the one verified host. `turn-end-gate` above sits
+    # on the same slot and declares `blocking` for exactly this reason.
+    severity: blocking
   # road-to-user-out-of-the-loop Phase 0 Step 1 — the interruption ledger.
   # Every Stop, classifies whether the turn that just ended put a synchronous
   # contact to the user and appends one `{run_id, turn, kind, class, roadmap}`
@@ -736,19 +883,19 @@ roles:
 
 platforms:
   augment:
-    session_start:    [chat-history, hot-context, handoff-context, session-canary, council-availability, first-run-gate, onboarding-gate, verify-before-complete, minimal-safe-diff, profile-staleness, wrapper-freshness, surface-probe, session-register]
-    session_end:      [chat-history, memory-learn, session-register]
-    stop:             [chat-history, hot-context, verify-before-complete, self-repair, session-register]
+    session_start:    [chat-history, hot-context, handoff-context, session-canary, council-availability, telemetry-disclosure, first-run-gate, onboarding-gate, verify-before-complete, minimal-safe-diff, profile-staleness, wrapper-freshness, surface-probe, session-register]
+    session_end:      [chat-history, memory-learn, session-register, roadmap-progress]
+    stop:             [chat-history, hot-context, verify-before-complete, self-repair, session-register, roadmap-progress]
     pre_tool_use:     [block-no-verify, block-unauthorized-git, evidence-independence, block-kernel-rule-writes, block-config-weakening, rtk-wrap, design-slop, ui-route-nudge, code-graph-nudge, ship-diff-volume, reread-guard]
-    post_tool_use:    [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan, pr-url-reminder, orchestration-record, tool-result-bytes, edit-shape]
+    post_tool_use:    [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan, pr-url-reminder, orchestration-record, telemetry-usage, tool-result-bytes, edit-shape]
 
   claude:
-    session_start:    [chat-history, hot-context, handoff-context, session-canary, council-availability, first-run-gate, onboarding-gate, verify-before-complete, minimal-safe-diff, profile-staleness, wrapper-freshness, surface-probe, session-register]
-    session_end:      [chat-history, memory-learn, session-register]
-    stop:             [chat-history, hot-context, verify-before-complete, team-review-gate, end-review-nudge, turn-end-gate, self-repair, session-register, session-eol, interruption-ledger]
+    session_start:    [chat-history, hot-context, handoff-context, session-canary, council-availability, telemetry-disclosure, first-run-gate, onboarding-gate, verify-before-complete, minimal-safe-diff, profile-staleness, wrapper-freshness, surface-probe, session-register]
+    session_end:      [chat-history, memory-learn, session-register, roadmap-progress]
+    stop:             [chat-history, hot-context, verify-before-complete, team-review-gate, end-review-nudge, turn-end-gate, self-repair, session-register, session-eol, interruption-ledger, roadmap-progress, run-continuation]
     user_prompt_submit: [chat-history, verify-before-complete, minimal-safe-diff, language-mirror, delegation-nudge, skill-route, git-authorization, session-canary, self-repair, session-register]
     pre_tool_use:     [block-no-verify, block-unauthorized-git, evidence-independence, block-kernel-rule-writes, block-config-weakening, rtk-wrap, design-slop, ui-route-nudge, code-graph-nudge, ship-diff-volume, reread-guard, spawn-guard-shadow]
-    post_tool_use:    [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan, pr-url-reminder, orchestration-record, tool-result-bytes, edit-shape, language-mirror]
+    post_tool_use:    [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan, pr-url-reminder, orchestration-record, telemetry-usage, tool-result-bytes, edit-shape, language-mirror]
     # `language-mirror` — round-5 § 6.1. `pre_compact` sets a pin-lost marker;
     # the `post_tool_use` entry above re-emits the pin exactly once while that
     # marker is set, then clears it. One extra injection per compaction EVENT —
@@ -787,8 +934,8 @@ platforms:
   # Decision matrix + upstream blockers tracked in
   # agents/settings/contexts/chat-history-platform-hooks.md § Cowork.
   cowork:
-    session_start:    [chat-history, hot-context, handoff-context, session-canary, council-availability, first-run-gate, onboarding-gate, verify-before-complete, minimal-safe-diff, profile-staleness, wrapper-freshness, surface-probe, session-register]
-    session_end:      [chat-history, memory-learn, session-register]
+    session_start:    [chat-history, hot-context, handoff-context, session-canary, council-availability, telemetry-disclosure, first-run-gate, onboarding-gate, verify-before-complete, minimal-safe-diff, profile-staleness, wrapper-freshness, surface-probe, session-register]
+    session_end:      [chat-history, memory-learn, session-register, roadmap-progress]
     # end-review-nudge and delegation-nudge are DELIBERATELY NOT bound on
     # this platform (F10, review) — cowork-dispatcher.sh's own header states
     # it "always exit[s] 0" and its dispatch line discards the dispatcher's
@@ -799,10 +946,10 @@ platforms:
     # is later verified to forward it. Binding them here would be dead
     # weight: the concern still runs (git diff, transcript scan, classifier),
     # still costs the dispatch, and its entire output is thrown away.
-    stop:             [chat-history, hot-context, verify-before-complete, self-repair, session-register]
+    stop:             [chat-history, hot-context, verify-before-complete, self-repair, session-register, roadmap-progress]
     user_prompt_submit: [chat-history, verify-before-complete, minimal-safe-diff, language-mirror, git-authorization, session-canary, self-repair, session-register]
     pre_tool_use:     [block-no-verify, block-unauthorized-git, evidence-independence, block-kernel-rule-writes, block-config-weakening, rtk-wrap, design-slop, ui-route-nudge, code-graph-nudge, ship-diff-volume, reread-guard, spawn-guard-shadow]
-    post_tool_use:    [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan, pr-url-reminder, orchestration-record, tool-result-bytes, edit-shape]
+    post_tool_use:    [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan, pr-url-reminder, orchestration-record, telemetry-usage, tool-result-bytes, edit-shape]
     # subagent-ledger IS bound here, unlike the two nudges above, and the
     # difference is the delivery channel rather than the platform: the nudges
     # depend on stdout reaching the model, which this trampoline discards by
@@ -821,11 +968,11 @@ platforms:
   # IDE-only — CLI-only users fall back to /checkpoint per
   # agents/settings/contexts/chat-history-platform-hooks.md.
   cursor:
-    session_start:      [chat-history, hot-context, handoff-context, session-canary, council-availability, first-run-gate, onboarding-gate, verify-before-complete, minimal-safe-diff, profile-staleness, wrapper-freshness, surface-probe, session-register]
-    session_end:        [chat-history, memory-learn, session-register]
-    stop:               [chat-history, hot-context, verify-before-complete, self-repair, session-register]
+    session_start:      [chat-history, hot-context, handoff-context, session-canary, council-availability, telemetry-disclosure, first-run-gate, onboarding-gate, verify-before-complete, minimal-safe-diff, profile-staleness, wrapper-freshness, surface-probe, session-register]
+    session_end:        [chat-history, memory-learn, session-register, roadmap-progress]
+    stop:               [chat-history, hot-context, verify-before-complete, self-repair, session-register, roadmap-progress]
     user_prompt_submit: [chat-history, verify-before-complete, minimal-safe-diff, language-mirror, git-authorization, session-canary, self-repair, session-register]
-    post_tool_use:      [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan, pr-url-reminder, orchestration-record, tool-result-bytes, edit-shape]
+    post_tool_use:      [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan, pr-url-reminder, orchestration-record, telemetry-usage, tool-result-bytes, edit-shape]
 
   # Phase 7.6 — Cline. Hooks live under `.clinerules/hooks/<HookName>`
   # (project, no file extension, must be executable per Cline docs) or
@@ -836,11 +983,11 @@ platforms:
   # both map to session_start. TaskCancel maps to stop because the
   # session is interrupted with partial state (mirrors Augment Stop).
   cline:
-    session_start:      [chat-history, hot-context, handoff-context, session-canary, council-availability, first-run-gate, onboarding-gate, verify-before-complete, minimal-safe-diff, profile-staleness, wrapper-freshness, surface-probe, session-register]
-    session_end:        [chat-history, memory-learn, session-register]
-    stop:               [chat-history, hot-context, verify-before-complete, self-repair, session-register]
+    session_start:      [chat-history, hot-context, handoff-context, session-canary, council-availability, telemetry-disclosure, first-run-gate, onboarding-gate, verify-before-complete, minimal-safe-diff, profile-staleness, wrapper-freshness, surface-probe, session-register]
+    session_end:        [chat-history, memory-learn, session-register, roadmap-progress]
+    stop:               [chat-history, hot-context, verify-before-complete, self-repair, session-register, roadmap-progress]
     user_prompt_submit: [chat-history, verify-before-complete, minimal-safe-diff, language-mirror, git-authorization, session-canary, self-repair, session-register]
-    post_tool_use:      [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan, pr-url-reminder, orchestration-record, tool-result-bytes, edit-shape]
+    post_tool_use:      [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan, pr-url-reminder, orchestration-record, telemetry-usage, tool-result-bytes, edit-shape]
 
   # Phase 7.7 — Windsurf (Cascade). Hooks live at `.windsurf/hooks.json`
   # (project) or `~/.codeium/windsurf/hooks.json` (user). Cascade has
@@ -855,7 +1002,7 @@ platforms:
   # surface to record verification commands; documented limitation).
   # minimal-safe-diff is omitted entirely on Windsurf for the same reason.
   windsurf:
-    session_start:      [chat-history, hot-context, handoff-context, session-canary, council-availability, first-run-gate, onboarding-gate, verify-before-complete, profile-staleness, wrapper-freshness, surface-probe, session-register]
+    session_start:      [chat-history, hot-context, handoff-context, session-canary, council-availability, telemetry-disclosure, first-run-gate, onboarding-gate, verify-before-complete, profile-staleness, wrapper-freshness, surface-probe, session-register]
     stop:               [chat-history, hot-context, verify-before-complete, self-repair, session-register]
     # language-mirror IS bound here: unlike minimal-safe-diff it needs only the
     # user_prompt_submit slot, which Windsurf has.
@@ -872,11 +1019,11 @@ platforms:
   # turn-check semantics. AfterAgent fires when the agent loop ends
   # — this is our `stop` slot.
   gemini:
-    session_start:      [chat-history, hot-context, handoff-context, session-canary, council-availability, first-run-gate, onboarding-gate, verify-before-complete, minimal-safe-diff, profile-staleness, wrapper-freshness, surface-probe, session-register]
-    session_end:        [chat-history, memory-learn, session-register]
-    stop:               [chat-history, hot-context, verify-before-complete, self-repair, session-register]
+    session_start:      [chat-history, hot-context, handoff-context, session-canary, council-availability, telemetry-disclosure, first-run-gate, onboarding-gate, verify-before-complete, minimal-safe-diff, profile-staleness, wrapper-freshness, surface-probe, session-register]
+    session_end:        [chat-history, memory-learn, session-register, roadmap-progress]
+    stop:               [chat-history, hot-context, verify-before-complete, self-repair, session-register, roadmap-progress]
     user_prompt_submit: [chat-history, verify-before-complete, minimal-safe-diff, language-mirror, git-authorization, session-canary, self-repair, session-register]
-    post_tool_use:      [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan, pr-url-reminder, orchestration-record, tool-result-bytes, edit-shape]
+    post_tool_use:      [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan, pr-url-reminder, orchestration-record, telemetry-usage, tool-result-bytes, edit-shape]
 
   # Phase 7.9 — Copilot has no hook surface. Concerns route through
   # rule-only fallback; the dispatcher silently no-ops on --platform copilot.

package/src/scripts/hooks/concern_registry.ts

@@ -43,6 +43,7 @@ import { main as teamReviewGateMain } from '../team_review_gate_hook.js';
 import { main as prUrlReminderMain } from '../pr_url_reminder_hook.js';
 import { main as sessionCanaryMain } from '../session_canary_hook.js';
 import { main as councilAvailabilityMain } from '../council_availability_hook.js';
+import { main as telemetryDisclosureMain } from '../telemetry_disclosure_hook.js';
 import { main as selfRepairMain } from '../self_repair_hook.js';
 import { main as sessionRegisterMain } from '../session_register_hook.js';
 import { main as languageMirrorMain } from '../language_mirror_hook.js';
@@ -57,6 +58,7 @@ import { main as designSlopMain } from './design_slop_hook.js';
 import { main as codeGraphNudgeMain } from './code_graph_nudge_hook.js';
 import { main as uiRouteNudgeMain } from './ui_route_nudge_hook.js';
 import { main as orchestrationRecordMain } from './orchestration_record_hook.js';
+import { main as telemetryUsageMain } from './telemetry_usage_hook.js';
 import { main as delegationNudgeMain } from './delegation_nudge_hook.js';
 import { main as skillRouteMain } from './skill_route_hook.js';
 import { main as endReviewNudgeMain } from './end_review_nudge_hook.js';
@@ -68,6 +70,7 @@ import { main as subagentLedgerMain } from './subagent_ledger_hook.js';
 import { main as toolResultBytesMain } from './tool_result_bytes_hook.js';
 import { main as spawnGuardShadowMain } from './spawn_guard_shadow_hook.js';
 import { main as interruptionLedgerMain } from './interruption_ledger_hook.js';
+import { main as runContinuationMain } from './run_continuation_hook.js';
 
 /** A concern `main` — argv-taking or not; both shapes exist. */
 export type ConcernMain = (argv?: string[]) => number | undefined | void;
@@ -93,6 +96,7 @@ export const CONCERN_REGISTRY: Readonly<Record<string, ConcernMain>> = {
     'src/scripts/pr_url_reminder_hook.ts': prUrlReminderMain as ConcernMain,
     'src/scripts/session_canary_hook.ts': sessionCanaryMain as ConcernMain,
     'src/scripts/council_availability_hook.ts': councilAvailabilityMain as ConcernMain,
+    'src/scripts/telemetry_disclosure_hook.ts': telemetryDisclosureMain as ConcernMain,
     'src/scripts/self_repair_hook.ts': selfRepairMain as ConcernMain,
     'src/scripts/session_register_hook.ts': sessionRegisterMain as ConcernMain,
     'src/scripts/language_mirror_hook.ts': languageMirrorMain as ConcernMain,
@@ -107,6 +111,7 @@ export const CONCERN_REGISTRY: Readonly<Record<string, ConcernMain>> = {
     'src/scripts/hooks/code_graph_nudge_hook.ts': codeGraphNudgeMain as ConcernMain,
     'src/scripts/hooks/ui_route_nudge_hook.ts': uiRouteNudgeMain as ConcernMain,
     'src/scripts/hooks/orchestration_record_hook.ts': orchestrationRecordMain as ConcernMain,
+    'src/scripts/hooks/telemetry_usage_hook.ts': telemetryUsageMain as ConcernMain,
     'src/scripts/hooks/delegation_nudge_hook.ts': delegationNudgeMain as ConcernMain,
     'src/scripts/hooks/skill_route_hook.ts': skillRouteMain as ConcernMain,
     'src/scripts/hooks/end_review_nudge_hook.ts': endReviewNudgeMain as ConcernMain,
@@ -118,4 +123,5 @@ export const CONCERN_REGISTRY: Readonly<Record<string, ConcernMain>> = {
     'src/scripts/hooks/tool_result_bytes_hook.ts': toolResultBytesMain as ConcernMain,
     'src/scripts/hooks/spawn_guard_shadow_hook.ts': spawnGuardShadowMain as ConcernMain,
     'src/scripts/hooks/interruption_ledger_hook.ts': interruptionLedgerMain as ConcernMain,
+    'src/scripts/hooks/run_continuation_hook.ts': runContinuationMain as ConcernMain,
 };