blun-king-cli 9.1.567 → 9.1.570

package/agent-spine-plugin/hooks/hooks.json

@@ -37,7 +37,7 @@
     ],
     "PreToolUse": [
       {
-        "matcher": "Edit|Write|apply_patch|Bash",
+        "matcher": "^(?:Edit|Write|apply_patch|Bash|PowerShell|mcp__plugin_agent-spine_agent-spine__session_timeline_(?:index|search))$",
         "hooks": [
           {
             "type": "command",

package/agent-spine-plugin/hooks/version.json

@@ -1,5 +1,5 @@
 {
   "schema": "agentspine.hook-bundle/v1",
-  "version": "0.59.1",
+  "version": "0.73.0",
   "contract": "agentspine.preflight/v2"
 }

package/agent-spine-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-spine",
-  "version": "0.59.1",
+  "version": "0.73.0",
   "description": "A non-destructive identity and memory spine for AI agents.",
   "type": "module",
   "bin": {
@@ -18,10 +18,19 @@
     ".mcp.json",
     "assets",
     "bin",
-    "docs",
+    "docs/acceptance.md",
+    "docs/assignment-continuation.md",
+    "docs/host-integration.md",
+    "docs/preflight-recall.md",
+    "docs/preservation-contract.md",
+    "docs/quality-gates.md",
+    "docs/releasing.md",
+    "docs/session-timeline.md",
+    "docs/source-roots.md",
+    "docs/structured-completion.md",
+    "docs/world-model.md",
     "hooks",
     "scripts",
-    "skill",
     "skills",
     "spine-example",
     "src",
@@ -36,6 +45,7 @@
     "host:check": "node scripts/check-hosts.js --json",
     "host:install-check": "node scripts/check-install.js --json",
     "lint": "node scripts/check-syntax.js",
+    "line-budget": "node scripts/check-line-budget.js",
     "release:check": "node scripts/release-check.js --json",
     "release:sbom": "npm sbom --sbom-format cyclonedx",
     "smoke": "node bin/agentspine.js doctor --json",

package/agent-spine-plugin/scripts/check-codex-install.js

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+import { spawn, spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { installCodexMcp, stripManagedCodexBlock } from "../src/lib/codex-installation.js";
+import { VERSION } from "../src/version.js";
+
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+function copyFilter(source) {
+  const name = basename(source);
+  return !new Set([".git", "node_modules"]).has(name) && !name.endsWith(".tgz");
+}
+
+function toolValue(response) {
+  const text = response.result?.content?.[0]?.text;
+  return text ? JSON.parse(text) : null;
+}
+
+async function invokeLauncher(launcher, cwd, env, requests, timeoutMs = 10000) {
+  return new Promise((resolveResult, reject) => {
+    const child = spawn(process.execPath, [launcher], {
+      cwd, env: { ...process.env, ...env }, stdio: ["pipe", "pipe", "pipe"]
+    });
+    const expected = new Set(requests.map((request) => request.id));
+    const responses = new Map();
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let complete = false;
+    const finish = (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (error) child.kill();
+      if (error) reject(error);
+      else resolveResult(responses);
+    };
+    const timer = setTimeout(() => finish(new Error(`Codex launcher probe timed out${stderr ? `: ${stderr}` : ""}`)), timeoutMs);
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => { stderr += chunk; });
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+      let newline;
+      while ((newline = stdout.indexOf("\n")) >= 0) {
+        const line = stdout.slice(0, newline).trim();
+        stdout = stdout.slice(newline + 1);
+        if (!line) continue;
+        let response;
+        try { response = JSON.parse(line); } catch (error) { return finish(error); }
+        if (expected.has(response.id)) responses.set(response.id, response);
+        if (responses.size === expected.size && !complete) {
+          complete = true;
+          child.stdin.end();
+        }
+      }
+    });
+    child.on("error", finish);
+    child.on("close", (code) => {
+      if (!settled) finish(complete ? null
+        : new Error(`Codex launcher exited with ${code}${stderr ? `: ${stderr}` : ""}`));
+    });
+    for (const request of requests) child.stdin.write(`${JSON.stringify(request)}\n`);
+  });
+}
+
+function hookRequirement(packageRoot, projectRoot, stateRoot) {
+  const input = {
+    host: "codex", cwd: projectRoot, session_id: "session:synthetic-codex-install",
+    hook_event_name: "UserPromptSubmit", event_id: "prompt:synthetic-codex-install",
+    prompt: "Continue the synthetic installed delivery.",
+    agent_spine_scope: { project_id: "project:synthetic-codex-install" }
+  };
+  const result = spawnSync(process.execPath, [join(packageRoot, "src", "hook.js")], {
+    cwd: projectRoot, env: { ...process.env, AGENTSPINE_STATE_DIR: stateRoot },
+    encoding: "utf8", input: JSON.stringify(input)
+  });
+  if (result.status !== 0) throw new Error(`installed Codex hook failed: ${result.stderr}`);
+  const context = JSON.parse(JSON.parse(result.stdout).hookSpecificOutput.additionalContext);
+  const requirementId = context.preflight?.premortem?.requirementId;
+  if (!requirementId) throw new Error("installed Codex hook did not issue a delivery requirement");
+  return requirementId;
+}
+
+async function oldPackage(root, target) {
+  await cp(root, target, { recursive: true, filter: copyFilter });
+  const pkgPath = join(target, "package.json");
+  const pkg = JSON.parse(await readFile(pkgPath, "utf8"));
+  pkg.version = "0.72.5";
+  await writeFile(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`, "utf8");
+  await writeFile(join(target, "src", "version.js"), 'export const VERSION = "0.72.5";\n', "utf8");
+}
+
+export async function checkCodexInstall(root, workspace) {
+  root = resolve(root);
+  const codexHome = join(workspace, "codex-home");
+  const skillsRoot = join(workspace, "user-home", ".agents", "skills");
+  const projectRoot = join(workspace, "project");
+  const stateRoot = join(workspace, "state");
+  const previousRoot = join(workspace, "cache-0.72.5");
+  await Promise.all([
+    mkdir(codexHome, { recursive: true }), mkdir(join(projectRoot, ".git"), { recursive: true }),
+    mkdir(stateRoot, { recursive: true }), oldPackage(root, previousRoot)
+  ]);
+  const foreignConfig = [
+    'model = "gpt-synthetic"',
+    "[mcp_servers.foreign]",
+    'command = "foreign-server"',
+    'args = ["--keep-byte-exact"]',
+    ""
+  ].join("\r\n");
+  const source = "# Synthetic Codex project\n\nKeep this source byte-exact.\n";
+  const unknown = '{"schema":"external.unknown-event/v99","decision":"not-authority"}\n';
+  const configPath = join(codexHome, "config.toml");
+  const sourcePath = join(projectRoot, "AGENTS.md");
+  const unknownPath = join(stateRoot, "external-event.json");
+  await Promise.all([
+    writeFile(configPath, foreignConfig, "utf8"),
+    writeFile(sourcePath, source, "utf8"),
+    writeFile(unknownPath, unknown, "utf8")
+  ]);
+  const initial = await installCodexMcp({ codexHome, skillsRoot, packageRoot: previousRoot });
+  const requirementId = hookRequirement(previousRoot, projectRoot, stateRoot);
+  const oldResponses = await invokeLauncher(initial.launcherPath, projectRoot, {
+    AGENTSPINE_STATE_DIR: stateRoot, PLUGIN_ROOT: join(workspace, "wrong-plugin-root")
+  }, [
+    { jsonrpc: "2.0", id: 1, method: "initialize", params: { protocolVersion: "2025-06-18" } },
+    { jsonrpc: "2.0", id: 2, method: "tools/list", params: {} },
+    { jsonrpc: "2.0", id: 3, method: "tools/call", params: { name: "session_briefing",
+      arguments: { root: projectRoot, cwd: projectRoot, host: "codex", maxBytes: 4096,
+        includeSourceContent: false } } }
+  ]);
+  if (oldResponses.get(1)?.result?.serverInfo?.version !== "0.72.5"
+    || (oldResponses.get(2)?.result?.tools || []).length < 3 || oldResponses.get(3)?.result?.isError) {
+    throw new Error("pre-update Codex process did not load the registered reader");
+  }
+
+  const updated = await installCodexMcp({ codexHome, skillsRoot, packageRoot: root });
+  await rm(previousRoot, { recursive: true, force: true });
+  const requests = [
+    { jsonrpc: "2.0", id: 10, method: "initialize", params: { protocolVersion: "2025-06-18" } },
+    { jsonrpc: "2.0", id: 11, method: "tools/list", params: {} },
+    { jsonrpc: "2.0", id: 12, method: "tools/call", params: { name: "read_document",
+      arguments: { root: projectRoot, host: "codex", path: "AGENTS.md", offset: 0, length: 4096 } } },
+    { jsonrpc: "2.0", id: 13, method: "tools/call", params: { name: "session_briefing",
+      arguments: { root: projectRoot, cwd: projectRoot, host: "codex", projectId: "project:synthetic-codex-install",
+        requirementId, maxBytes: 4096, includeSourceContent: false } } },
+    { jsonrpc: "2.0", id: 14, method: "tools/call", params: { name: "delivery_knowledge_query",
+      arguments: { root: projectRoot, requirementId, targetPaths: ["artifact.txt"], contractPaths: ["AGENTS.md"],
+        recentErrorTerms: ["stale reader", "missing registration"], maxBytes: 8192 } } },
+    { jsonrpc: "2.0", id: 15, method: "tools/call", params: { name: "record_delivery_premortem",
+      arguments: { root: projectRoot, requirementId, items: [
+        { category: "baseline-environment", failure: "this delivery fails because the installed reader is stale", check: "Check the loaded reader version." },
+        { category: "contract-tests", failure: "this delivery fails because required tools are missing", check: "List and call the required tools." },
+        { category: "delivery-path", failure: "this delivery fails because configuration bytes changed", check: "Hash unmanaged configuration and sources." }
+      ] } } }
+  ];
+  const responses = await invokeLauncher(updated.launcherPath, projectRoot, {
+    AGENTSPINE_STATE_DIR: stateRoot, PLUGIN_ROOT: join(workspace, "wrong-plugin-root")
+  }, requests);
+  const toolNames = new Set((responses.get(11)?.result?.tools || []).map((tool) => tool.name));
+  const read = toolValue(responses.get(12));
+  const briefing = toolValue(responses.get(13));
+  const knowledge = toolValue(responses.get(14));
+  const premortem = toolValue(responses.get(15));
+  for (const name of ["session_briefing", "delivery_knowledge_query", "record_delivery_premortem"]) {
+    if (!toolNames.has(name)) throw new Error(`updated Codex reader is missing ${name}`);
+  }
+  if (responses.get(10)?.result?.serverInfo?.version !== VERSION || read?.content !== source
+    || briefing?.deliveryUseReceipt?.blocked || knowledge?.deliveryUseReceipt?.blocked
+    || premortem?.blocked || premortem?.status !== "recorded") {
+    throw new Error("updated Codex reader did not preserve the existing session and required calls");
+  }
+  const config = await readFile(configPath, "utf8");
+  const installedSkill = await readFile(updated.skill.skillPath);
+  const sourceSkill = await readFile(join(root, "skills", "agent-spine", "SKILL.md"));
+  if (stripManagedCodexBlock(config) !== foreignConfig
+    || (config.match(/^\[mcp_servers\.agent-spine\]$/gm) || []).length !== 1
+    || !installedSkill.equals(sourceSkill)
+    || await readFile(sourcePath, "utf8") !== source || await readFile(unknownPath, "utf8") !== unknown) {
+    throw new Error("Codex installation changed foreign configuration, source bytes, or unknown state");
+  }
+  return {
+    ok: true,
+    version: VERSION,
+    oldVersion: "0.72.5",
+    configuredOnce: true,
+    foreignConfigDigest: sha256(foreignConfig),
+    unmanagedConfigDigest: updated.unmanagedAfterDigest,
+    sourceDigest: sha256(source),
+    unknownStateDigest: sha256(unknown),
+    tools: [...toolNames].filter((name) => REQUIRED_TOOL_NAMES.has(name)).sort(),
+    existingSessionReadable: true,
+    boundRequiredCalls: true,
+    nativeSkillInstalled: true,
+    wrongPluginRootIgnored: true,
+    authority: "installation-check-only"
+  };
+}
+
+const REQUIRED_TOOL_NAMES = new Set([
+  "session_briefing", "delivery_knowledge_query", "record_delivery_premortem", "read_document"
+]);
+
+async function main() {
+  const root = resolve(process.argv[2] || process.cwd());
+  const workspace = resolve(process.argv[3] || join(root, ".synthetic-codex-install"));
+  await mkdir(workspace, { recursive: true });
+  try {
+    process.stdout.write(`${JSON.stringify(await checkCodexInstall(root, workspace), null, 2)}\n`);
+  } finally {
+    if (!process.argv[3]) await rm(workspace, { recursive: true, force: true });
+  }
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === resolve(fileURLToPath(import.meta.url))) {
+  main().catch((error) => {
+    process.stderr.write(`AgentSpine Codex install check failed: ${error.message}\n`);
+    process.exitCode = 1;
+  });
+}

package/agent-spine-plugin/scripts/check-hosts.js

@@ -3,6 +3,10 @@ import { spawn } from "node:child_process";
 import { readFile, stat } from "node:fs/promises";
 import { isAbsolute, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { installedHostEnvironment } from "./check-install-hook.js";
+
+const TIMELINE_PRE_TOOL_MATCHER = "^(?:Edit|Write|apply_patch|Bash|PowerShell|mcp__plugin_agent-spine_agent-spine__session_timeline_(?:index|search))$";
+const BLUN_TIMELINE_PRE_TOOL_MATCHER = "^(?:Edit|Write|apply_patch|Bash|PowerShell|exec_command|mcp__(?:agent-spine|plugin-agent-spine_agent-spine)__session_timeline_(?:index|search))$";
 
 function assert(condition, message) {
   if (!condition) throw new Error(message);
@@ -25,7 +29,7 @@ async function validateEntrypoint(root, value) {
   assert(metadata.isFile(), "MCP entrypoint must be a regular file");
 }
 
-function validateHooks(root, hooks, { required, commandRoot }) {
+function validateHooks(root, hooks, { required, commandRoot, matcher = TIMELINE_PRE_TOOL_MATCHER }) {
   assert(hooks && typeof hooks === "object" && !Array.isArray(hooks), "hook bundle is missing");
   assert(Object.keys(hooks).every((key) => ["description", "hooks"].includes(key)), "hook bundle contains unsupported top-level metadata");
   assert(hooks.description && typeof hooks.description === "string", "hook bundle description is missing");
@@ -39,6 +43,8 @@ function validateHooks(root, hooks, { required, commandRoot }) {
       ? " --silent-oversize-post-tool-use" : ""}`;
     assert(command.command === expected, `${event} must use the bundled lifecycle adapter`);
     assert(Number.isInteger(command.timeout) && command.timeout > 0 && command.timeout <= 15, `${event} timeout is unsafe`);
+    if (event === "PreToolUse") assert(registrations[0].matcher === matcher,
+      "PreToolUse must route only exact mutations and timeline MCP calls through one guard");
   }
   const extras = Object.keys(hooks.hooks || {}).filter((event) => !required.includes(event));
   assert(extras.length === 0, `unknown hook events: ${extras.join(", ")}`);
@@ -62,6 +68,8 @@ function validateBlunHooks(root, hooks) {
       ? " --silent-oversize-post-tool-use" : ""}`;
     assert(command.command === expected, `${event} must use the bundled BLUN lifecycle adapter`);
     assert(Number.isInteger(command.timeout) && command.timeout > 0 && command.timeout <= 15, `${event} BLUN timeout is unsafe`);
+    if (event === "PreToolUse") assert(command.matcher === BLUN_TIMELINE_PRE_TOOL_MATCHER,
+      "BLUN PreToolUse must route only exact mutations and timeline MCP calls through one guard");
   }
   return { events: required, commands: required.length, entrypoint: relative(root, resolve(root, "src/hook.js")) };
 }
@@ -81,7 +89,7 @@ async function initializeServer({ label, root, variable, server, version }) {
   return await new Promise((resolveResult, reject) => {
     const child = spawn(command, args, {
       cwd: root,
-      env: { ...process.env, CLAUDE_PLUGIN_ROOT: root, PLUGIN_ROOT: root },
+      env: installedHostEnvironment(label, root),
       stdio: ["pipe", "pipe", "pipe"]
     });
     let stdout = "";
@@ -152,14 +160,15 @@ export async function checkHosts(root = process.cwd()) {
   await validateEntrypoint(root, resolve(root, pkg.bin["agentspine-worker"]));
   assert(claudeManifest.mcpServers === "./.mcp.json", "Claude manifest must explicitly reference ./.mcp.json");
   assert(claudeManifest.hooks === undefined, "default hooks/hooks.json must not also be registered through a supplemental manifest path");
-  assert(codexManifest.hooks === undefined, "Codex manifest must omit unsupported hook registration fields");
+  assert(codexManifest.hooks === "./hooks/codex.json", "Codex manifest must select its host-specific hook adapter");
   assert(claudeMcp.mcpServers && Object.keys(claudeMcp.mcpServers).length === 1, "Claude MCP file must contain one mcpServers registration");
   assert(codexManifest.mcpServers && Object.keys(codexManifest.mcpServers).length === 1, "Codex manifest must contain one MCP registration");
   const commonEvents = ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "PreCompact", "PostCompact", "Stop", "SubagentStop"];
   const claudeHookInventory = validateHooks(root, claudeHooks, {
     required: [...commonEvents, "InstructionsLoaded"], commandRoot: "CLAUDE_PLUGIN_ROOT"
   });
-  const codexHookInventory = validateHooks(root, codexHooks, { required: commonEvents, commandRoot: "PLUGIN_ROOT" });
+  const codexHookInventory = validateHooks(root, codexHooks, { required: commonEvents, commandRoot: "PLUGIN_ROOT",
+    matcher: "^(?:Edit|Write|apply_patch|Bash|PowerShell|mcp__(?:plugin_agent-spine_agent-spine|agent-spine)__session_timeline_(?:index|search))$" });
   const blunHookInventory = validateBlunHooks(root, blunManifest.hooks);
   const registrations = await Promise.all([
     initializeServer({ label: "blun", root, variable: "BLUN_PLUGIN_ROOT", server: blunManifest.mcpServers["agent-spine"], version: pkg.version }),
@@ -170,7 +179,7 @@ export async function checkHosts(root = process.cwd()) {
     ok: true, root, version: pkg.version, registrations,
     hooks: { blun: blunHookInventory, claude: claudeHookInventory, codex: codexHookInventory },
     hookDiscovery: {
-      blun: "plugin-manifest", claude: "default-hooks-directory", codex: "bundled-host-adapter",
+      blun: "plugin-manifest", claude: "default-hooks-directory", codex: "plugin-manifest",
       trust: "host-user-required", liveTrustVerified: false
     },
     worker: { entrypoint: pkg.bin["agentspine-worker"], setsPerInstall: 1 },

package/agent-spine-plugin/scripts/check-install-hook.js

@@ -0,0 +1,226 @@
+import { spawn } from "node:child_process";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+const HOST_ROOTS = {
+  blun: ["BLUN_PLUGIN_ROOT"],
+  claude: ["CLAUDE_PLUGIN_ROOT"],
+  codex: ["PLUGIN_ROOT", "CLAUDE_PLUGIN_ROOT"]
+};
+const HOST_ROOT_KEYS = ["BLUN_PLUGIN_ROOT", "CLAUDE_PLUGIN_ROOT", "PLUGIN_ROOT"];
+
+export function installedHostEnvironment(host, pluginRoot, extraEnv = {}) {
+  const rootKeys = HOST_ROOTS[host];
+  if (!rootKeys) throw new Error(`unsupported installed host: ${host}`);
+  const env = { ...process.env, ...extraEnv };
+  for (const key of HOST_ROOT_KEYS) delete env[key];
+  for (const key of rootKeys) env[key] = pluginRoot;
+  return env;
+}
+
+function parseProtocol(stdout, host) {
+  try {
+    return JSON.parse(stdout.trim());
+  } catch (error) {
+    throw new Error(`${host} installed hook returned invalid protocol JSON: ${stdout.slice(0, 2048)}`, { cause: error });
+  }
+}
+
+function parseContext(protocol, host, requireBriefing) {
+  const raw = protocol.hookSpecificOutput?.additionalContext;
+  if (typeof raw !== "string" || !raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    if (!requireBriefing) return null;
+    throw new Error(`${host} installed hook returned invalid briefing context JSON`, { cause: error });
+  }
+}
+
+function protocolShape(protocol) {
+  const specific = protocol.hookSpecificOutput;
+  return {
+    protocolKeys: Object.keys(protocol).sort(),
+    hookSpecificKeys: specific && typeof specific === "object" ? Object.keys(specific).sort() : [],
+    permissionDecision: specific?.permissionDecision || null,
+    permissionDecisionReason: specific?.permissionDecisionReason || null
+  };
+}
+
+export async function invokeInstalledHook(pluginRoot, projectRoot, stateRoot, host, payload = null,
+  { requireBriefing = true, extraEnv = {} } = {}) {
+  return await new Promise((resolveResult, reject) => {
+    const child = spawn(process.execPath, [join(pluginRoot, "src/hook.js")], {
+      cwd: projectRoot,
+      env: installedHostEnvironment(host, pluginRoot, {
+        AGENTSPINE_HOST: host,
+        AGENTSPINE_STATE_DIR: stateRoot,
+        ...extraEnv
+      }),
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    const timer = setTimeout(() => {
+      child.kill();
+      reject(new Error(`${host} installed hook timed out`));
+    }, 5000);
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => { stdout += chunk; });
+    child.stderr.on("data", (chunk) => { stderr += chunk; });
+    child.once("error", reject);
+    child.once("exit", (code) => {
+      clearTimeout(timer);
+      if (code !== 0) {
+        reject(new Error(`${host} installed hook exited with ${code}: ${stderr.slice(0, 2048)}`));
+        return;
+      }
+      try {
+        const protocol = parseProtocol(stdout, host);
+        const context = parseContext(protocol, host, requireBriefing);
+        if (requireBriefing && (context?.briefing?.host !== host
+          || !Array.isArray(context?.briefing?.sources?.documents))) {
+          throw new Error(`${host} installed hook did not inject a real session briefing: `
+            + `${protocol.reason || context?.error || context?.sourceResolution?.reason || "missing context"}`);
+        }
+        resolveResult({
+          event: protocol.hookSpecificOutput?.hookEventName || payload?.hook_event_name || null, host,
+          sources: context?.briefing?.sources?.documents?.length ?? null,
+          sourceIds: context?.briefing?.sources?.documents?.map((item) => item.path) || [],
+          sourceContents: context?.briefing?.sources?.documents?.map((item) => item.content).filter(Boolean) || [],
+          sourceResolution: context?.sourceResolution || null,
+          learningClaims: context?.briefing?.learning?.map((item) => item.claim) || [],
+          attentionKinds: context?.briefing?.attention?.items?.map((item) => item.kind) || [],
+          capturedAttentionKind: context?.attentionEvent?.kind || null,
+          selfstarter: context?.selfstarter || null,
+          channelEvent: context?.channelEvent || null,
+          voiceBrief: context?.briefing?.voiceBrief || null,
+          preflight: context?.preflight || null,
+          decision: protocol.decision || null,
+          reason: protocol.reason || null,
+          message: protocol.hookSpecificOutput?.message || null,
+          ...protocolShape(protocol)
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+    child.stdin.end(`${JSON.stringify(payload || {
+      hook_event_name: "SessionStart", cwd: projectRoot, host
+    })}\n`);
+  });
+}
+
+export async function invokeInstalledBlunPostWriteDigest(pluginRoot, projectRoot, stateRoot) {
+  const sessionId = `session:installed-blun-post-${stateRoot.split(/[\\/]/).at(-1)}`;
+  const shared = {
+    hook_event_name: "UserPromptSubmit", cwd: projectRoot, host: "blun",
+    project_id: "project:installed-blun-protocol", session_id: sessionId,
+    event_id: `prompt:${sessionId}`, prompt: "Change the synthetic installed BLUN artifact safely."
+  };
+  const prompted = await invokeInstalledHook(pluginRoot, projectRoot, stateRoot, "blun", shared,
+    { requireBriefing: false });
+  const requirementId = prompted.message?.match(
+    /Requirement: (premortem-requirement:[a-f0-9]{64}:[a-f0-9]{64})/
+  )?.[1];
+  if (!requirementId) throw new Error("installed BLUN prompt did not expose its premortem requirement");
+  const previousStateRoot = process.env.AGENTSPINE_STATE_DIR;
+  try {
+    process.env.AGENTSPINE_STATE_DIR = stateRoot;
+    const premortem = await import(pathToFileURL(join(pluginRoot, "src/lib/delivery-premortem.js")).href);
+    const usage = await import(pathToFileURL(join(pluginRoot, "src/lib/delivery-agent-usage.js")).href);
+    await usage.recordDeliveryBriefingUse({ root: projectRoot, requirementId,
+      input: { root: projectRoot }, result: { schema: "synthetic-installed-briefing" } });
+    await usage.recordDeliveryKnowledgeUse({ root: projectRoot, requirementId,
+      input: { targets: ["AGENTS.md"] }, result: { schema: "synthetic-installed-knowledge" } });
+    const recorded = await premortem.recordDeliveryPremortem({
+      root: projectRoot, requirementId, items: [
+        { category: "baseline-environment", failure: "this delivery fails because the installed baseline is stale",
+          check: "Compare the installed synthetic snapshot digest." },
+        { category: "contract-tests", failure: "this delivery fails because the installed contract regresses",
+          check: "Run the installed synthetic Node test." },
+        { category: "delivery-path", failure: "this delivery fails because the installed artifact is misplaced",
+          check: "Verify the installed synthetic artifact path and digest." }
+      ]
+    });
+    if (recorded.blocked) throw new Error(`installed BLUN premortem registration failed: ${recorded.reason}`);
+  } finally {
+    if (previousStateRoot === undefined) delete process.env.AGENTSPINE_STATE_DIR;
+    else process.env.AGENTSPINE_STATE_DIR = previousStateRoot;
+  }
+  const filePath = join(projectRoot, "installed-blun-post-write.txt");
+  const tool = { tool_name: "Write", tool_use_id: `write:${sessionId}`,
+    tool_input: { file_path: filePath, content: "synthetic installed BLUN write\n" } };
+  const pre = await invokeInstalledHook(pluginRoot, projectRoot, stateRoot, "blun", {
+    ...shared, ...tool, hook_event_name: "PreToolUse"
+  }, { requireBriefing: false });
+  if (pre.decision === "block" || pre.permissionDecision === "deny") {
+    throw new Error(`installed BLUN PreToolUse denied its registered premortem: ${pre.reason}`);
+  }
+  await writeFile(filePath, tool.tool_input.content, "utf8");
+  const post = await invokeInstalledHook(pluginRoot, projectRoot, stateRoot, "blun", {
+    ...shared, ...tool, hook_event_name: "PostToolUse", success: true, tool_response: { ok: true }
+  }, { requireBriefing: false });
+  const digest = post.message?.match(/Premortem latest write sha256 ([a-f0-9]{64})/)?.[1];
+  if (!digest || !exactKeys(post.protocolKeys, ["hookSpecificOutput"])
+    || !exactKeys(post.hookSpecificKeys, ["hookEventName", "message"])) {
+    throw new Error("installed BLUN PostToolUse did not return its latest-write digest through message");
+  }
+  return { contextField: "message", latestWriteDigest: digest };
+}
+
+function exactKeys(value, expected) {
+  return JSON.stringify(value) === JSON.stringify([...expected].sort());
+}
+
+export async function invokeInstalledBlockingProtocols(pluginRoot, projectRoot, stateRoot) {
+  const writePayload = (host) => ({
+    hook_event_name: "PreToolUse", cwd: projectRoot, host,
+    project_id: "project:installed-protocol",
+    session_id: `session:installed-${host}-protocol`, tool_name: "Write",
+    tool_use_id: `tool:installed-${host}-protocol`,
+    tool_input: { file_path: "AGENTS.md", content: "synthetic\n" }
+  });
+  const claudePreTool = await invokeInstalledHook(
+    pluginRoot, projectRoot, stateRoot, "claude", writePayload("claude"), { requireBriefing: false }
+  );
+  const claudeStop = await invokeInstalledHook(pluginRoot, projectRoot, stateRoot, "claude", {
+    hook_event_name: "Stop", cwd: projectRoot, host: "claude",
+    project_id: "project:installed-protocol",
+    session_id: "session:installed-claude-stop-protocol",
+    agent_spine_exchange_directory: projectRoot,
+    final_assistant_message: "missing-installed-artifact.txt sha256 0000000000000000"
+  }, { requireBriefing: false });
+  const codexPreTool = await invokeInstalledHook(
+    pluginRoot, projectRoot, stateRoot, "codex", writePayload("codex"), { requireBriefing: false }
+  );
+  if (claudePreTool.decision !== null || claudePreTool.permissionDecision !== "deny"
+    || !claudePreTool.permissionDecisionReason?.includes("protected source")
+    || !exactKeys(claudePreTool.protocolKeys, ["hookSpecificOutput"])
+    || !exactKeys(claudePreTool.hookSpecificKeys,
+      ["hookEventName", "permissionDecision", "permissionDecisionReason"])) {
+    throw new Error("installed Claude PreToolUse denial did not use its nested permissionDecision schema");
+  }
+  if (claudeStop.decision !== null || claudeStop.permissionDecision !== null) {
+    throw new Error("installed Claude Stop must not block replies for artifact evidence");
+  }
+  if (codexPreTool.decision !== "block" || !codexPreTool.reason?.includes("protected source")
+    || codexPreTool.permissionDecision !== null
+    || !exactKeys(codexPreTool.protocolKeys, ["decision", "reason"])) {
+    const observed = {
+      decision: codexPreTool.decision, reason: codexPreTool.reason,
+      protocolKeys: codexPreTool.protocolKeys, hookSpecificKeys: codexPreTool.hookSpecificKeys,
+      permissionDecision: codexPreTool.permissionDecision,
+      sourceResolution: codexPreTool.sourceResolution, preflight: codexPreTool.preflight,
+      selfstarter: codexPreTool.selfstarter
+    };
+    throw new Error("installed Codex denial did not preserve its strict top-level decision/reason schema: "
+      + JSON.stringify(observed).slice(0, 8192));
+  }
+  return {
+    claude: { preTool: "nested-permission-deny", stop: "advisory" },
+    codex: { preTool: "top-level-block" }
+  };
+}