@windyroad/jtbd 0.14.6 → 0.14.7

package/.claude-plugin/plugin.json

@@ -90,5 +90,5 @@
     }
   },
   "name": "wr-jtbd",
-  "version": "0.14.6"
+  "version": "0.14.7"
 }

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "wr-jtbd",
-  "version": "0.14.6",
+  "version": "0.14.7",
   "description": "Jobs-to-be-done governance for product changes",
   "author": {
     "name": "Windy Road Technology",

package/hooks/hooks.json

@@ -27,9 +27,26 @@
             "command": "${PLUGIN_ROOT}/hooks/staleness-check.sh"
           }
         ]
+      },
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${PLUGIN_ROOT}/hooks-codex/codex-agent-completion.mjs\""
+          }
+        ]
       }
     ],
     "PreToolUse": [
+      {
+        "matcher": "Bash|Edit|Write|ExitPlanMode",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${PLUGIN_ROOT}/hooks-codex/codex-agent-completion.mjs\""
+          }
+        ]
+      },
       {
         "matcher": "Edit|Write",
         "hooks": [

package/hooks-codex/codex-agent-completion.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
-import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
@@ -10,6 +11,9 @@ const hookDir = dirname(fileURLToPath(import.meta.url));
 const role = "wr-jtbd:agent";
 const writer = join(hookDir, "..", "hooks", "jtbd-mark-reviewed.sh");
 const policy = "docs/jtbd";
+const passPattern = new RegExp("^[ \\t]*>?[ \\t]*\\*\\*JTBD Review: PASS\\*\\*[ \\t]*$", "m");
+const firstLineOnly = true;
+const verdictFile = "/tmp/jtbd-verdict";
 const ttlSeconds = process.env.REVIEW_TTL ?? "3600";
 const ttl = Number(ttlSeconds) * 1000;
 
@@ -17,10 +21,26 @@ function stateDir(sessionId) {
   return join(process.env.TMPDIR || "/tmp", `claude-risk-${sessionId}`);
 }
 
+function transportDir() {
+  return join(process.env.TMPDIR || "/tmp", "codex-review-transport");
+}
+
 function statePath(input, target, suffix = "") {
   return join(stateDir(input.session_id), `codex-review-${Buffer.from(role + ":" + target).toString("base64url")}${suffix}`);
 }
 
+function transportId(sessionId, target) {
+  return createHash("sha256").update(sessionId + "\0" + role + "\0" + target).digest("hex");
+}
+
+function registrationPath(sessionId, target) {
+  return join(transportDir(), `registration-${transportId(sessionId, target)}.json`);
+}
+
+function receiptPath(sessionId, target, suffix = "") {
+  return join(transportDir(), `receipt-${transportId(sessionId, target)}.json${suffix}`);
+}
+
 function normalizeTarget(target) {
   if (typeof target !== "string") return "";
   return target.startsWith("/root/") ? target.slice("/root/".length) : target;
@@ -33,6 +53,47 @@ function policyHash(root) {
   return result.status === 0 && /^[a-f0-9]{64}$/.test(hash || "") ? hash : null;
 }
 
+function expectedExternalKey(prompt) {
+  if (role !== "wr-voice-tone:external-comms" || typeof prompt !== "string" || !prompt) return null;
+  const result = spawnSync("bash", ["-c", 'source "$1"; value="$(cat)"; derive_external_comms_key_from_prompt "$value"',
+    "external-key", join(hookDir, "..", "hooks", "lib", "external-comms-key.sh")], { input: prompt, encoding: "utf8" });
+  const key = result.stdout?.trim();
+  return result.status === 0 && /^[a-f0-9]{64}$/.test(key || "") ? key : null;
+}
+
+function outputAllowed(output, registered) {
+  const candidate = firstLineOnly ? output.split(/\r?\n/).find((line) => line.trim()) || "" : output;
+  if (!passPattern.test(candidate)) return false;
+  if (verdictFile) {
+    try { if (readFileSync(verdictFile, "utf8").trim() !== "PASS") return false; }
+    catch { return false; }
+  }
+  if (role !== "wr-voice-tone:external-comms") return true;
+  const keys = [...output.matchAll(/^EXTERNAL_COMMS_VOICE_TONE_KEY:[ \t]*([a-f0-9]{64})$/gm)];
+  if (keys.length !== 1) return false;
+  return Boolean(registered.expectedKey && registered.expectedKey === keys[0][1]);
+}
+
+function reapTransport() {
+  if (!existsSync(transportDir())) return;
+  for (const name of readdirSync(transportDir())) {
+    const path = join(transportDir(), name);
+    try {
+      const statAge = Date.now() - statSync(path).mtimeMs;
+      if (/^(?:receipt|risk-receipt)-[a-f0-9]{64}\.json\.(?:claim|done)$/.test(name)) {
+        if (!Number.isFinite(statAge) || statAge < 0 || statAge >= ttl) rmSync(path, { force: true });
+        continue;
+      }
+      if (!/^(?:registration|receipt)-[a-f0-9]{64}\.json$/.test(name)) continue;
+      const value = JSON.parse(readFileSync(path, "utf8"));
+      if (value.role !== role) continue;
+      const timestamp = name.startsWith("receipt-") ? value.completedAt : value.createdAt;
+      const age = Date.now() - timestamp;
+      if (!Number.isFinite(age) || age < 0 || age >= ttl) rmSync(path, { force: true });
+    } catch { /* Another completion may own or remove this transport file. */ }
+  }
+}
+
 function diagnostic(reason, input) {
   const dir = process.env.TMPDIR || "/tmp";
   const path = join(dir, "codex-review-completion-diagnostic.json");
@@ -71,9 +132,12 @@ function targetFromSpawn(input) {
 
 function clear(input, target) {
   for (const suffix of ["", ".claim", ".done"]) rmSync(statePath(input, target, suffix), { force: true });
+  rmSync(registrationPath(input.session_id, target), { force: true });
+  for (const suffix of ["", ".claim", ".done"]) rmSync(receiptPath(input.session_id, target, suffix), { force: true });
 }
 
 function remember(input) {
+  reapTransport();
   const target = normalizeTarget(targetFromSpawn(input));
   if (!target) return;
   mkdirSync(stateDir(input.session_id), { recursive: true });
@@ -89,7 +153,17 @@ function remember(input) {
     diagnostic("policy-hash-failed", input);
     return;
   }
-  writeFileSync(statePath(input, target), JSON.stringify({ role, target, ...bound, policyHash: hash }), { mode: 0o600 });
+  const prompt = input.tool_input?.message ?? input.tool_input?.prompt ?? "";
+  const externalKey = expectedExternalKey(prompt);
+  const registered = { parentSession: input.session_id, role, target, ...bound, policyHash: hash,
+    promptDigest: createHash("sha256").update(prompt).digest("hex"), expectedKey: externalKey, createdAt: Date.now() };
+  writeFileSync(statePath(input, target), JSON.stringify(registered), { mode: 0o600 });
+  if (role === "wr-voice-tone:external-comms" && !externalKey) {
+    diagnostic("missing-external-comms-key-binding", input);
+    return;
+  }
+  mkdirSync(transportDir(), { recursive: true, mode: 0o700 });
+  writeFileSync(registrationPath(input.session_id, target), JSON.stringify(registered), { mode: 0o600 });
 }
 
 function claim(input, target) {
@@ -104,54 +178,36 @@ function claim(input, target) {
   return { path, done };
 }
 
-function complete(input, target, output) {
-  target = normalizeTarget(target);
-  if (!target || typeof output !== "string" || !output) return;
-  const path = statePath(input, target);
-  if (existsSync(statePath(input, target, ".done"))) return;
-  if (!existsSync(path)) {
-    diagnostic("missing-parent-registration", input);
-    return;
-  }
-
-  let registered, age;
-  try {
-    registered = JSON.parse(readFileSync(path, "utf8"));
-    age = Date.now() - Math.floor(statSync(path).mtimeMs);
-  }
-  catch {
-    diagnostic("malformed-registration", input);
-    return;
-  }
+function validRegistration(registered, input, target, age) {
   if (registered.role !== role || registered.target !== target) {
     diagnostic("registration-mismatch", input);
-    return;
+    return false;
   }
   if (!Number.isFinite(age) || age < 0) {
     diagnostic("invalid-registration-age", input);
-    return;
+    return false;
   }
   if (age >= ttl) {
     diagnostic("stale-registration", input);
-    return;
+    return false;
   }
-
   const current = checkout(input.cwd || process.cwd());
   if (!current || current.root !== registered.root || current.physical !== registered.physical) {
     diagnostic("checkout-mismatch", input);
-    return;
+    return false;
   }
-
   const hash = policyHash(registered.root);
   if (!hash || hash !== registered.policyHash) {
     diagnostic(hash ? "policy-changed" : "policy-hash-failed", input);
-    return;
+    return false;
   }
+  return true;
+}
 
-  const claimed = claim(input, target);
-  if (!claimed) return;
+function writeMarker(input, registered, target, output, completedAt, claimed) {
   const synthetic = {
     ...input,
+    session_id: registered.parentSession,
     cwd: registered.root,
     tool_name: "Agent",
     tool_input: { subagent_type: role, prompt: "" },
@@ -163,14 +219,129 @@ function complete(input, target, output) {
     input: JSON.stringify(synthetic),
     encoding: "utf8",
   });
-  if (result.status === 0) {
-    renameSync(claimed.path, claimed.done);
+  if (result.status !== 0) {
+    rmSync(claimed.path, { force: true });
+    diagnostic("marker-writer-failed", input);
+    return false;
+  }
+  renameSync(claimed.path, claimed.done);
+  rmSync(statePath({ session_id: registered.parentSession }, target), { force: true });
+  rmSync(registrationPath(registered.parentSession, target), { force: true });
+  const assessedAt = new Date(completedAt);
+  for (const candidate of [
+    join(process.env.TMPDIR || "/tmp", `jtbd-reviewed-${registered.parentSession}`),
+    join(process.env.TMPDIR || "/tmp", `jtbd-plan-reviewed-${registered.parentSession}`),
+  ]) {
+    if (existsSync(candidate)) utimesSync(candidate, assessedAt, assessedAt);
+    if (existsSync(candidate + ".hash")) utimesSync(candidate + ".hash", assessedAt, assessedAt);
+  }
+  if (role === "wr-voice-tone:external-comms") {
+    const keys = [...output.matchAll(/^EXTERNAL_COMMS_VOICE_TONE_KEY:[ \t]*([a-f0-9]{64})$/gm)];
+    if (keys.length === 1) {
+      const keyed = join(stateDir(registered.parentSession), `external-comms-voice-tone-reviewed-${keys[0][1]}`);
+      if (existsSync(keyed)) utimesSync(keyed, assessedAt, assessedAt);
+    }
+  }
+  return true;
+}
+
+function complete(input, target, output) {
+  target = normalizeTarget(target);
+  if (!target || typeof output !== "string" || !output) return;
+  const path = statePath(input, target);
+  if (existsSync(statePath(input, target, ".done"))) return;
+  if (!existsSync(path)) {
+    diagnostic("missing-parent-registration", input);
+    return;
+  }
+
+  let registered, age;
+  try {
+    registered = JSON.parse(readFileSync(path, "utf8"));
+    age = Date.now() - Math.floor(statSync(path).mtimeMs);
+  }
+  catch {
+    diagnostic("malformed-registration", input);
+    return;
+  }
+  if (!validRegistration(registered, input, target, age)) {
     rmSync(path, { force: true });
+    rmSync(registrationPath(registered.parentSession || input.session_id, target), { force: true });
+    return;
+  }
+
+  const claimed = claim(input, target);
+  if (!claimed) return;
+  writeMarker(input, registered, target, output, Date.now(), claimed);
+}
+
+function registrations(input, target) {
+  reapTransport();
+  if (!existsSync(transportDir())) return [];
+  const current = checkout(input.cwd || process.cwd());
+  if (!current) return [];
+  return readdirSync(transportDir())
+    .filter((name) => /^registration-[a-f0-9]{64}\.json$/.test(name))
+    .flatMap((name) => {
+      const path = join(transportDir(), name);
+      try {
+        const registered = JSON.parse(readFileSync(path, "utf8"));
+        return registered.role === role && registered.target === target &&
+          registered.root === current.root && registered.physical === current.physical
+          ? [{ path, registered, age: Date.now() - Math.floor(statSync(path).mtimeMs) }]
+          : [];
+      } catch { return []; }
+    });
+}
+
+function persistPending(input, target, output) {
+  target = normalizeTarget(target);
+  if (!target || typeof output !== "string" || !output) return;
+  const candidates = registrations(input, target);
+  if (candidates.length !== 1) {
+    diagnostic(candidates.length ? "ambiguous-parent-registration" : "missing-parent-registration", input);
     return;
   }
-  rmSync(claimed.path, { force: true });
-  diagnostic("marker-writer-failed", input);
-  process.exitCode = 1;
+  const { registered, age } = candidates[0];
+  if (!validRegistration(registered, input, target, age)) return;
+  if (!outputAllowed(output, registered)) {
+    diagnostic("non-pass-or-mismatched-output", input);
+    return;
+  }
+  const path = receiptPath(registered.parentSession, target);
+  if (existsSync(path) || existsSync(path + ".done")) return;
+  try {
+    writeFileSync(path, JSON.stringify({ ...registered, output, completedAt: Date.now() }), { flag: "wx", mode: 0o600 });
+  } catch (error) {
+    if (error?.code !== "EEXIST") diagnostic("receipt-write-failed", input);
+  }
+}
+
+function consumePending(input) {
+  reapTransport();
+  if (!existsSync(transportDir())) return;
+  const prefix = `receipt-`;
+  for (const name of readdirSync(transportDir()).filter((entry) => entry.startsWith(prefix) && entry.endsWith(".json"))) {
+    const path = join(transportDir(), name);
+    let pending, age;
+    try {
+      pending = JSON.parse(readFileSync(path, "utf8"));
+      age = Date.now() - pending.completedAt;
+    } catch {
+      diagnostic("malformed-receipt", input);
+      continue;
+    }
+    if (pending.parentSession !== input.session_id || pending.role !== role) continue;
+    if (!validRegistration(pending, input, pending.target, age)) continue;
+    const claimPath = path + ".claim";
+    const donePath = path + ".done";
+    try { writeFileSync(claimPath, "", { flag: "wx", mode: 0o600 }); }
+    catch (error) { if (error?.code === "EEXIST") continue; throw error; }
+    const claimed = { path: claimPath, done: donePath };
+    if (writeMarker(input, pending, pending.target, pending.output, pending.completedAt, claimed)) {
+      rmSync(path, { force: true });
+    }
+  }
 }
 
 function close(input) {
@@ -194,10 +365,21 @@ if (!/^[0-9]+$/.test(ttlSeconds) || !Number.isSafeInteger(ttl) || ttl <= 0) {
   process.exit(0);
 }
 
-if (SPAWN_TOOLS.has(input.tool_name)) remember(input);
-if (CLOSE_TOOLS.has(input.tool_name)) close(input);
-if (WAIT_TOOLS.has(input.tool_name)) wait(input);
-if (input.hook_event_name === "SubagentStop") {
-  if (input.agent_type !== role) diagnostic("unrelated-subagent-stop", input);
-  else complete(input, input.task_name || input.agent_name || input.agent_id, input.last_assistant_message);
+try {
+  if (SPAWN_TOOLS.has(input.tool_name)) remember(input);
+  if (CLOSE_TOOLS.has(input.tool_name)) close(input);
+  if (WAIT_TOOLS.has(input.tool_name)) wait(input);
+  if (input.hook_event_name === "UserPromptSubmit" || input.hook_event_name === "PreToolUse" || ["Bash", "Edit", "Write", "ExitPlanMode"].includes(input.tool_name)) consumePending(input);
+  if (input.hook_event_name === "SubagentStop") {
+    if (input.agent_type !== role) diagnostic("unrelated-subagent-stop", input);
+    else {
+      const target = input.task_name || input.agent_name || input.agent_id;
+      const local = statePath(input, normalizeTarget(target));
+      if (existsSync(local)) complete(input, target, input.last_assistant_message);
+      else persistPending(input, target, input.last_assistant_message);
+    }
+  }
+} catch {
+  diagnostic("transport-error", input);
+  process.exitCode = 0;
 }

package/hooks-codex/hooks.json

@@ -27,9 +27,26 @@
             "command": "${PLUGIN_ROOT}/hooks/staleness-check.sh"
           }
         ]
+      },
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${PLUGIN_ROOT}/hooks-codex/codex-agent-completion.mjs\""
+          }
+        ]
       }
     ],
     "PreToolUse": [
+      {
+        "matcher": "Bash|Edit|Write|ExitPlanMode",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${PLUGIN_ROOT}/hooks-codex/codex-agent-completion.mjs\""
+          }
+        ]
+      },
       {
         "matcher": "Edit|Write",
         "hooks": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@windyroad/jtbd",
-  "version": "0.14.6",
+  "version": "0.14.7",
   "description": "Jobs-to-be-done enforcement for UI changes",
   "bin": {
     "windyroad-jtbd": "./bin/install.mjs"