@nodii/dev 0.6.24 → 0.6.26

package/dist/doctor.js

@@ -5,6 +5,7 @@ import { devRequest, encode, isOAuthConfig, query, setAuthProvider } from "./cor
 import { OAuthAuthProvider, decodeClaims, loadRefreshToken } from "./oauth.js";
 import { inferGitContext, repoName } from "./lanes.js";
 import { figmaFileKey, figmaLockCheck, holdsSet, notRegisteredHint, scopeText } from "./figma.js";
+import { hookDiagnostics } from "./hook-doctor.js";
 
 /**
  * What a lane's commands need, in Dev's route policy (staffRuleFor in Dev's
@@ -262,6 +263,25 @@ export async function doctorCommand(deps = {}) {
     }
   }
 
+  // 9. Runtime hooks: present, accepted by that runtime, and observed firing.
+  const hookRoot = context?.worktree ?? deps.cwd ?? process.cwd();
+  try {
+    const runtimes = await (deps.hookDiagnostics ?? hookDiagnostics)(hookRoot);
+    for (const runtime of runtimes) {
+      const key = `hooks_${runtime.runtime.replace(/[^a-z0-9]+/gi, "_")}`;
+      const extra = { runtime: runtime.runtime, installed: runtime.installed, trusted: runtime.trusted, firing: runtime.firing, managed: runtime.managed, lastFiredAt: runtime.lastFiredAt ?? null, ...(runtime.cliStatus ? { cliStatus: runtime.cliStatus } : {}) };
+      if (runtime.installed === null) checks.push(cannot(key, runtime.error ?? "runtime hook registry unavailable", extra));
+      else if (!runtime.installed) checks.push(missing(key, "hooks are not installed", "nodii-dev harness install (or setup --yes)", extra));
+      else if (!runtime.trusted) checks.push(missing(key, `hooks are installed but not trusted${runtime.trustStatuses?.length ? ` (${runtime.trustStatuses.join(", ")})` : ""}`, runtime.runtime.startsWith("codex") ? "review /hooks, or have an operator run the commands printed by `nodii-dev harness update --system`" : "review the runtime hook configuration", extra));
+      else if (runtime.managed && runtime.cliStatus?.ok === false) checks.push(missing(key, `${runtime.cliStatus.message}; managed hooks fail open until this is fixed`, "update nodii-dev, then run `nodii-dev harness update --system` to refresh the absolute CLI path", extra));
+      else if (!runtime.firing) checks.push(missing(key, `hooks are installed and trusted${runtime.managed ? " (managed)" : ""}, but no firing receipt exists`, "start a fresh runtime session and run doctor again", extra));
+      else checks.push(ok(key, `installed, trusted${runtime.managed ? " (managed)" : ""}, and firing (last ${runtime.lastFiredAt})`, extra));
+    }
+  } catch (error) {
+    checks.push(cannot("hooks_claude", error?.message ?? String(error)));
+    checks.push(cannot("hooks_codex", error?.message ?? String(error)));
+  }
+
   const ready = checks.every((x) => x.status === "ok");
   const width = Math.max(...checks.map((x) => x.key.length));
   const human = (p) => [

package/dist/harness.js

@@ -7,9 +7,11 @@ import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname, join, normalize, sep } from "node:path";
+import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 import { CliError, devRequest, query } from "./core.js";
-import { safetySettingsSnippet } from "./safety.js";
+import { managedHookBundle, nodiiCommandArgs, writeManagedHookBundle } from "./managed-hooks.js";
+import { codexSafetyHooksSnippet, regroundingHooksSnippet, safetySettingsSnippet } from "./safety.js";
 
 /** What this CLI wrote, per path: { mode, sha256 }, or for merge-json the hook entries it `added`. */
 export const STATE_PATH = ".nodii/harness-state.json";
@@ -35,7 +37,7 @@ async function optional(path) {
 
 // The only files Dev generates (AD-era contract §7). Anything else, such as a
 // git hook or a CI workflow, is refused whatever the disk's case rules.
-const HARNESS_PATHS = [/^CLAUDE\.md$/, /^AGENTS\.md$/, /^\.claude\/settings\.json$/, /^\.nodii\/harness\.json$/, /^\.claude\/skills\/nodii-[a-z0-9][a-z0-9._-]*\/SKILL\.md$/];
+const HARNESS_PATHS = [/^CLAUDE\.md$/, /^AGENTS\.md$/, /^\.claude\/settings\.json$/, /^\.codex\/hooks\.json$/, /^\.nodii\/harness\.json$/, /^\.claude\/skills\/nodii-[a-z0-9][a-z0-9._-]*\/SKILL\.md$/];
 
 /** A generated path must be one of the harness files the contract names. */
 export function safeRelative(path) {
@@ -142,9 +144,47 @@ export function checkHarness(harness) {
   });
 }
 
+const CODEX_EVENTS = new Set([
+  "SessionStart", "UserPromptSubmit", "PreToolUse", "PermissionRequest", "PostToolUse",
+  "PreCompact", "PostCompact", "SubagentStart", "SubagentStop", "Stop", "Interrupt", "SessionEnd",
+]);
+
+function addHookEntries(hooks, additions) {
+  const out = { ...hooks };
+  for (const [event, entries] of Object.entries(additions ?? {})) {
+    out[event] = [...(out[event] ?? [])];
+    for (const entry of entries) if (!out[event].some((existing) => stable(existing) === stable(entry))) out[event].push(entry);
+  }
+  return out;
+}
+
+function assertNodiiHooks(hooks, path) {
+  for (const [event, entries] of Object.entries(hooks ?? {}))
+    for (const entry of entries)
+      for (const handler of entry.hooks ?? [])
+        if (handler.type !== "command")
+          throw new CliError("HARNESS_INVALID", `${path} ${event} hooks may run nodii-dev commands only (MW5-20).`, 1);
+        else try { nodiiCommandArgs(handler.command); }
+        catch { throw new CliError("HARNESS_INVALID", `${path} ${event} hooks may run one nodii-dev command only (MW5-20).`, 1); }
+}
+
+export function codexHooksFromClaude(hooks = {}) {
+  const out = {};
+  for (const [event, entries] of Object.entries(hooks)) {
+    if (!CODEX_EVENTS.has(event)) continue;
+    out[event] = entries.map((entry) => {
+      if (!["PreToolUse", "PermissionRequest", "PostToolUse"].includes(event) || !entry.matcher) return structuredClone(entry);
+      const translated = entry.matcher.replace(/\b(?:Edit|Write|MultiEdit|NotebookEdit)\b/g, "apply_patch");
+      const matcher = translated.replace(/\|apply_patch(?=(?:\|apply_patch)+\))/g, "");
+      return { ...structuredClone(entry), matcher };
+    });
+  }
+  return out;
+}
+
 // Safety enforcement is executable CLI behaviour, not methodology prose. Add
-// its nodii-dev-only hook entries to the settings fragment Dev generated so a
-// normal harness install/update always installs the matching CLI hooks.
+// its nodii-dev-only entries for both runtimes. Codex receives the same
+// lifecycle blocks with runtime-specific tool matchers.
 export function withSafetyHooks(harness) {
   checkHarness(harness);
   const copy = { ...harness, files: harness.files.map((file) => ({ ...file })) };
@@ -156,13 +196,25 @@ export function withSafetyHooks(harness) {
   if (settings.mode !== "merge-json")
     throw new CliError("HARNESS_INVALID", "Dev must generate .claude/settings.json as merge-json so nodii-dev can install safety hooks.", 1);
   const parsed = JSON.parse(settings.content);
-  const hooks = { ...(parsed.hooks ?? {}) };
-  for (const [event, entries] of Object.entries(safetySettingsSnippet().hooks)) {
-    hooks[event] = [...(hooks[event] ?? [])];
-    for (const entry of entries) if (!hooks[event].some((existing) => stable(existing) === stable(entry))) hooks[event].push(entry);
-  }
+  let hooks = addHookEntries(parsed.hooks, safetySettingsSnippet().hooks);
+  hooks = addHookEntries(hooks, regroundingHooksSnippet().hooks);
+  assertNodiiHooks(hooks, ".claude/settings.json");
   settings.content = JSON.stringify({ ...parsed, hooks });
   settings.sha256 = sha(settings.content);
+
+  let codex = copy.files.find((file) => file.path === ".codex/hooks.json");
+  if (!codex) {
+    codex = { path: ".codex/hooks.json", mode: "merge-json", kind: "settings", content: "{}" };
+    copy.files.push(codex);
+  }
+  if (codex.mode !== "merge-json")
+    throw new CliError("HARNESS_INVALID", "Dev must generate .codex/hooks.json as merge-json so nodii-dev can install Codex hooks.", 1);
+  const codexParsed = JSON.parse(codex.content);
+  let codexHooks = addHookEntries(codexParsed.hooks, codexHooksFromClaude(hooks));
+  codexHooks = addHookEntries(codexHooks, codexSafetyHooksSnippet().hooks);
+  assertNodiiHooks(codexHooks, ".codex/hooks.json");
+  codex.content = JSON.stringify({ ...codexParsed, hooks: codexHooks });
+  codex.sha256 = sha(codex.content);
   return copy;
 }
 
@@ -181,7 +233,7 @@ export async function planHarness(root, harness, { install, adopt = [], request
   const owned = state?.files ?? {};
   const adopted = new Set(adopt.map((path) => {
     try { return safeRelative(path); }
-    catch { throw new CliError("USAGE", `--adopt ${path} is not a harness file (CLAUDE.md, AGENTS.md, .claude/settings.json, .claude/skills/nodii-CODE/SKILL.md).`, 2); }
+    catch { throw new CliError("USAGE", `--adopt ${path} is not a harness file (CLAUDE.md, AGENTS.md, .claude/settings.json, .codex/hooks.json, .claude/skills/nodii-CODE/SKILL.md).`, 2); }
   }));
   const changes = [];
   const conflicts = [];
@@ -315,6 +367,21 @@ export async function repoContext(cwd = process.cwd()) {
 const flagList = (value) => (value === undefined || value === true ? [] : [value].flat().flatMap((x) => String(x).split(",")).filter(Boolean));
 const changeLine = (c) => `${{ create: "+", remove: "-" }[c.action] ?? "~"} ${c.path}${["create", "update", "remove"].includes(c.action) ? "" : ` (${c.action})`}`;
 
+const shellQuote = (value) => `'${String(value).replaceAll("'", `'\\''`)}'`;
+
+/**
+ * Print-only operator plan for the managed Codex layer. The CLI deliberately
+ * never invokes sudo: an operator reviews the generated hooks before copying
+ * the exact repository file into Codex's trusted system layer.
+ */
+export function systemHookInstallPlan(bundle) {
+  const source = join(bundle.dir, "requirements.toml");
+  return [
+    "sudo install -d -m 0755 /etc/codex",
+    `sudo install -m 0644 ${shellQuote(source)} /etc/codex/requirements.toml`,
+  ];
+}
+
 // What each planned change means for a check: how the file on disk differs from Dev's.
 const DIFFERENCE = {
   create: "missing; Dev would create it",
@@ -370,8 +437,8 @@ async function checkCommand(root, repo, state, fetchHarness) {
   };
 }
 
-export async function harnessCommand(action, flags, { request = devRequest, context = repoContext } = {}) {
-  if (!["install", "update", "check"].includes(action)) throw new CliError("USAGE", "harness install|update|check [--repo NAME] [--service ID] [--include-drafts[=false]] [--adopt PATH,...] [--dry-run] [--check]", 2);
+export async function harnessCommand(action, flags, { request = devRequest, context = repoContext, managedHome, managedCliPath = fileURLToPath(new URL("../bin/nodii-dev", import.meta.url)), writeManaged = writeManagedHookBundle } = {}) {
+  if (!["install", "update", "check"].includes(action)) throw new CliError("USAGE", "harness install|update|check [--repo NAME] [--service ID] [--include-drafts[=false]] [--adopt PATH,...] [--dry-run] [--check] [--system]", 2);
   if (flags.fleet || flags.all) throw new CliError("USAGE", "The harness is installed one service at a time, in that service's repository. There is no fleet mode.", 2);
   if (flags.root === true || flags.repo === true) throw new CliError("USAGE", "--root and --repo need a value.", 2);
   const ctx = flags.root ? { root: flags.root, repo: flags.repo } : await context();
@@ -382,18 +449,33 @@ export async function harnessCommand(action, flags, { request = devRequest, cont
   const saved = action === "install" ? {} : (state?.request ?? {});
   const serviceId = flags.service && flags.service !== true ? String(flags.service) : (saved.serviceId ?? undefined);
   const includeDrafts = flags["include-drafts"] !== undefined ? flags["include-drafts"] !== "false" : Boolean(saved.includeDrafts);
-  const params = { repo, serviceId, includeDrafts: includeDrafts ? "true" : undefined };
-  const fetchHarness = async () => {
-    const response = await request("GET", `/api/v1/harness${query(params)}`);
-    return { ...response, data: withSafetyHooks(response.data) };
+  let effectiveIncludeDrafts = includeDrafts;
+  const fetchHarness = async ({ draftFallback = false } = {}) => {
+    const get = () => request("GET", `/api/v1/harness${query({ repo, serviceId, includeDrafts: effectiveIncludeDrafts ? "true" : undefined })}`);
+    let response;
+    let fallback = false;
+    try { response = await get(); }
+    catch (error) {
+      if (!draftFallback || effectiveIncludeDrafts || error?.code !== "METHODOLOGY_NOT_AVAILABLE") throw error;
+      effectiveIncludeDrafts = true;
+      fallback = true;
+      response = await get();
+    }
+    const sources = response.data?.sources ?? [];
+    const draftSources = sources.filter((source) => source.status !== "ratified");
+    const draftNotice = draftSources.length
+      ? `${fallback || draftSources.length === sources.length ? "No methodology is ratified; using latest draft methodology" : "Using draft methodology"} ${response.data.methodologyVersion} (${draftSources.map((source) => `${source.code} ${source.version}`).join(", ")}).`
+      : null;
+    const data = draftNotice ? { ...response.data, warnings: [...(response.data.warnings ?? []), draftNotice] } : response.data;
+    return { ...response, data: withSafetyHooks(data) };
   };
 
   if (action === "install" && flags.check) throw new CliError("USAGE", "--check goes with `harness update`; to preview an install use --dry-run.", 2);
-  if (action === "check" && (flags["dry-run"] || flags.adopt)) throw new CliError("USAGE", "harness check writes nothing; --dry-run and --adopt go with install and update.", 2);
+  if (action === "check" && (flags["dry-run"] || flags.adopt || flags.system)) throw new CliError("USAGE", "harness check writes nothing; --dry-run, --adopt and --system go with install and update.", 2);
   if (action === "check" || (action === "update" && flags.check)) return checkCommand(ctx.root, repo, state, fetchHarness);
 
-  const harness = (await fetchHarness()).data;
-  const plan = await planHarness(ctx.root, harness, { install: action === "install", adopt: flagList(flags.adopt), request: { ...(serviceId ? { serviceId } : {}), includeDrafts } });
+  const harness = (await fetchHarness({ draftFallback: true })).data;
+  const plan = await planHarness(ctx.root, harness, { install: action === "install", adopt: flagList(flags.adopt), request: { ...(serviceId ? { serviceId } : {}), includeDrafts: effectiveIncludeDrafts } });
   const summary = {
     repo: harness.repo, serviceId: harness.serviceId ?? null,
     from: state?.methodologyVersion ?? null, to: harness.methodologyVersion,
@@ -411,7 +493,18 @@ export async function harnessCommand(action, flags, { request = devRequest, cont
     throw new CliError("HARNESS_CONFLICT",
       `Nothing written. These files are not nodii-dev's to change:\n${plan.conflicts.map((c) => `  ${c.path}: ${c.reason}`).join("\n")}\n` +
       "Restore files nodii-dev wrote (git checkout, or remove your edits). For your own files, remove them or let nodii-dev take them over with --adopt PATH[,PATH].", 1, summary);
-  if (flags["dry-run"]) return { payload: { data: { ...summary, dryRun: true } }, human: `${lines.join("\n")}\n${plan.changes.length ? "Dry run: nothing written." : "No changes."}` };
+  const codexChange = plan.changes.find((change) => change.path === ".codex/hooks.json");
+  const codexText = codexChange?.text ?? await optional(join(ctx.root, ".codex/hooks.json"));
+  const managedBundle = flags.system ? managedHookBundle(codexText, { home: managedHome, cliPath: managedCliPath }) : null;
+  const systemCommands = managedBundle ? systemHookInstallPlan(managedBundle) : [];
+  if (flags["dry-run"]) {
+    const preview = managedBundle ? `\nWould stage managed Codex hooks in ${managedBundle.dir}. Dry run: no managed files were written and no sudo commands are printed until they exist.` : "";
+    return { payload: { data: { ...summary, dryRun: true, ...(managedBundle ? { managedDir: managedBundle.dir } : {}) } }, human: `${lines.join("\n")}\n${plan.changes.length ? "Dry run: nothing written." : "No changes."}${preview}` };
+  }
+  const systemText = systemCommands.length
+    ? `\nManaged Codex hooks are staged in ${managedBundle.dir}. One operator install covers codex-personal and codex-work; review ${join(managedBundle.dir, "requirements.toml")}, then run:\n${systemCommands.join("\n")}\nNo privileged command was run. Later --system updates refresh the user-owned managed directory without sudo.`
+    : "";
   await applyHarness(ctx.root, plan);
-  return { payload: { data: { ...summary, applied: true } }, human: `${lines.join("\n")}\n${plan.changes.length ? `${action === "install" ? "Installed" : "Updated"}: ${plan.changes.length} change${plan.changes.length === 1 ? "" : "s"}.` : "Harness already current."}` };
+  if (managedBundle) await writeManaged(managedBundle);
+  return { payload: { data: { ...summary, applied: true, ...(systemCommands.length ? { systemCommands, managedDir: managedBundle.dir } : {}) } }, human: `${lines.join("\n")}\n${plan.changes.length ? `${action === "install" ? "Installed" : "Updated"}: ${plan.changes.length} change${plan.changes.length === 1 ? "" : "s"}.` : "Harness already current."}${systemText}` };
 }

package/dist/hook-doctor.js

@@ -0,0 +1,126 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { readFile, rm, writeFile } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { HOOK_EVENTS } from "./safety.js";
+import { managedHookCliStatus } from "./managed-hooks.js";
+
+const execFileAsync = promisify(execFile);
+
+async function optional(path) {
+  try { return await readFile(path, "utf8"); }
+  catch (error) { if (error.code === "ENOENT") return null; throw error; }
+}
+
+const nodiiEntries = (hooks = {}) => Object.values(hooks).flat().filter((entry) =>
+  (entry.hooks ?? []).some((hook) => hook.type === "command" && /^nodii-dev(?:\s|$)/.test(String(hook.command ?? ""))),
+);
+
+async function firingEvents(root) {
+  try {
+    const path = (await execFileAsync("git", ["-C", root, "rev-parse", "--path-format=absolute", "--git-path", HOOK_EVENTS], { encoding: "utf8" })).stdout.trim();
+    const text = await optional(path);
+    return String(text ?? "").trim().split("\n").filter(Boolean).flatMap((line) => {
+      try { return [JSON.parse(line)]; } catch { return []; }
+    });
+  } catch { return []; }
+}
+
+/** Read the hook registry Codex itself resolved for this cwd. */
+export function codexHooksList(cwd, { codexBin = "codex", spawnImpl = spawn, timeoutMs = 5_000, env = process.env } = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawnImpl(codexBin, ["app-server", "--stdio"], { cwd, env, stdio: ["pipe", "pipe", "pipe"] });
+    const pidFile = join(tmpdir(), `nodii-dev-codex-hooks-${child.pid ?? "starting"}-${randomUUID()}.pid`);
+    let stdout = "";
+    let stderr = "";
+    let listed = null;
+    let settled = false;
+    let forceTimer;
+    let pidSaved = Promise.reject(new Error("Codex process did not start"));
+    pidSaved.catch(() => {});
+    const cleanup = async () => { clearTimeout(timer); clearTimeout(forceTimer); await rm(pidFile, { force: true }).catch(() => {}); };
+    const finish = async (error) => {
+      if (settled) return;
+      settled = true;
+      await cleanup();
+      if (error) reject(error); else resolve(listed ?? []);
+    };
+    const send = (value) => child.stdin.write(`${JSON.stringify(value)}\n`);
+    const timer = setTimeout(() => {
+      child.stdin.end();
+      forceTimer = setTimeout(async () => {
+        try { await pidSaved; child.kill("SIGTERM"); } catch {}
+      }, 1_000);
+    }, timeoutMs);
+    child.on("spawn", () => { pidSaved = writeFile(pidFile, `${child.pid}\n`, { mode: 0o600 }); pidSaved.catch(() => {}); });
+    child.on("error", (error) => finish(error));
+    child.stderr.on("data", (chunk) => { if (stderr.length < 4_096) stderr += chunk; });
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+      for (;;) {
+        const newline = stdout.indexOf("\n");
+        if (newline < 0) break;
+        const line = stdout.slice(0, newline);
+        stdout = stdout.slice(newline + 1);
+        if (!line) continue;
+        let message;
+        try { message = JSON.parse(line); } catch { continue; }
+        if (message.id === 1) {
+          send({ method: "initialized", params: {} });
+          send({ id: 2, method: "hooks/list", params: { cwd } });
+        } else if (message.id === 2) {
+          if (message.error) { child.stdin.end(); finish(new Error(message.error.message ?? "Codex hooks/list failed")); return; }
+          listed = message.result?.data ?? [];
+          child.stdin.end();
+        }
+      }
+    });
+    child.on("exit", (code) => {
+      if (listed) finish();
+      else finish(new Error(`codex app-server exited ${code ?? "without a status"}${stderr.trim() ? `: ${stderr.trim()}` : ""}`));
+    });
+    send({ id: 1, method: "initialize", params: { clientInfo: { name: "nodii-dev-doctor-probe", title: "nodii-dev doctor probe", version: "0.0.0" } } });
+  });
+}
+
+export async function hookDiagnostics(root, deps = {}) {
+  const events = await (deps.firingEvents ?? firingEvents)(root);
+  const fired = (runtime) => events.filter((event) => event.runtime === runtime || event.profile === runtime).at(-1) ?? null;
+  let claude = {};
+  try { claude = JSON.parse((await optional(join(root, ".claude/settings.json"))) ?? "{}"); }
+  catch { claude = {}; }
+  const claudeInstalled = nodiiEntries(claude.hooks).length > 0;
+  const out = [{
+    runtime: "claude", installed: claudeInstalled, trusted: claudeInstalled,
+    firing: Boolean(fired("claude")), lastFiredAt: fired("claude")?.at ?? null,
+    managed: false,
+  }];
+  const profiles = deps.codexProfiles ?? [
+    { runtime: "codex-personal", home: join(homedir(), ".codex") },
+    { runtime: "codex-work", home: join(homedir(), ".codex-work") },
+  ];
+  const cliStatus = await (deps.managedHookCliStatus ?? managedHookCliStatus)({ home: deps.home ?? homedir() });
+  for (const profile of profiles) {
+    try {
+      const data = await (deps.codexHooksList ?? codexHooksList)(root, { ...deps, env: { ...(deps.env ?? process.env), CODEX_HOME: profile.home } });
+      const record = data.find((item) => item.cwd === root) ?? data[0] ?? {};
+      const hooks = record.hooks ?? [];
+      const managedHooks = hooks.filter((hook) => hook.isManaged === true || hook.trustStatus === "managed");
+      const trustedHooks = hooks.filter((hook) => hook.isManaged === true || ["managed", "trusted"].includes(hook.trustStatus));
+      out.push({
+        runtime: profile.runtime, profileHome: profile.home, installed: hooks.length > 0, trusted: managedHooks.length > 0 || (hooks.length > 0 && trustedHooks.length === hooks.length),
+        firing: Boolean(fired(profile.runtime)), lastFiredAt: fired(profile.runtime)?.at ?? null,
+        managed: managedHooks.length > 0, managedCount: managedHooks.length,
+        ...(managedHooks.length ? { cliStatus } : {}),
+        trustStatuses: [...new Set(hooks.map((hook) => hook.trustStatus ?? "unknown"))],
+        warnings: record.warnings ?? [], errors: record.errors ?? [],
+      });
+    } catch (error) {
+      out.push({ runtime: profile.runtime, profileHome: profile.home, installed: null, trusted: null, firing: Boolean(fired(profile.runtime)), lastFiredAt: fired(profile.runtime)?.at ?? null, managed: null, error: error.message });
+    }
+  }
+  return out;
+}

package/dist/hooks.js

@@ -1,6 +1,8 @@
-import { CliError, devRequest } from "./core.js";
+import { CliError, devRequest, readConfig } from "./core.js";
 import { FOUNDATIONS_ID, figmaLockCheck, outOfScopeText } from "./figma.js";
 import { execFile } from "node:child_process";
+import { realpath } from "node:fs/promises";
+import { resolve } from "node:path";
 import { promisify } from "node:util";
 import { safetySettingsSnippet } from "./safety.js";
 
@@ -214,6 +216,34 @@ export async function heartbeatCurrentLane(request = devRequest) {
   return { heartbeated: true, key: lane.key };
 }
 
+/** SessionStart compact context, plain text for both Claude and Codex. */
+export async function sessionStartContext(payload, { request = devRequest, config = readConfig } = {}) {
+  if (payload?.source !== "compact") return null;
+  let lane = null;
+  try {
+    const cwd = payload.cwd ?? process.cwd();
+    const branch = (await execFileAsync("git", ["branch", "--show-current"], { cwd, encoding: "utf8" })).stdout.trim();
+    const rootText = (await execFileAsync("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf8" })).stdout.trim();
+    const root = await realpath(rootText).catch(() => resolve(rootText));
+    const current = await config(false);
+    const lanes = (await request("GET", "/api/v1/lanes?limit=200")).data ?? [];
+    for (const item of lanes) {
+      if (item.agentId !== current.agentId || item.branch !== branch || ["on_dev", "stopped"].includes(item.status)) continue;
+      const worktree = await realpath(item.worktree ?? root).catch(() => resolve(item.worktree ?? root));
+      if (worktree === root) { lane = item; break; }
+    }
+  } catch {}
+  if (!lane) return "Freeze re-grounding: no active Dev lane was available for this branch; re-read the lane brief before continuing.";
+  const freeze = lane.freeze ?? {};
+  return [
+    `Freeze re-grounding for ${lane.key}:`,
+    `title: ${lane.title ?? "(untitled)"}`,
+    `status: ${lane.status}`,
+    `boundaries: ${JSON.stringify(freeze.boundaries ?? {})}`,
+    `rules: ${JSON.stringify(freeze.rules ?? freeze.ruleRefs ?? [])}`,
+  ].join("\n");
+}
+
 export function workflowSuggestion(payload) {
   const command = payload?.tool_input?.command ?? "";
   if (/\bgit\s+push\b/.test(command)) return "nodii-dev: pushed work; record it with `nodii-dev lane evidence <key> --commit <sha>` or `--pr <url>`.";

package/dist/lanes.js

@@ -1,7 +1,8 @@
 import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
 import { promisify } from "node:util";
 import { CliError, encode, devRequest, query, readConfig, requireFlag } from "./core.js";
-import { recordReviewReceipt } from "./safety.js";
+import { recordReviewReceipt, reviewCommitContext } from "./safety.js";
 
 const execFileAsync = promisify(execFile);
 const via = { via: "nodii-dev" };
@@ -53,6 +54,19 @@ function evidence(flags) {
 
 const list = (value) => String(value).split(",").map((x) => x.trim()).filter(Boolean);
 
+export async function reviewBody(flags, read = (path) => readFile(path, "utf8")) {
+  const file = requireFlag(flags, "file");
+  let body;
+  try {
+    body = JSON.parse(await read(file));
+  } catch (error) {
+    throw new CliError("REVIEW_FILE_INVALID", `Cannot read review JSON from ${file}: ${error.message}`, 2);
+  }
+  if (!body || typeof body !== "object" || Array.isArray(body))
+    throw new CliError("REVIEW_FILE_INVALID", "The review file must contain one JSON object.", 2);
+  return { ...body, ...via };
+}
+
 /**
  * DEC-0011 (MW1-28.1): the body for `lane non-issue`. A re-route needs at
  * least one issue key or an explicit `none`, and the branch work is either
@@ -99,7 +113,7 @@ export async function branchCommits(lane) {
   }
 }
 
-export async function laneCommand(action, args, flags, { request = devRequest, config = readConfig, gitContext = inferGitContext, commitsOf = branchCommits, reviewReceipt = recordReviewReceipt } = {}) {
+export async function laneCommand(action, args, flags, { request = devRequest, config = readConfig, gitContext = inferGitContext, commitsOf = branchCommits, read = (path) => readFile(path, "utf8"), reviewContext = reviewCommitContext, reviewReceipt = recordReviewReceipt } = {}) {
   if (action === "list") {
     const c = flags.mine ? await config() : null;
     const payload = await request("GET", `/api/v1/lanes${query({ kind: flags.kind, status: flags.status, machine: flags.machine, agent: flags.mine ? c.agentId : flags.agent, "waiting-on": flags["waiting-on"], stuck: flags.stuck, cursor: flags.cursor, limit: flags.limit })}`);
@@ -170,12 +184,50 @@ export async function laneCommand(action, args, flags, { request = devRequest, c
   }
   if (action === "land") return { payload: await request("POST", `/api/v1/lanes/${encode(id)}/land`, via), human: `${ref}: recorded on main.` };
   if (action === "review") {
-    const payload = await request("POST", `/api/v1/lanes/${encode(id)}/review`, via);
+    const body = await reviewBody(flags, read);
+    const current = await reviewContext();
+    if (body.head !== current.commit || body.base !== current.base)
+      throw new CliError(
+        "REVIEW_FILE_STALE",
+        `The review file covers base ${body.base ?? "(missing)"} and head ${body.head ?? "(missing)"}, but this worktree is base ${current.base} and head ${current.commit}. Review the current diff and write a new receipt.`,
+        2,
+      );
+    const payload = await request("POST", `/api/v1/lanes/${encode(id)}/review`, body);
     try { await reviewReceipt(); }
     catch (error) {
-      throw new CliError("REVIEW_RECEIPT_FAILED", `${ref}: Dev recorded the review, but the local push receipt could not be written (${error?.message ?? error}). Re-run nodii-dev lane review ${ref} from its worktree.`, 1);
+      throw new CliError("REVIEW_RECEIPT_FAILED", `${ref}: Dev recorded the review, but the local push receipt could not be written (${error?.message ?? error}). Re-run nodii-dev lane review ${ref} --file REVIEW.json from its worktree.`, 1);
     }
-    return { payload, human: `${ref}: review recorded for the current commit and origin/main.` };
+    return {
+      payload,
+      human: (p) => {
+        const findings = p.data.findings ?? [];
+        const missed = findings.filter((finding) => finding.missedTrigger === true).length;
+        return `${ref}: review recorded for the current commit and origin/main (${p.data.exitReason}; ${findings.length} finding(s), ${missed} missed trigger(s)).`;
+      },
+    };
+  }
+  if (action === "reviews") {
+    const payload = await request("GET", `/api/v1/lanes/${encode(id)}`);
+    return {
+      payload,
+      human: (p) => {
+        const reviews = p.data.reviews ?? [];
+        return reviews.length
+          ? reviews
+              .map((run) => {
+                const missed = run.findings.filter((finding) => finding.missedTrigger === true).length;
+                return [
+                  `${run.createdAt}\t${run.head}\t${run.exitReason}\t${run.findings.length} finding(s)\t${missed} missed trigger(s)`,
+                  ...run.findings.map(
+                    (finding) =>
+                      `  ${finding.severity}\t${finding.perspective}\t${finding.clauseId ?? "-"}\t${finding.summary}${finding.missedTrigger ? "\tMISSED_TRIGGER" : ""}`,
+                  ),
+                ].join("\n");
+              })
+              .join("\n")
+          : `No reviews recorded for ${ref}.`;
+      },
+    };
   }
   if (action === "verify") {
     const value = requireFlag(flags, "dev-check");