@windyroad/voice-tone 0.8.4 → 0.8.5

package/.claude-plugin/plugin.json

@@ -123,5 +123,5 @@
     }
   },
   "name": "wr-voice-tone",
-  "version": "0.8.4"
+  "version": "0.8.5"
 }

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "wr-voice-tone",
-  "version": "0.8.4",
+  "version": "0.8.5",
   "description": "Voice, tone, and external-communications governance",
   "author": {
     "name": "Windy Road Technology",

package/hooks/external-comms-gate.sh

@@ -138,6 +138,24 @@ _gh_api_has_body() {
     printf '%s' "$1" | grep -qE '(^|[[:space:]])(--field|--raw-field|--input|-f|-F)([[:space:]]|=)'
 }
 
+# P537: return success only when at least one matched command segment can
+# publish. Every publish segment must opt into a true dry run before the
+# external-comms review can be skipped; mixed commands therefore fail closed.
+_npm_publish_has_real_invocation() {
+    local segment
+    while IFS= read -r segment; do
+        if printf '%s' "$segment" | grep -qE '^\s*npm publish(\s|$)'; then
+            if ! printf '%s' "$segment" | grep -qE '(^|[[:space:]])--dry-run(=true)?($|[[:space:]])' \
+                || printf '%s' "$segment" | grep -qE '(^|[[:space:]])(--dry-run=false|--no-dry-run)($|[[:space:]])'; then
+                return 0
+            fi
+        fi
+    done <<EOF
+$(printf '%s' "$1" | tr ';&|' '\n\n\n')
+EOF
+    return 1
+}
+
 # ---------- Surface detection ----------
 SURFACE=""
 DRAFT=""
@@ -180,7 +198,11 @@ except Exception:
                 exit 0
             fi
         elif echo "$COMMAND" | grep -qE '(^|;|&&|\|\|)\s*npm publish(\s|$)'; then
-            SURFACE="npm-publish"
+            if _npm_publish_has_real_invocation "$COMMAND"; then
+                SURFACE="npm-publish"
+            else
+                exit 0
+            fi
         elif echo "$COMMAND" | grep -qE '(^|;|&&|\|\|)\s*git commit(\s|$)'; then
             # P082 Phase 1: gate `git commit -m / --message / HEREDOC` so commit
             # message bodies are reviewed by the voice-tone + risk evaluators
@@ -431,7 +453,7 @@ fi
 # (sha256(DRAFT + '\n' + SURFACE)). Single fire per gate cycle.
 VERDICT_PREFIX="${EXTERNAL_COMMS_VERDICT_PREFIX:-EXTERNAL_COMMS_${EXTERNAL_COMMS_EVALUATOR_ID^^}}"
 if [ -n "${CODEX_THREAD_ID:-}" ]; then
-    COMPLETION_GUIDANCE='On Codex, wait for the reviewer to finish, then close that completed agent once before retrying; the PostToolUse compatibility hook consumes the completed close response and persists its structured verdict, with no transcript parsing or nested codex exec.'
+    COMPLETION_GUIDANCE='On Codex, the calling agent waits for the reviewer to finish, then invokes `interrupt_agent` once on that completed target before retrying; the PostToolUse compatibility hook consumes the completed response and persists its structured verdict, with no transcript parsing or nested codex exec.'
 else
     COMPLETION_GUIDANCE='On Claude Code, dispatch the reviewer SYNCHRONOUSLY (run_in_background: false): a background-launched reviewer does not fire its PostToolUse mark hook, so the marker never persists and this gate re-blocks (P402).'
 fi

package/hooks/hooks.json

@@ -81,6 +81,10 @@
           {
             "type": "command",
             "command": "node \"${PLUGIN_ROOT}/hooks-codex/codex-agent-completion.mjs\""
+          },
+          {
+            "type": "command",
+            "command": "node \"${PLUGIN_ROOT}/hooks-codex/codex-agent-completion-2.mjs\""
           }
         ]
       }
@@ -94,6 +98,15 @@
             "command": "node \"${PLUGIN_ROOT}/hooks-codex/codex-agent-completion.mjs\""
           }
         ]
+      },
+      {
+        "matcher": "^wr-voice-tone:external-comms$",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${PLUGIN_ROOT}/hooks-codex/codex-agent-completion-2.mjs\""
+          }
+        ]
       }
     ]
   }

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

@@ -0,0 +1,207 @@
+#!/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";
+
+const hookDir = dirname(fileURLToPath(import.meta.url));
+const role = "wr-voice-tone:external-comms";
+const writer = join(hookDir, "..", "hooks", "external-comms-mark-reviewed.sh");
+const policy = "docs/VOICE-AND-TONE.md";
+const ttlSeconds = process.env.REVIEW_TTL ?? "3600";
+const ttl = Number(ttlSeconds) * 1000;
+
+function response(input) {
+  if (typeof input.tool_response === "object" && input.tool_response) return input.tool_response;
+  try { return JSON.parse(input.tool_response); } catch { return {}; }
+}
+
+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 (["collaborationspawn_agent", "spawn_agent", "multi_agent_v1__spawn_agent"].includes(input.tool_name)) remember(input);
+if (["collaborationinterrupt_agent", "interrupt_agent", "close_agent", "multi_agent_v1__close_agent"].includes(input.tool_name)) close(input);
+if (["collaborationwait_agent", "wait_agent", "multi_agent_v1__wait_agent"].includes(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

@@ -81,6 +81,10 @@
           {
             "type": "command",
             "command": "node \"${PLUGIN_ROOT}/hooks-codex/codex-agent-completion.mjs\""
+          },
+          {
+            "type": "command",
+            "command": "node \"${PLUGIN_ROOT}/hooks-codex/codex-agent-completion-2.mjs\""
           }
         ]
       }
@@ -94,6 +98,15 @@
             "command": "node \"${PLUGIN_ROOT}/hooks-codex/codex-agent-completion.mjs\""
           }
         ]
+      },
+      {
+        "matcher": "^wr-voice-tone:external-comms$",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${PLUGIN_ROOT}/hooks-codex/codex-agent-completion-2.mjs\""
+          }
+        ]
       }
     ]
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@windyroad/voice-tone",
-  "version": "0.8.4",
+  "version": "0.8.5",
   "description": "Voice and tone enforcement for user-facing copy",
   "bin": {
     "windyroad-voice-tone": "./bin/install.mjs"

package/skills/assess-external-comms/SKILL.md

@@ -92,6 +92,11 @@ prompt: <constructed review prompt from step 3>
 
 Wait for the subagent to complete. The subagent outputs a structured verdict block (`EXTERNAL_COMMS_VOICE_TONE_VERDICT: PASS|FAIL` + optional `EXTERNAL_COMMS_VOICE_TONE_REASON: ...` on FAIL). The `PostToolUse:Agent` hook (`external-comms-mark-reviewed.sh`) parses the verdict, derives the marker key from the prompt's `SURFACE:` + `<draft>` structure, and writes the per-evaluator marker automatically on PASS.
 
+On Codex, use `agent_type: wr-voice-tone:external-comms` with
+`fork_turns: "none"`. After it reports completion, invoke `interrupt_agent`
+exactly once on that completed target so the compatibility hook can persist the
+structured verdict.
+
 **Do not write to `${TMPDIR:-/tmp}/claude-risk-*` yourself.** The hook is the only correct mechanism.
 
 ### 5. Present results