@amsterdamdatalabs/adl-agent-control-linux-x64 0.1.12 → 0.1.26

package/packages/agent-hooks/src/hooks/briefing/index.ts

@@ -1,320 +1,60 @@
-/**
- * The `briefing` hook kind.
- *
- * Ports `enact-m5/.agents/hooks/session-briefing/`
- * (`session-briefing.mjs` + `src/render.mjs` + `src/warmup.mjs`) onto the
- * `HookHandler` contract in `../contract.ts`.
- *
- * Two subprocess calls into `lean-ctx`, both behind the injected `Runner` so
- * tests never touch a real binary:
- *
- *  1. `hook codex-session-start` — the base lean-ctx session briefing text,
- *     read out of its `hookSpecificOutput.additionalContext` JSON.
- *  2. `overview [task]` and `knowledge status` — the PROJECT WARMUP appendix,
- *     always emitted (even with no lean-ctx at all) because its static
- *     workflow block does not depend on either call succeeding.
- *
- * `lean-ctx` is a GLOBAL binary installed fleet-wide on `PATH` by
- * global-tools (see its `manifest.json`'s `"lean-ctx"` entry) — unlike the
- * reference tree, there is no repo-local `.agents/bin/lean-ctx-local`
- * wrapper here, so every call below resolves `lean-ctx` off the ambient
- * `PATH` directly. What stays repo-local is lean-ctx's own state: every call
- * still sets `LEAN_CTX_CONFIG_DIR`/`LEAN_CTX_DATA_DIR`/`LEAN_CTX_STATE_DIR`/
- * `LEAN_CTX_CACHE_DIR` rooted at `<root>/.agents/lean-ctx/<config/lean-ctx|data|state|cache>`
- * (`../../lean-ctx/env.ts`'s `leanCtxEnv` — shared with the `lean-ctx`
- * pre/post-tool-use hook kind, `../lean-ctx/index.ts`), so lean-ctx's
- * config/data/state/cache stay per-repository even though the binary itself
- * is now shared.
- *
- * HARDCUT (work item A.3): this used to set the plain `XDG_CONFIG_HOME`/
- * `XDG_DATA_HOME`/`XDG_STATE_HOME`/`XDG_CACHE_HOME` vars, mirroring what the
- * reference's wrapper script exported before exec'ing its own repo-local
- * binary. `../../lean-ctx/env.ts`'s header records the live verification
- * (this session, 2026-09-14) that the real v3.9.20 binary does not actually
- * key its config/data/state/cache resolution on those XDG vars at all — only
- * on the four `LEAN_CTX_*` ones now used here.
- *
- * lean-ctx missing or failing is advisory, never fatal: the warmup section
- * still goes out and the failure is named on stderr, but this never returns
- * exitCode 2 — a briefing hook has no host-visible "block" channel, and the
- * reference script's own header says the same ("Advises only — never block
- * the session or prompt"). A spawn that never exits (gap #1) degrades the
- * same way: the injected `Runner` is timeout-enforcing (see
- * `../../lib/spawn-with-timeout.ts`), so a hung `lean-ctx` child is killed
- * and reported exactly like a failed/ENOENT spawn — `status: null` — rather
- * than hanging the calling agent host.
- *
- * `deploy.mjs`-level concerns from the reference tree — wiring the hook into
- * each host's config, `--self-test`/`--host=`/`--event=` argv parsing, the
- * five-surface deploy fixture in `tests/test-wiring.mjs` — are out of scope
- * here: `src/hosts/*` and `src/main.ts`'s dispatch own that, per this task's
- * boundary.
- */
-
+/** Static session-orientation briefing for supported agent hosts. */
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
-
 import type { HookHandler, HookInvocation, HookResult, HostId } from '../contract.ts'
 import { spawnWithTimeout } from '../../lib/spawn-with-timeout.ts'
-import { leanCtxEnvFor } from '../../lean-ctx/env.ts'
-
-/** The marker lean-ctx's own `hook codex-session-start` output carries, when present. */
-export const MARKER = 'lean-ctx SESSION BRIEFING'
-export const WARMUP_MARKER = 'PROJECT WARMUP'
-
-const LEAN_CTX_BIN = 'lean-ctx'
 
-const OVERVIEW_MAX_LINES = 28
-const OVERVIEW_TIMEOUT_MS = 12_000
-const DEFAULT_TIMEOUT_MS = 8_000
-
-export interface RunResult {
-  readonly status: number | null
-  readonly stdout: string
-  readonly stderr: string
-  /** `true` only when the spawn was killed for exceeding `timeoutMs` — see gap #1. */
-  readonly timedOut?: boolean
-}
-
-export interface RunOptions {
-  readonly cwd: string
-  readonly env: Readonly<Record<string, string | undefined>>
-  readonly input?: string
-  /** Wall-clock spawn timeout in ms; overridable per call, defaults per call site below. */
-  readonly timeoutMs?: number
-}
-
-/** Process spawning, injected so tests never need a real `lean-ctx` binary. */
+interface RunResult { readonly status: number | null; readonly stdout: string; readonly stderr: string; readonly timedOut?: boolean }
+interface RunOptions { readonly cwd: string; readonly env: Readonly<Record<string, string | undefined>>; readonly input?: string; readonly timeoutMs?: number }
 export type Runner = (cmd: string, args: readonly string[], opts: RunOptions) => Promise<RunResult>
-
-function deliveredStateDir(root: string): string {
-  return join(root, '.agents/lean-ctx/state/session-briefing-delivered')
-}
-
-function sessionId(payload: Record<string, unknown>): string {
-  const raw = payload['session_id'] ?? payload['conversation_id']
-  return typeof raw === 'string' && raw.trim().length > 0 ? raw.trim() : 'unknown'
-}
-
-/** Cursor and Kimi have no host-native "fire once at SessionStart" channel; gate on a marker file instead. */
-function usesPromptGate(host: HostId): boolean {
-  return host === 'cursor' || host === 'kimi'
+/** Kept for the shared subprocess-runner contract used by focused tests. */
+export const bunRunner: Runner = async (cmd, args, opts) => {
+  try {
+    const result = await spawnWithTimeout(cmd, args, { cwd: opts.cwd, env: opts.env, timeoutMs: opts.timeoutMs ?? 8_000, ...(opts.input === undefined ? {} : { stdin: opts.input }) })
+    return result.timedOut ? { status: null, stdout: result.stdout, stderr: result.stderr.trim() || `${cmd} timed out after ${opts.timeoutMs ?? 8_000}ms`, timedOut: true } : { status: result.exitCode, stdout: result.stdout, stderr: result.stderr }
+  } catch (error) { return { status: null, stdout: '', stderr: error instanceof Error ? error.message : String(error) } }
 }
 
-function deliveredPath(root: string, host: HostId, session: string): string {
-  return join(deliveredStateDir(root), `${host}-${session}.done`)
-}
+const WARMUP_MARKER = 'PROJECT WARMUP'
 
-function alreadyDelivered(root: string, host: HostId, session: string): boolean {
-  if (!usesPromptGate(host)) return false
-  return existsSync(deliveredPath(root, host, session))
+function deliveredStateDir(root: string): string { return join(root, '.adl', 'state', 'session-briefing-delivered') }
+function sessionId(payload: Record<string, unknown>): string {
+  const raw = payload.session_id ?? payload.conversation_id
+  return typeof raw === 'string' && raw.trim() ? raw.trim() : 'unknown'
 }
-
+function usesPromptGate(host: HostId): boolean { return host === 'cursor' || host === 'kimi' }
+function deliveredPath(root: string, host: HostId, session: string): string { return join(deliveredStateDir(root), `${host}-${session}.done`) }
+function alreadyDelivered(root: string, host: HostId, session: string): boolean { return usesPromptGate(host) && existsSync(deliveredPath(root, host, session)) }
 function markDelivered(root: string, host: HostId, session: string): void {
   if (!usesPromptGate(host)) return
   mkdirSync(deliveredStateDir(root), { recursive: true })
   writeFileSync(deliveredPath(root, host, session), `${new Date().toISOString()}\n`)
 }
-
-function runLeanCtx(
-  run: Runner,
-  root: string,
-  env: Readonly<Record<string, string | undefined>>,
-  args: readonly string[],
-  timeoutMs = DEFAULT_TIMEOUT_MS,
-): Promise<RunResult> {
-  return run(LEAN_CTX_BIN, args, { cwd: root, env: leanCtxEnvFor(root, env), timeoutMs })
-}
-
-function truncateLines(text: string, maxLines: number): string {
-  const lines = text.split('\n')
-  if (lines.length <= maxLines) return text
-  return `${lines.slice(0, maxLines).join('\n')}\n… (${lines.length - maxLines} more lines; call ctx_overview for full map)`
-}
-
-function taskFromPayload(payload: Record<string, unknown>): string {
-  const prompt = payload['prompt']
-  const trimmed = typeof prompt === 'string' ? prompt.trim() : ''
-  if (trimmed.length < 8) return ''
-  return trimmed.length > 120 ? `${trimmed.slice(0, 117)}…` : trimmed
-}
-
-function workflowBlock(): string {
+function briefingText(): string {
   return [
-    WARMUP_MARKER,
-    '',
-    'Start every session (ctx_* or lean-ctx; use ctx_call when not advertised):',
-    '• ctx_overview / lean-ctx overview ["task"] — project map; FIRST on unfamiliar work',
+    WARMUP_MARKER, '',
+    'Start every session with ctx_overview when it is available; use ctx_call when it is not advertised.',
     '• ctx_knowledge(action="wakeup") — cross-session facts and decisions',
-    '• ctx_session(action="status") — last session findings in this repo',
-    '',
-    'Knowledge: ctx_knowledge or lean-ctx knowledge — status | recall | search | remember | consolidate',
-    'Checkpoints: ctx_session(action="task"|"decision", …) after significant progress',
-    '',
+    '• ctx_session(action="status") — last session findings in this repository', '',
     'After orientation: ctx_compose → ctx_read/ctx_search → ctx_shell (verify) → persist.',
   ].join('\n')
 }
-
-/**
- * The PROJECT WARMUP appendix. Always non-empty — its static workflow block
- * does not depend on `lean-ctx` at all — so a briefing is never fully silent
- * just because the binary is missing.
- */
-async function projectWarmupAppendix(
-  run: Runner,
-  root: string,
-  env: Readonly<Record<string, string | undefined>>,
-  payload: Record<string, unknown>,
-): Promise<string> {
-  const parts = [workflowBlock()]
-
-  const task = taskFromPayload(payload)
-  const overviewArgs = task ? ['overview', task] : ['overview']
-  const overview = await runLeanCtx(run, root, env, overviewArgs, OVERVIEW_TIMEOUT_MS)
-  if (overview.status === 0 && overview.stdout.trim()) {
-    parts.push('', '--- ctx_overview (cached snapshot) ---', truncateLines(overview.stdout.trim(), OVERVIEW_MAX_LINES))
-  }
-
-  const knowledge = await runLeanCtx(run, root, env, ['knowledge', 'status'])
-  if (knowledge.status === 0 && knowledge.stdout.trim()) {
-    parts.push('', '--- ctx_knowledge status ---', knowledge.stdout.trim())
-  }
-
-  return parts.join('\n')
-}
-
-function composeBriefing(base: string, warmup: string): string {
-  const b = base.trim()
-  const w = warmup.trim()
-  if (b && w) return `${b}\n\n${w}`
-  return b || w
-}
-
-interface BaseBriefing {
-  readonly text: string
-  readonly failureNote: string
-  readonly outcome: 'ok' | 'timeout' | 'error'
-}
-
-/** Runs `lean-ctx hook codex-session-start`; failure degrades to an empty base text plus a stderr note. */
-async function baseBriefing(
-  run: Runner,
-  root: string,
-  env: Readonly<Record<string, string | undefined>>,
-  payload: Record<string, unknown>,
-): Promise<BaseBriefing> {
-  const result = await run(LEAN_CTX_BIN, ['hook', 'codex-session-start'], {
-    cwd: root,
-    env: leanCtxEnvFor(root, env),
-    input: JSON.stringify(payload),
-    timeoutMs: DEFAULT_TIMEOUT_MS,
-  })
-
-  if (result.status !== 0 || !result.stdout.trim()) {
-    const reason = result.stderr.trim() || `lean-ctx exited with status ${String(result.status)}`
-    return {
-      text: '',
-      failureNote: `session-briefing: lean-ctx hook codex-session-start failed — ${reason}\n`,
-      outcome: result.timedOut ? 'timeout' : 'error',
-    }
-  }
-
-  try {
-    const parsed = JSON.parse(result.stdout) as { hookSpecificOutput?: { additionalContext?: unknown } }
-    const text = parsed.hookSpecificOutput?.additionalContext
-    return { text: typeof text === 'string' ? text : '', failureNote: '', outcome: 'ok' }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error)
-    return {
-      text: '',
-      failureNote: `session-briefing: lean-ctx hook codex-session-start returned invalid JSON — ${message}\n`,
-      outcome: 'error',
-    }
-  }
-}
-
-/**
- * Wrap briefing text in a host's native envelope.
- *
- * Per official docs where they differ from the reference tree:
- *  - Claude / Codex SessionStart (and any other event): `hookSpecificOutput.additionalContext`.
- *  - Cursor: flat `additional_context` — the reference's nested
- *    `hookSpecificOutput` shape for Cursor `UserPromptSubmit` is not part of
- *    Cursor's documented hook contract, so it is not ported here.
- *  - Kimi: bare stdout text (its `UserPromptSubmit` hook has no JSON envelope).
- *  - OpenCode: `{"advice": "..."}`, consumed by this repo's own OpenCode plugin.
- */
 function renderBriefing(host: HostId, event: string, text: string): string {
-  if (!text) return ''
   if (host === 'kimi') return `${text}\n`
   if (host === 'opencode') return JSON.stringify({ advice: text })
   if (host === 'cursor') return JSON.stringify({ additional_context: text })
   return JSON.stringify({ hookSpecificOutput: { hookEventName: event, additionalContext: text } })
 }
 
-export function createBriefingHandler(deps: { run: Runner }): HookHandler {
+export function createBriefingHandler(): HookHandler {
   return async (inv: HookInvocation): Promise<HookResult> => {
-    const { host, root, env } = inv
-    const payload = inv.payload
-    const event = inv.event ?? 'SessionStart'
-    const session = sessionId(payload)
-
-    if (alreadyDelivered(root, host, session)) {
+    const session = sessionId(inv.payload)
+    if (alreadyDelivered(inv.root, inv.host, session)) {
       inv.record?.({ reason: 'SKIP already delivered this session' })
       return { stdout: '', stderr: '', exitCode: 0 }
     }
-
-    const { text: base, failureNote, outcome } = await baseBriefing(deps.run, root, env, payload)
-    const warmup = await projectWarmupAppendix(deps.run, root, env, payload)
-    const text = composeBriefing(base, warmup)
-
-    markDelivered(root, host, session)
-    const reasons = { ok: 'PASS', timeout: 'TIMEOUT lean-ctx hook codex-session-start', error: 'ERROR lean-ctx hook codex-session-start' }
-    inv.record?.({
-      reason: reasons[outcome],
-      message: failureNote.trim(),
-      downstream: 'lean-ctx hook codex-session-start, lean-ctx overview, lean-ctx knowledge status',
-    })
-
-    return {
-      stdout: renderBriefing(host, event, text),
-      stderr: failureNote,
-      exitCode: 0,
-    }
+    markDelivered(inv.root, inv.host, session)
+    inv.record?.({ reason: 'PASS', downstream: 'static session briefing' })
+    return { stdout: renderBriefing(inv.host, inv.event ?? 'SessionStart', briefingText()), stderr: '', exitCode: 0 }
   }
 }
-
-/**
- * The production `Runner`: a real, timeout-enforcing subprocess via
- * `spawnWithTimeout` (see `../../lib/spawn-with-timeout.ts`) — replaces the
- * reference tree's `Bun.spawnSync`, which had no timeout and could hang the
- * calling agent host forever on a stuck `lean-ctx` child (gap #1). A timeout
- * degrades exactly like an ENOENT/failed spawn: `status: null` with the
- * reason on stderr, plus `timedOut: true` so callers can tell the two apart.
- */
-export const bunRunner: Runner = async (cmd, args, opts) => {
-  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS
-  try {
-    const result = await spawnWithTimeout(cmd, args, {
-      cwd: opts.cwd,
-      env: opts.env,
-      timeoutMs,
-      ...(opts.input !== undefined ? { stdin: opts.input } : {}),
-    })
-    if (result.timedOut) {
-      return {
-        status: null,
-        stdout: result.stdout,
-        stderr: result.stderr.trim() || `${cmd} timed out after ${timeoutMs}ms`,
-        timedOut: true,
-      }
-    }
-    return { status: result.exitCode, stdout: result.stdout, stderr: result.stderr }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error)
-    return { status: null, stdout: '', stderr: message }
-  }
-}
-
-export const handleBriefing: HookHandler = createBriefingHandler({ run: bunRunner })
-export default handleBriefing

package/packages/agent-hooks/src/hooks/contract.ts

@@ -3,13 +3,12 @@
  *
  * `controls hook <kind> --host=X` is invoked by agent hosts (Claude Code,
  * Codex, Cursor, OpenCode, Kimi) with a JSON payload on stdin. Every kind
- * (`pre-tool-use`, `user-prompt-submit`, `briefing`, `crg`, `lean-ctx`
- * pre-tool-use/post-tool-use) is dispatched from `src/main.ts` through one
+ * (`pre-tool-use`, `user-prompt-submit`, `briefing`, `crg`) is dispatched
+ * from `src/main.ts` through one
  * `HookHandler` shape, so a handler never sees `process`, argv, or stdin
  * directly — only the `HookInvocation` it is called with, and it returns a
  * `HookResult` for `main.ts` to write to stdout/stderr and turn into a
- * process exit code. `lean-ctx mcp` is the one exception: it is not a
- * `HookHandler` at all — see `src/lean-ctx/mcp.ts`'s header.
+ * process exit code.
  *
  * This file is intentionally the *only* place that shape is defined: other
  * agents implementing `src/hooks/user-prompt-submit/`, `src/hooks/briefing/`,
@@ -31,26 +30,27 @@ export interface ActivityNote {
   /** `PASS`, `DENY <rule>`, `ERROR <what>`, `TIMEOUT <what>`, or `SKIP <why>`. */
   readonly reason: string
   readonly message?: string
-  /** What the hook invoked downstream, e.g. `lean-ctx hook redirect`, `skills: tdd, research`. */
+  /** What the hook invoked downstream, e.g. `skills: tdd, research`. */
   readonly downstream?: string
   /** Set only for a blocked pre-tool-use decision: the rule id written to the deny log. */
   readonly denyRuleId?: string
   /**
    * Set only when an identity decision was actually made for this
-   * invocation (a rewrite, or a deny/pass decided by one of the four
-   * identity rules — `adl.session-required-for-writes`, `adl.git-identity`,
-   * `adl.token-minting-role`, `tool.azure-devops`): where the effective
-   * agent identity came from, per the one-agent-identity standard's own
-   * resolution order (STATUS.md 12p, "The
-   * standard") — `inline` (a valid `ADL_AGENT_ID_AGENT=` on the command
-   * itself), `env` (the session environment), `default-file` (the machine
-   * default-agent file), or `none` (nothing resolved at all). See
-   * `../pre-tool-use/handler.ts`'s `identitySourceFor`.
+   * invocation (a rewrite, or a deny/pass decided by one of the identity
+   * rules — `adl.run-required-for-writes`, `adl.git-identity`,
+   * `adl.token-minting-role`, `tool.azure-devops`, … — or by a role gate on
+   * an Azure DevOps MCP call): where the effective agent identity came from,
+   * per the one-agent-identity resolution order — `inline` (a valid
+   * `ADL_AGENT_ID_AGENT=` on the command itself), `env` (the session
+   * environment), `default-file` (the machine default-agent file), or
+   * `none` (nothing resolved at all). An allowed Azure DevOps MCP call logs
+   * it too, reads included (Tarun, 2026-09-29). See
+   * `../pre-tool-use/handler.ts`'s `effectiveIdentityFor` and
+   * `fallbackIdentity`.
    */
   readonly identitySource?: 'inline' | 'env' | 'default-file' | 'none'
   /**
-   * M8 (STATUS.md 12p): the EFFECTIVE agent
-   * identity this decision actually used — set together with
+   * The EFFECTIVE agent identity this decision actually used — set together with
    * `identitySource`, whenever that is set to anything but `'none'`. Read
    * by `./log.ts` for the `agent` column INSTEAD OF the session's raw
    * `ADL_AGENT_ID_AGENT` env var — the two differ exactly when a command
@@ -63,7 +63,7 @@ export interface ActivityNote {
 }
 
 export interface HookInvocation {
-  readonly kind: 'pre-tool-use' | 'user-prompt-submit' | 'briefing' | 'crg' | 'lean-ctx'
+  readonly kind: 'pre-tool-use' | 'user-prompt-submit' | 'briefing' | 'crg'
   readonly host: HostId
   readonly event?: string
   readonly subcommand?: string

package/packages/agent-hooks/src/hooks/crg/background.ts

@@ -29,11 +29,25 @@
  * pending marker exists clears it and runs once more. On its way out it
  * releases the lock, then re-checks the marker once and re-acquires the
  * lock (noclobber) if a hook queued in the meantime, closing the last gap.
+ *
+ * Self-heal: if `code-review-graph update --skip-flows` exits non-zero,
+ * the runner runs `code-review-graph build --skip-flows` once and logs a
+ * `SELF-HEAL:` marker to stderr (captured by the spawn into
+ * `crg-update.log`). The original error is already in the log because
+ * the spawn captures the update's own stderr; the marker is appended
+ * after, so the failure is never silently swallowed. The build runs at
+ * most once per runner invocation (a per-runner shell variable), so a
+ * runner that re-iterates because the pending marker was set does not
+ * re-trigger the build on the second iteration. If the build itself
+ * fails, the runner exits and the next edit tries again — persistent
+ * failures stay visible in the log instead of being hidden.
  */
 
 import { closeSync, mkdirSync, openSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
 
+import { ensureAdlGitignore } from '../../log/adl-dir.ts'
+
 export const LOCK_REL = '.adl/crg-update.lock'
 export const PENDING_REL = '.adl/crg-update.pending'
 export const UPDATE_LOG_REL = '.adl/logs/crg-update.log'
@@ -43,9 +57,21 @@ export const MAX_LOCK_AGE_MS = 30 * 60 * 1000
 
 export const RUNNER_SCRIPT = [
   'lock="$1"; pending="$2"; shift 2',
+  'build_attempted=',
   'while :; do',
   '  rm -f "$pending"',
   '  "$@"',
+  '  rc=$?',
+  '  if [ "$rc" -ne 0 ] && [ -z "$build_attempted" ]; then',
+  '    echo "SELF-HEAL: $* exited $rc; running code-review-graph build --skip-flows" >&2',
+  '    if code-review-graph build --skip-flows; then',
+  '      echo "SELF-HEAL: build ok; next update will validate" >&2',
+  '    else',
+  '      build_rc=$?',
+  '      echo "SELF-HEAL: build failed (exit $build_rc); self-heal aborted" >&2',
+  '    fi',
+  '    build_attempted=1',
+  '  fi',
   '  if [ -e "$pending" ]; then continue; fi',
   '  rm -f "$lock"',
   '  if [ -e "$pending" ] && (set -C; echo $$ > "$lock") 2>/dev/null; then continue; fi',
@@ -160,6 +186,7 @@ function acquireAndStart(deps: BackgroundDeps, root: string, env: SpawnSpec['env
 
 export function requestUpdate(deps: BackgroundDeps, root: string, env: SpawnSpec['env']): UpdateRequest {
   mkdirSync(join(root, '.adl', 'logs'), { recursive: true, mode: 0o700 })
+  ensureAdlGitignore(join(root, '.adl'))
   const lockPath = join(root, LOCK_REL)
   const pendingPath = join(root, PENDING_REL)
 

package/packages/agent-hooks/src/hooks/crg/index.ts

@@ -47,7 +47,7 @@
 
 import type { HookHandler, HookInvocation, HookResult } from '../contract.ts'
 import { spawnWithTimeout } from '../../lib/spawn-with-timeout.ts'
-import { defaultBackgroundDeps, requestUpdate, type BackgroundDeps } from './background.ts'
+import { requestUpdate, type BackgroundDeps } from './background.ts'
 import { toDecideInput } from '../../pre-tool-use/handler.ts'
 import { invocations } from '../../rules/shell/invocation.ts'
 
@@ -155,7 +155,8 @@ function isGitCommitInvocation(payload: Record<string, unknown>): boolean {
 }
 
 /**
- * `pre-commit.sh`: silent `detect-changes --brief`, stdout `{"passed":true}`,
+ * `pre-commit.sh`: silent `detect-changes --brief`, with Codex receiving its
+ * native allow envelope rather than the legacy `{"passed":true}` payload,
  * always exit 0 — but ONLY when the invoking payload's shell command is
  * actually a `git commit` (see this file's header, work item B). Anything
  * else — no shell command at all (a non-Bash tool call), or a shell command
@@ -168,7 +169,10 @@ async function preCommit(run: Runner, inv: HookInvocation): Promise<HookResult>
     return { stdout: '', stderr: '', exitCode: 0 }
   }
   const result = await runCrg(run, inv, ['detect-changes', '--brief'])
-  return { stdout: '{"passed":true}\n', stderr: missingBinaryNote('pre-commit', result), exitCode: 0 }
+  const stdout = inv.host === 'codex'
+    ? `${JSON.stringify({ hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'allow' } })}\n`
+    : '{"passed":true}\n'
+  return { stdout, stderr: missingBinaryNote('pre-commit', result), exitCode: 0 }
 }
 
 /**
@@ -235,6 +239,3 @@ export const bunRunner: Runner = async (cmd, args, opts) => {
     return { status: null, stdout: '', stderr: message }
   }
 }
-
-export const handleCrg: HookHandler = createCrgHandler({ run: bunRunner, background: defaultBackgroundDeps })
-export default handleCrg

package/packages/agent-hooks/src/hooks/log.ts

@@ -40,8 +40,7 @@
  *     `result` is never left empty just because a row has nothing to say.
  *   - `rule` is set only for a blocked pre-tool-use decision
  *     (`ActivityNote.denyRuleId`), same trigger as the old deny log.
- *   - `agent` is `ActivityNote.identityAgent` (M8,
- *     STATUS.md 12p) — the EFFECTIVE identity the
+ *   - `agent` is `ActivityNote.identityAgent` — the EFFECTIVE identity the
  *     decision actually used, set by `../pre-tool-use/handler.ts`'s
  *     `effectiveIdentityFor` — when an identity decision was made; a valid
  *     inline `ADL_AGENT_ID_AGENT=` override on the command differs from the
@@ -50,12 +49,12 @@
  *     `ADL_AGENT_ID_AGENT` (`../rules/impl/adl-identity.ts`'s env var) for
  *     any row with no identity decision at all. `human` has no source at
  *     this layer and is left absent.
- *   - `identity_source` (W2 build item 5, 2026-09-28) comes straight off
+ *   - `identity_source` comes straight off
  *     `ActivityNote.identitySource` (`./contract.ts`), set by
  *     `../pre-tool-use/handler.ts`'s `decideAndRespond` only when an
  *     identity decision was actually made for this invocation — absent
- *     otherwise, never defaulted to `'none'` for an unrelated row. M8 widens
- *     when this is set to also cover the "override's PASS" row: an
+ *     otherwise, never defaulted to `'none'` for an unrelated row. It is set
+ *     for the "override's PASS" row too: an
  *     identity-bearing command whose only identity-bearing pieces already
  *     carry a valid inline override needs no rewrite (`rewriteGitNetworkCommands`'s
  *     `unchanged` outcome), but it still made a real identity decision.
@@ -79,9 +78,9 @@ import type { ActivityNote, HookHandler, HookInvocation, HookResult } from './co
 
 export const HOOKS_LOG_REL = '.adl/logs/hooks.log'
 export const HOOKS_DENY_LOG_REL = '.adl/logs/hooks-deny.log'
-export const MAX_LOGGED_COMMAND_LENGTH = 2000
+const MAX_LOGGED_COMMAND_LENGTH = 2000
 
-export function truncateCommand(value: string): string {
+function truncateCommand(value: string): string {
   return value.length > MAX_LOGGED_COMMAND_LENGTH ? `${value.slice(0, MAX_LOGGED_COMMAND_LENGTH)}...<truncated>` : value
 }
 
@@ -108,7 +107,7 @@ const stringAt = (record: Readonly<Record<string, unknown>>, key: string): strin
  * `{"command": "...", "cwd": "...", "sandbox": false}` (no `tool_input` at
  * all). No Cursor-specific field renaming was needed here.
  */
-export function toolSummary(payload: Readonly<Record<string, unknown>>): string {
+function toolSummary(payload: Readonly<Record<string, unknown>>): string {
   const rawInput = payload.tool_input
   const input = typeof rawInput === 'object' && rawInput !== null && !Array.isArray(rawInput) ? (rawInput as Record<string, unknown>) : {}
   for (const key of ['command', 'cmd', 'script']) {
@@ -172,8 +171,7 @@ export async function runLogged(inv: HookInvocation, handler: HookHandler, now:
     const duration = Math.round(performance.now() - started)
     const sessionId = sessionOf(inv.payload)
     const runId = runIdOf(inv.env)
-    // M8 (STATUS.md 12p): the EFFECTIVE identity
-    // this decision used — set on `outcome` whenever an identity decision
+    // The EFFECTIVE identity this decision used — set on `outcome` whenever an identity decision
     // was actually made (`../pre-tool-use/handler.ts`'s `effectiveIdentityFor`)
     // — wins over the session's raw `ADL_AGENT_ID_AGENT` env var: they
     // differ exactly when the command carries a valid inline override

package/packages/agent-hooks/src/hooks/user-prompt-submit/match.ts

@@ -51,7 +51,7 @@ function processTerm(term: string): string | null {
  * so it is rebuilt per invocation rather than persisted — that keeps the hook
  * stateless and makes an edited SKILL.md take effect immediately.
  */
-export function buildIndex(skills: readonly Skill[]): MiniSearch {
+function buildIndex(skills: readonly Skill[]): MiniSearch {
   const index = new MiniSearch({
     fields: ['name', 'keywords', 'description'],
     storeFields: ['label', 'description'],

package/packages/agent-hooks/src/hooks/user-prompt-submit/tokenizer.ts

@@ -1,6 +1,6 @@
 /**
  * Minimal Unigram tokenizer over the pruned tokenizer.json of the
- * adl-embedding artifact. Pure TS — no dependency on a native tokenizer
+ * enact-embedding artifact. Pure TS — no dependency on a native tokenizer
  * package.
  *
  * Ported unchanged from enact-repo-controls-m5's

package/packages/agent-hooks/src/hooks/user-prompt-submit/vector.ts

@@ -10,10 +10,11 @@
  * the artifact from a repo-local `.cache/enact-embedding/model/` directory
  * built by that repo's own installer. This hook instead treats the model as a
  * GLOBAL, machine-wide asset shared by every repository —
- * `resolveGlobalArtifactDir` resolves `${XDG_CACHE_HOME:-$HOME/.cache}/adl-embedding/model/`
- * (renamed from `enact-embedding`, matching `packages/fleet/src/install-embedding-model.ts`,
- * the installer that actually writes this directory) from the invocation's
- * own `env`, never `process.env` and never repo-relative.
+ * `resolveGlobalArtifactDir` resolves `${XDG_CACHE_HOME:-$HOME/.cache}/enact-embedding/model/`
+ * (matching `packages/fleet/src/install-embedding-model.ts`, the installer that
+ * actually writes this directory; the earlier `adl-embedding` name is a hard
+ * cut, never read as a fallback) from the invocation's own `env`, never
+ * `process.env` and never repo-relative.
  *
  * `loadVectorHalf`'s `LoadVectorResult.reason` (on `ok: false`) already
  * carries a specific, human-readable cause (directory missing, which files
@@ -37,7 +38,7 @@ const ARTIFACT_FILES = ['model.bin', 'tokenizer.json', 'tokenizer_config.json',
 export function resolveGlobalArtifactDir(env: Readonly<Record<string, string | undefined>>): string {
   const xdgCacheHome = env.XDG_CACHE_HOME
   const base = xdgCacheHome && xdgCacheHome.trim() !== '' ? xdgCacheHome : join(requireHome(env), '.cache')
-  return join(base, 'adl-embedding', 'model')
+  return join(base, 'enact-embedding', 'model')
 }
 
 function requireHome(env: Readonly<Record<string, string | undefined>>): string {

package/packages/agent-hooks/src/hosts/registry.ts

@@ -15,7 +15,7 @@ import { cursorSpec } from './impl/cursor.ts'
 import { opencodeSpec } from './impl/opencode.ts'
 import { kimiSpec } from './impl/kimi.ts'
 
-export const HOST_SPECS: Readonly<Record<HostId, HostSpec>> = {
+const HOST_SPECS: Readonly<Record<HostId, HostSpec>> = {
   claude: claudeSpec,
   codex: codexSpec,
   cursor: cursorSpec,