@windyroad/jtbd 0.14.3 → 0.14.4

package/.claude-plugin/plugin.json

@@ -90,5 +90,5 @@
     }
   },
   "name": "wr-jtbd",
-  "version": "0.14.3"
+  "version": "0.14.4"
 }

package/.codex-plugin/plugin.json

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

package/hooks/hooks.json

@@ -76,6 +76,26 @@
             "command": "bash \"${PLUGIN_ROOT}/hooks-codex/codex-adapter.sh\" \"${PLUGIN_ROOT}/hooks/jtbd-slide-marker.sh\""
           }
         ]
+      },
+      {
+        "matcher": "collaboration.spawn_agent|collaboration.wait_agent|collaboration.interrupt_agent|collaborationspawn_agent|collaborationwait_agent|collaborationinterrupt_agent|spawn_agent|wait_agent|interrupt_agent|close_agent|multi_agent_v1__spawn_agent|multi_agent_v1__wait_agent|multi_agent_v1__close_agent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${PLUGIN_ROOT}/hooks-codex/codex-agent-completion.mjs\""
+          }
+        ]
+      }
+    ],
+    "SubagentStop": [
+      {
+        "matcher": "^wr-jtbd:agent$",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${PLUGIN_ROOT}/hooks-codex/codex-agent-completion.mjs\""
+          }
+        ]
       }
     ]
   }

package/hooks/lib/codex-completion-input.mjs

@@ -0,0 +1,41 @@
+export const SPAWN_TOOLS = new Set([
+  "collaboration.spawn_agent",
+  "collaborationspawn_agent",
+  "spawn_agent",
+  "multi_agent_v1__spawn_agent",
+]);
+
+export const WAIT_TOOLS = new Set([
+  "collaboration.wait_agent",
+  "collaborationwait_agent",
+  "wait_agent",
+  "multi_agent_v1__wait_agent",
+]);
+
+export const CLOSE_TOOLS = new Set([
+  "collaboration.interrupt_agent",
+  "collaborationinterrupt_agent",
+  "interrupt_agent",
+  "close_agent",
+  "multi_agent_v1__close_agent",
+]);
+
+export function parsedResponse(value) {
+  if (Array.isArray(value)) {
+    const text = value
+      .filter((item) => item && typeof item === "object" && typeof item.text === "string")
+      .map((item) => item.text)
+      .join("\n");
+    return parsedResponse(text);
+  }
+  if (typeof value === "object" && value) return value;
+  try {
+    return parsedResponse(JSON.parse(value));
+  } catch {
+    return {};
+  }
+}
+
+export function response(input) {
+  return parsedResponse(input?.tool_response);
+}

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

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+
+import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { CLOSE_TOOLS, SPAWN_TOOLS, WAIT_TOOLS, response } from "../hooks/lib/codex-completion-input.mjs";
+
+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 ttlSeconds = process.env.REVIEW_TTL ?? "3600";
+const ttl = Number(ttlSeconds) * 1000;
+
+function stateDir(sessionId) {
+  return join(process.env.TMPDIR || "/tmp", `claude-risk-${sessionId}`);
+}
+
+function statePath(input, target, suffix = "") {
+  return join(stateDir(input.session_id), `codex-review-${Buffer.from(role + ":" + target).toString("base64url")}${suffix}`);
+}
+
+function normalizeTarget(target) {
+  if (typeof target !== "string") return "";
+  return target.startsWith("/root/") ? target.slice("/root/".length) : target;
+}
+
+function policyHash(root) {
+  const result = spawnSync("bash", ["-c", 'source "$1"; _substance_hash_path "$2"', "review-policy",
+    join(hookDir, "..", "hooks", "lib", "gate-helpers.sh"), policy], { cwd: root, encoding: "utf8" });
+  const hash = result.stdout?.trim();
+  return result.status === 0 && /^[a-f0-9]{64}$/.test(hash || "") ? hash : null;
+}
+
+function diagnostic(reason, input) {
+  const dir = process.env.TMPDIR || "/tmp";
+  const path = join(dir, "codex-review-completion-diagnostic.json");
+  const temporary = join(dir, `.codex-review-completion-diagnostic-${process.pid}.tmp`);
+  try {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(temporary, JSON.stringify({
+      timestamp: new Date().toISOString(),
+      reason,
+      event: input?.hook_event_name === "SubagentStop" ? "SubagentStop" : input?.tool_name || "unknown",
+      role,
+    }), { mode: 0o600 });
+    renameSync(temporary, path);
+  } catch {
+    rmSync(temporary, { force: true });
+  }
+}
+
+function checkout(cwd) {
+  if (typeof cwd !== "string" || !cwd) return null;
+  let root;
+  try { root = realpathSync(cwd); } catch { return null; }
+  const git = spawnSync("git", ["-C", root, "rev-parse", "--show-toplevel"], { encoding: "utf8" });
+  if (git.status !== 0) return null;
+  let gitRoot;
+  try { gitRoot = realpathSync(git.stdout.trim()); } catch { return null; }
+  if (gitRoot !== root) return null;
+  const stat = statSync(root);
+  return { root, physical: `${stat.dev}:${stat.ino}` };
+}
+
+function targetFromSpawn(input) {
+  const result = response(input);
+  return result.agent_id ?? result.task_name;
+}
+
+function clear(input, target) {
+  for (const suffix of ["", ".claim", ".done"]) rmSync(statePath(input, target, suffix), { force: true });
+}
+
+function remember(input) {
+  const target = normalizeTarget(targetFromSpawn(input));
+  if (!target) return;
+  mkdirSync(stateDir(input.session_id), { recursive: true });
+  clear(input, target);
+  if (input.tool_input?.agent_type !== role) return;
+  const bound = checkout(input.cwd || process.cwd());
+  if (!bound) {
+    diagnostic("invalid-spawn-checkout", input);
+    return;
+  }
+  const hash = policyHash(bound.root);
+  if (!hash) {
+    diagnostic("policy-hash-failed", input);
+    return;
+  }
+  writeFileSync(statePath(input, target), JSON.stringify({ role, target, ...bound, policyHash: hash }), { mode: 0o600 });
+}
+
+function claim(input, target) {
+  const path = statePath(input, target, ".claim");
+  const done = statePath(input, target, ".done");
+  if (existsSync(done)) return null;
+  try { writeFileSync(path, "", { flag: "wx", mode: 0o600 }); }
+  catch (error) {
+    if (error?.code === "EEXIST") return null;
+    throw error;
+  }
+  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;
+  }
+  if (registered.role !== role || registered.target !== target) {
+    diagnostic("registration-mismatch", input);
+    return;
+  }
+  if (!Number.isFinite(age) || age < 0) {
+    diagnostic("invalid-registration-age", input);
+    return;
+  }
+  if (age >= ttl) {
+    diagnostic("stale-registration", input);
+    return;
+  }
+
+  const current = checkout(input.cwd || process.cwd());
+  if (!current || current.root !== registered.root || current.physical !== registered.physical) {
+    diagnostic("checkout-mismatch", input);
+    return;
+  }
+
+  const hash = policyHash(registered.root);
+  if (!hash || hash !== registered.policyHash) {
+    diagnostic(hash ? "policy-changed" : "policy-hash-failed", input);
+    return;
+  }
+
+  const claimed = claim(input, target);
+  if (!claimed) return;
+  const synthetic = {
+    ...input,
+    cwd: registered.root,
+    tool_name: "Agent",
+    tool_input: { subagent_type: role, prompt: "" },
+    tool_response: { content: [{ type: "text", text: output }] },
+  };
+  const result = spawnSync(writer, {
+    cwd: registered.root,
+    env: process.env,
+    input: JSON.stringify(synthetic),
+    encoding: "utf8",
+  });
+  if (result.status === 0) {
+    renameSync(claimed.path, claimed.done);
+    rmSync(path, { force: true });
+    return;
+  }
+  rmSync(claimed.path, { force: true });
+  diagnostic("marker-writer-failed", input);
+  process.exitCode = 1;
+}
+
+function close(input) {
+  complete(input, input.tool_input?.target, response(input).previous_status?.completed);
+}
+
+function wait(input) {
+  const statuses = response(input).status;
+  if (!statuses || typeof statuses !== "object") return;
+  for (const [target, status] of Object.entries(statuses)) complete(input, target, status?.completed);
+}
+
+let body = "";
+process.stdin.setEncoding("utf8");
+for await (const chunk of process.stdin) body += chunk;
+let input;
+try { input = JSON.parse(body); } catch { process.exit(0); }
+if (!/^[A-Za-z0-9-]+$/.test(input.session_id || "")) process.exit(0);
+if (!/^[0-9]+$/.test(ttlSeconds) || !Number.isSafeInteger(ttl) || ttl <= 0) {
+  diagnostic("invalid-review-ttl", input);
+  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.agent_id, input.last_assistant_message);
+}

package/hooks-codex/hooks.json

@@ -76,6 +76,26 @@
             "command": "bash \"${PLUGIN_ROOT}/hooks-codex/codex-adapter.sh\" \"${PLUGIN_ROOT}/hooks/jtbd-slide-marker.sh\""
           }
         ]
+      },
+      {
+        "matcher": "collaboration.spawn_agent|collaboration.wait_agent|collaboration.interrupt_agent|collaborationspawn_agent|collaborationwait_agent|collaborationinterrupt_agent|spawn_agent|wait_agent|interrupt_agent|close_agent|multi_agent_v1__spawn_agent|multi_agent_v1__wait_agent|multi_agent_v1__close_agent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${PLUGIN_ROOT}/hooks-codex/codex-agent-completion.mjs\""
+          }
+        ]
+      }
+    ],
+    "SubagentStop": [
+      {
+        "matcher": "^wr-jtbd:agent$",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${PLUGIN_ROOT}/hooks-codex/codex-agent-completion.mjs\""
+          }
+        ]
       }
     ]
   }

package/package.json

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