feat(hooks): dsh-hooks-claude + dsh-hooks-codex bridges (hooks stack PR-F)

The two bridge plugins that run a user's existing Claude Code / Codex hook
config on the harness's typed interception seams, built on the shared
dsh-hook-protocol library. A bridge is a faithfulness adapter, not a power
tool: anything it does a native cordis plugin does more powerfully — the
bridge exists only to run UNMODIFIED external hooks.

- dsh-hooks-claude: CC dialect. Seven hook points (SessionStart,
  UserPromptSubmit, PreToolUse, PostToolUse, Stop, SubagentStart,
  SubagentStop), CC per-event stdin payloads, env + ${CLAUDE_PLUGIN_ROOT}/
  ${CLAUDE_PROJECT_DIR} substitution, literal-or-regex matcher.
- dsh-hooks-codex: Codex dialect — a deliberate subset. Five hook points,
  always-regex matcher, snake_case payloads (turn_id/model, no trailing
  newline), no env/substitution, block-only decisions.

Both map the neutral merged outcome onto the seam's typed Decision and stamp
an explicit {kind:'plugin'} source on injected context (so it is never
mislabeled as a user prompt). Config parse-failure is contained; only command
hooks run. updatedInput is logged+warned (input rewrite deferred); the Stop
loop-guard is deferred (TODO).

Tests: per-file 100% — config-parse unit branches + per-seam mappings
end-to-end through the REAL loop + REAL bash + REAL shell scripts (scripted
mock model only) + a real-Loader export-shape guard. A keyless ACP snapshot
scenario (hook-prompt-block) proves a UserPromptSubmit hook blocks a prompt
end-to-end (rejected turn -> ACP cancelled, hook/* events in the log); a
with-key e2e (hooks.e2e.ts) proves a PreToolUse hook blocks real bash
(verified on disk). The snapshot normalizer now scrubs hook/result.durationMs.

RFC: docs/rfc/implemented/feature/2026-06-30-hook-bridges.md

examples/acp-agent/tests/acp.snapshot.ts

@@ -29,12 +29,22 @@ interface Scenario {
   name: string
   /** Whether the scenario drives at least one model turn (so a JSONL golden applies). */
   hasModelTurn: boolean
+  /**
+   * Whether the run persists a comparable session log to diff against the
+   * `session.jsonl` fixture. Defaults to {@link hasModelTurn} (a model turn
+   * always produces a log worth comparing). Set it independently for a scenario
+   * that produces a non-trivial log WITHOUT a model turn — e.g. a prompt blocked
+   * by a `UserPromptSubmit` hook, which opens a `rejected` turn carrying `hook/*`
+   * events but never calls the model.
+   */
+  comparesLog?: boolean
   /**
    * Whether `test:snapshot:record` regenerates this scenario's `session.jsonl`
    * from the LIVE API. `recorded` scenarios are model-driven and reproducible;
    * `authored` scenarios (a hand-written `replay.override.json` sidecar drives
    * replay — e.g. a provider error or a cancel, which the live API can't be
-   * coaxed into deterministically) are NEVER re-recorded.
+   * coaxed into deterministically — or a deterministic hook scenario whose
+   * derived empty script needs no sidecar) are NEVER re-recorded.
    */
   recorded: boolean
   /**
@@ -61,6 +71,11 @@ const SCENARIOS: Scenario[] = [
   { name: 'subagent-multi', hasModelTurn: true, recorded: true, childSessions: 2 },
   { name: 'subagent-fork', hasModelTurn: true, recorded: true, childSessions: 1 },
   { name: 'subagent-mixed', hasModelTurn: true, recorded: true, childSessions: 2 },
+  // A UserPromptSubmit hook blocks the prompt before any step runs: no model
+  // call (keyless, authored — its derived script is empty so it needs no
+  // sidecar), but it persists a `rejected` turn carrying `hook/*` events, so its
+  // log IS compared. The hooks.json riding in workspace/ drives the bridge.
+  { name: 'hook-prompt-block', hasModelTurn: false, comparesLog: true, recorded: false },
 ]
 
 /** The sibling child-fixture paths for a scenario (`session.1.jsonl` …). */
@@ -139,12 +154,15 @@ for (const scenario of SCENARIOS) {
       await expect(normalizeStdout(result.rawStdout, ctx))
         .toMatchFileSnapshot(join(dir, 'stdout.golden.jsonl'))
 
-      if (scenario.hasModelTurn) {
+      // A model turn always produces a log worth comparing; a hook scenario can
+      // produce one without a model turn (a `rejected` turn carrying `hook/*`).
+      const comparesLog = scenario.comparesLog ?? scenario.hasModelTurn
+      if (comparesLog) {
         // The harvested logs (primary-first) must match their committed fixtures
         // 1:1. Each side passes through normalizeSessionLog, scrubbed against ITS
         // OWN volatile values — the live run's via `ctx`, the committed fixture's
         // via its own header (a committed file cannot share the live run's ids).
-        expect(result.sessionLogs.length, 'a model scenario must persist a session log').toBe(childSessions + 1)
+        expect(result.sessionLogs.length, 'this scenario must persist a session log').toBe(childSessions + 1)
         const fixtureFiles = ['session.jsonl', ...Array.from({ length: childSessions }, (_, i) => `session.${i + 1}.jsonl`)]
         for (let i = 0; i < fixtureFiles.length; i++) {
           const harvested = (result.sessionLogs[i] as HarvestedLog).content