@windyroad/risk-scorer 0.18.10 → 0.18.11

package/.claude-plugin/plugin.json

@@ -310,5 +310,5 @@
     }
   },
   "name": "wr-risk-scorer",
-  "version": "0.18.10"
+  "version": "0.18.11"
 }

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "wr-risk-scorer",
-  "version": "0.18.10",
+  "version": "0.18.11",
   "description": "Pipeline risk scoring, commit/push gates, and secret leak detection",
   "author": {
     "name": "Windy Road Technology",

package/hooks/codex-agent-completion.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
-import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, 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, isAbsolute, join } from "node:path";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
@@ -28,6 +29,10 @@ function riskDir(sessionId) {
   return join(process.env.TMPDIR || "/tmp", `claude-risk-${sessionId}`);
 }
 
+function pendingDir() {
+  return join(process.env.TMPDIR || "/tmp", "claude-risk-pending");
+}
+
 function statePath(input, target, suffix = "") {
   return join(riskDir(input.session_id), `codex-agent-${Buffer.from(target).toString("base64url")}${suffix}`);
 }
@@ -98,6 +103,63 @@ function pipelineAssessment(output) {
   return { root, output: sanitized };
 }
 
+function checkoutId(root) {
+  const stat = statSync(root);
+  return createHash("sha256").update(`${stat.dev}:${stat.ino}`).digest("hex");
+}
+
+function stateHash(root) {
+  const state = spawnSync(join(hookDir, "lib/pipeline-state.sh"), ["--hash-inputs"], {
+    cwd: root,
+    encoding: "utf8",
+  });
+  if (state.status !== 0) return null;
+  return createHash("md5").update(state.stdout).digest("hex");
+}
+
+function completionId(input, output) {
+  if (typeof input.session_id !== "string" || typeof input.agent_id !== "string") return null;
+  return createHash("sha256").update(`${input.session_id}\0${input.agent_id}\0${output}`).digest("hex");
+}
+
+function pendingPath(id, hash, completion, suffix = "") {
+  return join(pendingDir(), `${id}-${hash}-${completion}${suffix}`);
+}
+
+function freshReceipt(path) {
+  if (!existsSync(path)) return false;
+  const ttl = Number.parseInt(process.env.RISK_TTL || "3600", 10) * 1000;
+  return Date.now() - statSync(path).mtimeMs < ttl;
+}
+
+function persistPendingPipeline(input) {
+  if (input.agent_type !== "wr-risk-scorer:pipeline") return;
+  const assessment = pipelineAssessment(input.last_assistant_message);
+  if (!assessment) return;
+  const id = checkoutId(assessment.root);
+  const hash = stateHash(assessment.root);
+  const completion = completionId(input, assessment.output);
+  if (!hash || !completion || !/^RISK_SCORES: commit=\d+ push=\d+ release=\d+$/m.test(assessment.output)) return;
+  mkdirSync(pendingDir(), { recursive: true });
+  const path = pendingPath(id, hash, completion);
+  for (const candidate of [path, `${path}.done`]) {
+    if (freshReceipt(candidate)) return;
+    rmSync(candidate, { force: true });
+  }
+  try {
+    writeFileSync(path, JSON.stringify({
+      role: input.agent_type,
+      output: assessment.output,
+      checkoutId: id,
+      stateHash: hash,
+      completionId: completion,
+      createdAt: Date.now(),
+    }), { flag: "wx", mode: 0o600 });
+  } catch (error) {
+    if (error?.code !== "EEXIST") throw error;
+  }
+}
+
 function markTarget(input, target, output) {
   if (typeof target !== "string" || typeof output !== "string" || !output) return;
 
@@ -152,7 +214,88 @@ function markWait(input) {
 }
 
 function markSubagentStop(input) {
-  markTarget(input, input.agent_id, input.last_assistant_message);
+  const state = typeof input.agent_id === "string" ? statePath(input, input.agent_id) : "";
+  if (state && existsSync(state)) {
+    markTarget(input, input.agent_id, input.last_assistant_message);
+    return;
+  }
+  persistPendingPipeline(input);
+}
+
+function consumePending(input) {
+  if (!/^[A-Za-z0-9-]+$/.test(input.session_id || "")) return;
+  let root;
+  try {
+    root = realpathSync(process.cwd());
+  } catch {
+    return;
+  }
+  const git = spawnSync("git", ["-C", root, "rev-parse", "--show-toplevel"], { encoding: "utf8" });
+  if (git.status !== 0 || realpathSync(git.stdout.trim()) !== root) return;
+
+  const id = checkoutId(root);
+  const hash = stateHash(root);
+  if (!hash) return;
+  const prefix = `${id}-${hash}-`;
+  const pendingPaths = existsSync(pendingDir())
+    ? readdirSync(pendingDir())
+      .filter((name) => name.startsWith(prefix) && !name.endsWith(".claim") && !name.endsWith(".done"))
+      .map((name) => join(pendingDir(), name))
+      .sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs)
+    : [];
+  const path = pendingPaths[0];
+  if (!path) return;
+
+  const claim = `${path}.claim`;
+  try {
+    writeFileSync(claim, "", { flag: "wx", mode: 0o600 });
+  } catch (error) {
+    if (error?.code === "EEXIST") return;
+    throw error;
+  }
+
+  try {
+    const pending = JSON.parse(readFileSync(path, "utf8"));
+    const ttl = Number.parseInt(process.env.RISK_TTL || "3600", 10) * 1000;
+    if (pending.role !== "wr-risk-scorer:pipeline" || pending.checkoutId !== id ||
+        pending.stateHash !== hash || typeof pending.output !== "string" ||
+        typeof pending.completionId !== "string" || !path.endsWith(`-${pending.completionId}`) ||
+        !Number.isFinite(pending.createdAt) || Date.now() - pending.createdAt < 0 ||
+        Date.now() - pending.createdAt >= ttl) return;
+
+    const synthetic = {
+      ...input,
+      cwd: root,
+      tool_name: "Agent",
+      tool_input: { subagent_type: pending.role, prompt: "" },
+      tool_response: { content: [{ type: "text", text: pending.output }] },
+    };
+    const result = spawnSync(join(hookDir, "risk-score-mark.sh"), {
+      cwd: root,
+      env: process.env,
+      input: JSON.stringify(synthetic),
+      encoding: "utf8",
+    });
+    if (result.status !== 0) {
+      process.exitCode = 1;
+      return;
+    }
+    const assessedAt = new Date(pending.createdAt);
+    const markers = ["commit", "push", "release", "commit-born", "push-born", "release-born"];
+    if (/^RISK_BYPASS:\s*reducing\s*$/m.test(pending.output)) {
+      markers.push("reducing-commit", "reducing-push", "reducing-release");
+    } else if (/^RISK_BYPASS:\s*incident\s*$/m.test(pending.output)) {
+      markers.push("incident-release");
+    }
+    for (const marker of markers) {
+      const markerPath = join(riskDir(input.session_id), marker);
+      if (existsSync(markerPath)) utimesSync(markerPath, assessedAt, assessedAt);
+    }
+    renameSync(path, `${path}.done`);
+    for (const stale of pendingPaths.slice(1)) rmSync(stale, { force: true });
+  } finally {
+    rmSync(claim, { force: true });
+  }
 }
 
 let body = "";
@@ -166,6 +309,11 @@ try {
   process.exit(0);
 }
 
+if (process.argv.includes("--consume-pending")) {
+  consumePending(input);
+  process.exit(process.exitCode || 0);
+}
+
 if (!/^[A-Za-z0-9-]+$/.test(input.session_id || "")) process.exit(0);
 
 if (["collaborationspawn_agent", "spawn_agent", "multi_agent_v1__spawn_agent"].includes(input.tool_name)) {

package/hooks/risk-pending-receipt.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+# Consume a checkout-bound Codex SubagentStop receipt in the parent session.
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+source "$SCRIPT_DIR/lib/gate-helpers.sh"
+_parse_input
+
+TOOL_NAME="$(_get_tool_name)"
+EVENT_NAME="$(printf '%s' "$_HOOK_INPUT" | python3 -c 'import json,sys; print(json.load(sys.stdin).get("hook_event_name", ""))' 2>/dev/null || true)"
+[ "$TOOL_NAME" = "Bash" ] || [ "$EVENT_NAME" = "UserPromptSubmit" ] || exit 0
+_enter_hook_cwd || exit 0
+printf '%s' "$_HOOK_INPUT" | node "$SCRIPT_DIR/codex-agent-completion.mjs" --consume-pending

package/hooks/risk-scorer-dispatch.sh

@@ -47,6 +47,9 @@ if messages:
     fi
     ;;
   user-prompt)
+    # Codex code-mode tools do not expose a parent PreToolUse event. Import a
+    # completed child receipt on the next already-enabled parent prompt.
+    "$SCRIPT_DIR/risk-pending-receipt.sh" <<<"$INPUT" || true
     run_hook risk-score.sh
     run_hook staleness-check.sh
     ;;
@@ -59,6 +62,10 @@ if messages:
         run_hook risk-policy-enforce-edit.sh
         ;;
       Bash)
+        # Current Codex emits SubagentStop in the child conversation but does
+        # not expose native collaboration calls to the parent's PostToolUse.
+        # Import the exact checkout/hash-bound receipt before enforcing gates.
+        "$SCRIPT_DIR/risk-pending-receipt.sh" <<<"$INPUT" || true
         run_hook git-push-gate.sh
         run_hook risk-score-commit-gate.sh
         run_hook external-comms-gate.sh

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@windyroad/risk-scorer",
-  "version": "0.18.10",
+  "version": "0.18.11",
   "description": "Pipeline risk scoring, commit/push gates, and secret leak detection",
   "scripts": {
     "prepack": "node scripts/sync-codex-skills.mjs --pack",