@inerrata-corporation/errata 2.0.6-dev.2752 → 2.0.6-dev.2759

package/errata.mjs

@@ -71189,7 +71189,7 @@ var init_report_render = __esm({
 init_src6();
 import { closeSync as closeSync2, existsSync as existsSync34, openSync as openSync2, readFileSync as readFileSync35, renameSync as renameSync4, statSync as statSync8 } from "node:fs";
 import { join as join40, resolve as pathResolve2 } from "node:path";
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 
 // src/daemon.ts
 import { existsSync as existsSync26, writeFileSync as writeFileSync22 } from "node:fs";
@@ -79907,7 +79907,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.6-dev.2752" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.6-dev.2759" : "2.0.0-alpha.0";
 var IGNORED_PATH = /[\\/](?:\.git|node_modules|\.errata|\.claude|\.codex|\.cursor|\.turbo|\.next|dist|coverage|test-results|playwright-report|__pycache__)(?:[\\/]|$)/;
 var IGNORED_NOISE = /castalia\.db|eventlog\.sqlite|turn-cursors/;
 var GIT_OP_MUTE_MS = 4e3;
@@ -85577,6 +85577,7 @@ var SessionAffinity = class {
 };
 
 // src/multi.ts
+init_checkout_root();
 var PROCESS_STARTED_AT = Date.now();
 var SELF_ENTRY = process.argv[1] ? pathResolve(process.argv[1]) : "";
 var LOCAL_BUILD_ENTRY = SELF_ENTRY && !isInstalledEntry(SELF_ENTRY) ? SELF_ENTRY : void 0;
@@ -86124,6 +86125,19 @@ async function startMultiDaemon(opts = {}) {
       if (owner) break;
       owner = ownerOf(records, p);
     }
+    if (!owner) {
+      for (const p of [primary, ...others]) {
+        if (!p) continue;
+        const gitRoot = nearestGitRoot(p);
+        const main2 = gitRoot ? mainCheckoutOfWorktree(gitRoot) : null;
+        if (!main2) continue;
+        owner = ownerOf(records, main2);
+        if (!owner && listWorkspaceEntries().some((e) => pickOwnerRoot([e.path], main2))) {
+          if (attachWorkspace(main2).attached) owner = ownerOf(records, main2);
+        }
+        if (owner) break;
+      }
+    }
     if (!owner && others.length > 0) {
       const registryRoots = listWorkspaceEntries().map((e) => e.path);
       const registered = others.map((p) => pickOwnerRoot(registryRoots, p)).find((r) => r != null);
@@ -87552,9 +87566,9 @@ function deriveAuthBase(verificationUri) {
 }
 function openInBrowser(url2) {
   try {
-    void import("node:child_process").then(({ spawn: spawn5 }) => {
+    void import("node:child_process").then(({ spawn: spawn6 }) => {
       const [cmd2, args2] = process.platform === "win32" ? ["cmd", ["/c", "start", "", url2]] : process.platform === "darwin" ? ["open", [url2]] : ["xdg-open", [url2]];
-      spawn5(cmd2, args2, { detached: true, stdio: "ignore" }).unref();
+      spawn6(cmd2, args2, { detached: true, stdio: "ignore" }).unref();
     });
   } catch {
   }
@@ -87634,6 +87648,7 @@ function installedHarnessVersion(bin) {
 }
 async function diagnoseInstallation(cfg, dependencies) {
   const checks = [];
+  if (dependencies.codexHooks) checks.push(...await dependencies.codexHooks());
   const profileName = cfg.activeInstallationProfile;
   const profile = profileName ? cfg.installationProfiles[profileName] : void 0;
   checks.push(
@@ -87727,6 +87742,97 @@ async function diagnoseInstallation(cfg, dependencies) {
   };
 }
 
+// src/codex-doctor.ts
+import { spawn as spawn4 } from "node:child_process";
+import { createInterface } from "node:readline";
+function readCodexHookState(cwd, options = {}) {
+  return new Promise((resolve7, reject) => {
+    const child = spawn4(options.bin ?? "codex", options.args ?? ["app-server", "--stdio"], {
+      cwd,
+      windowsHide: true,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const lines = createInterface({ input: child.stdout });
+    let settled = false;
+    let size = 0;
+    let hooks;
+    let features;
+    const finish = (error48) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      lines.close();
+      child.kill();
+      if (error48) reject(error48);
+      else resolve7({ ...hooks, features });
+    };
+    const timer = setTimeout(() => finish(new Error("Codex hook inspection timed out")), options.timeoutMs ?? 1e4);
+    const send = (id, method, params) => {
+      child.stdin.write(JSON.stringify({ id, method, params }) + "\n");
+    };
+    child.on("error", () => finish(new Error("Codex could not be started for hook inspection")));
+    child.on("exit", () => finish(new Error("Codex exited before returning its hook state")));
+    child.stdin.on("error", () => finish(new Error("Codex hook inspection connection closed")));
+    child.stderr.resume();
+    child.stdout.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > 2e6) finish(new Error("Codex hook inspection exceeded its response budget"));
+    });
+    lines.on("line", (line) => {
+      if (settled) return;
+      let message2;
+      try {
+        message2 = JSON.parse(line);
+      } catch {
+        return;
+      }
+      if (![1, 2, 3].includes(message2.id)) return;
+      if (message2.error) return finish(new Error("Codex does not support hook inspection; update Codex and review /hooks"));
+      if (message2.id === 1) {
+        child.stdin.write(JSON.stringify({ method: "initialized" }) + "\n");
+        send(2, "hooks/list", { cwds: [cwd] });
+        send(3, "config/read", { cwd, includeLayers: false });
+      } else if (message2.id === 2) {
+        const entry = message2.result?.data?.[0];
+        if (!Array.isArray(entry?.hooks)) return finish(new Error("Codex returned no hook inspection result"));
+        hooks = { hooks: entry.hooks, errors: entry.errors };
+      } else {
+        if (!message2.result?.config) return finish(new Error("Codex returned no effective configuration"));
+        features = message2.result.config.features ?? {};
+      }
+      if (hooks && features) finish();
+    });
+    send(1, "initialize", {
+      clientInfo: { name: "errata_doctor", version: "1.0.0" },
+      capabilities: { experimentalApi: true }
+    });
+  });
+}
+function assessCodexHooks(state) {
+  const check2 = (status, detail) => [{ id: "codex_hooks", status, detail }];
+  if (state.errors?.length) return check2("fail", "Codex could not load hook configuration; inspect /hooks for errors");
+  if ((state.features?.hooks ?? state.features?.codex_hooks) === false) {
+    return check2("fail", "Codex hooks are explicitly disabled; left unchanged");
+  }
+  const hooks = state.hooks.filter((h) => h.command?.includes("errata-relay.mjs"));
+  const required2 = ["sessionStart", "userPromptSubmit", "preToolUse", "postToolUse", "stop"];
+  const missing = required2.filter((event) => !hooks.some((h) => h.eventName === event));
+  const checks = [];
+  if (missing.length) checks.push(...check2("fail", `Errata hooks missing or outdated in this checkout (${missing.join(", ")}); run errata install-hooks codex here`));
+  if (hooks.some((h) => !h.enabled)) checks.push(...check2("fail", "Errata hooks are disabled in Codex; review /hooks; left unchanged"));
+  if (hooks.some((h) => !["trusted", "managed"].includes(h.trustStatus))) {
+    checks.push(...check2("fail", "Errata hooks need review/trust in Codex /hooks before they can run; project trust is separate"));
+  }
+  return checks.length ? checks : check2("pass", "Codex discovers enabled, trusted Errata hooks; verify live context and capture in a session");
+}
+async function diagnoseCodexHooks(cwd) {
+  try {
+    return assessCodexHooks(await readCodexHookState(cwd));
+  } catch (error48) {
+    return [{ id: "codex_hooks", status: "fail", detail: error48 instanceof Error ? error48.message : "Cannot verify Codex hooks" }];
+  }
+}
+
 // src/whoami.ts
 async function resolveWhoami(client, actingHandle) {
   return actingHandle ? client.contextAs(actingHandle) : client.context();
@@ -87819,8 +87925,8 @@ function buildCodexHooksToml(port, options) {
   };
   if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error("Invalid hook port");
   const command = quote(options.nodePath) + " " + quote(options.relayPath) + " " + port;
-  const handlers = ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse"].map(
-    (event) => "[[hooks." + event + "]]\n" + (event === "UserPromptSubmit" ? "" : 'matcher = ".*"\n') + "\n[[hooks." + event + '.hooks]]\ntype = "command"\ncommand = ' + JSON.stringify(command) + "\ntimeout = 10\nadditionalContextLimit = 5000\n"
+  const handlers = ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "Stop"].map(
+    (event) => "[[hooks." + event + "]]\n" + (["UserPromptSubmit", "Stop"].includes(event) ? "" : 'matcher = ".*"\n') + "\n[[hooks." + event + '.hooks]]\ntype = "command"\ncommand = ' + JSON.stringify(command) + "\ntimeout = 10\nadditionalContextLimit = 5000\n"
   );
   return CODEX_HOOKS_BEGIN + "\n" + handlers.join("\n") + CODEX_HOOKS_END + "\n";
 }
@@ -87853,7 +87959,8 @@ try {
     } catch { /* An unavailable daemon must never block the agent. */ }
   };
   if (event === 'PreToolUse' || event === 'PostToolUse') await post('hook', true);
-  if (event === 'PostToolUse') await post('turn');
+  // Stop sees the final assistant message, including turns with no tools.
+  if (event === 'PostToolUse' || event === 'Stop') await post('turn');
   if (['SessionStart', 'UserPromptSubmit', 'PostToolUse'].includes(event)) {
     // Run after capture, so changes already rendered by the daemon arrive now.
     // Background extraction finishing later arrives at the next tool boundary.
@@ -88752,6 +88859,7 @@ async function cmdWhoami(args2) {
 async function cmdDoctor(args2) {
   const cfg = loadConfig();
   const report = await diagnoseInstallation(cfg, {
+    ...hasCodexConfig(process.cwd()) ? { codexHooks: () => diagnoseCodexHooks(process.cwd()) } : {},
     inspect: () => inspectCloudEndpoint(cfg.cloudUrl),
     authenticate: async () => {
       const me = await authedCloudClient(cfg).me();
@@ -90197,7 +90305,7 @@ function spawnDaemonDetached(options = {}) {
     out2 = openSync2(logPath, "a");
   } catch {
   }
-  spawn4(cmd2, args2, {
+  spawn5(cmd2, args2, {
     detached: true,
     stdio: ["ignore", out2, out2],
     windowsHide: true,
@@ -90419,12 +90527,15 @@ async function installCursorMcpConfig() {
   console.log(`  \u26A0\uFE0F  reload Cursor (Cmd/Ctrl-Shift-P \u2192 "Reload Window") to pick it up.`);
 }
 async function installCodexHooks(port) {
-  const file2 = writeCodexHooks(ROOT, port);
+  const gitRoot = nearestGitRoot(process.cwd());
+  const hookRoot = gitRoot && mainCheckoutOfWorktree(gitRoot) ? gitRoot : ROOT;
+  const file2 = writeCodexHooks(hookRoot, port);
   console.log(`installed Codex hooks \u2192 ${file2}`);
   console.log("  Context loads on SessionStart/UserPromptSubmit and refreshes after tools when changed.");
-  console.log("  Tool capture and /api/turn harvesting remain enabled.");
+  console.log("  Tool and final-reply capture are configured; hooks must be trusted before they run.");
   console.log("  Restart/resume Codex to reload config, then review and trust the hooks with /hooks.");
-  console.log("  If your Codex version gates hooks, enable [features] codex_hooks = true.");
+  console.log("  Run `errata doctor` here to check hook discovery and trust; installation alone is not activation.");
+  console.log("  Respect an explicit [features] hooks = false setting (older builds use codex_hooks).");
   console.log("  Older Codex versions may not support every event; update if hooks do not fire.");
 }
 async function refreshLinkedCodexHooks(args2) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inerrata-corporation/errata",
-  "version": "2.0.6-dev.2752",
+  "version": "2.0.6-dev.2759",
   "description": "errata - local-first observation engine for AI coding agents",
   "type": "module",
   "bin": {