blun-king-cli 9.1.562 → 9.1.564

package/LIESMICH.txt

@@ -1,7 +1,7 @@
-BLUN Code 9.1.561
+BLUN Code 9.1.563
 
 Installation:
-  npm install -g blun-king-cli@9.1.561
+  npm install -g blun-king-cli@9.1.563
 
 Start:
   blun

package/README.md

@@ -11,7 +11,7 @@ web tools, MCP servers, and an optional Telegram channel.
 ## Install
 
 ```sh
-npm install -g blun-king-cli@9.1.561
+npm install -g blun-king-cli@9.1.563
 ```
 
 Start the local console with:

package/agent-spine-plugin/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
       "name": "agent-spine",
       "source": ".",
       "description": "Map existing rules, soul, and memory without rewriting source files.",
-      "version": "0.11.4",
+      "version": "0.49.0",
       "author": {
         "name": "Mayk Biletti"
       },

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

@@ -1,6 +1,6 @@
 {
   "name": "agent-spine",
-  "version": "0.11.4",
+  "version": "0.49.0",
   "description": "A non-destructive identity and memory spine for Claude Code agents.",
   "author": {
     "name": "Mayk Biletti",

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

@@ -1,6 +1,6 @@
 {
   "name": "agent-spine",
-  "version": "0.11.4",
+  "version": "0.49.0",
   "description": "A non-destructive identity and memory spine for Codex agents.",
   "author": {
     "name": "Mayk Biletti",

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

@@ -1,6 +1,6 @@
 {
   "name": "agent-spine",
-  "version": "0.11.4",
+  "version": "0.49.0",
   "description": "A non-destructive identity and memory spine for BLUN King agents.",
   "license": "Apache-2.0",
   "author": {
@@ -15,10 +15,10 @@
     }
   },
   "hooks": [
-    { "event": "SessionStart", "command": "node \"./src/hook.js\"", "timeout": 180 },
+    { "event": "SessionStart", "command": "node \"./src/hook.js\"", "timeout": 15 },
     { "event": "UserPromptSubmit", "command": "node \"./src/hook.js\"", "timeout": 15 },
     { "event": "PreToolUse", "matcher": "Edit|Write|apply_patch|Bash|exec_command", "command": "node \"./src/hook.js\"", "timeout": 15 },
-    { "event": "PostToolUse", "command": "node \"./src/hook.js\"", "timeout": 15 },
+    { "event": "PostToolUse", "command": "node \"./src/hook.js\" --silent-oversize-post-tool-use", "timeout": 15 },
     { "event": "PreCompact", "command": "node \"./src/hook.js\"", "timeout": 15 },
     { "event": "PostCompact", "command": "node \"./src/hook.js\"", "timeout": 15 },
     { "event": "Stop", "command": "node \"./src/hook.js\"", "timeout": 15 },

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

@@ -4,7 +4,7 @@
     "SessionStart": [
       {
         "matcher": "startup|resume|clear|compact",
-        "hooks": [{ "type": "command", "command": "node \"${PLUGIN_ROOT}/src/hook.js\"", "timeout": 180 }]
+        "hooks": [{ "type": "command", "command": "node \"${PLUGIN_ROOT}/src/hook.js\"", "timeout": 15 }]
       }
     ],
     "UserPromptSubmit": [
@@ -20,7 +20,7 @@
     ],
     "PostToolUse": [
       {
-        "hooks": [{ "type": "command", "command": "node \"${PLUGIN_ROOT}/src/hook.js\"", "timeout": 15 }]
+        "hooks": [{ "type": "command", "command": "node \"${PLUGIN_ROOT}/src/hook.js\" --silent-oversize-post-tool-use", "timeout": 15 }]
       }
     ],
     "PreCompact": [

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

@@ -52,7 +52,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"${CLAUDE_PLUGIN_ROOT}/src/hook.js\"",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/src/hook.js\" --silent-oversize-post-tool-use",
             "timeout": 15
           }
         ]

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

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

package/agent-spine-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-spine",
-  "version": "0.11.4",
+  "version": "0.49.0",
   "description": "A non-destructive identity and memory spine for AI agents.",
   "type": "module",
   "bin": {

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

@@ -1,196 +1,199 @@
-#!/usr/bin/env node
-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";
-
-function assert(condition, message) {
-  if (!condition) throw new Error(message);
-}
-
-async function json(root, path) {
-  return JSON.parse(await readFile(resolve(root, path), "utf8"));
-}
-
-function expand(value, variable, root) {
-  assert(typeof value === "string" && value.length > 0, "host command values must be non-empty strings");
-  return value.split(`\${${variable}}`).join(root);
-}
-
-async function validateEntrypoint(root, value) {
-  const target = resolve(value);
-  const within = relative(root, target);
-  assert(within && !within.startsWith("..") && !isAbsolute(within), "MCP entrypoint must remain inside the plugin");
-  const metadata = await stat(target);
-  assert(metadata.isFile(), "MCP entrypoint must be a regular file");
-}
-
-function validateHooks(root, hooks, { required, commandRoot }) {
-  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");
-  for (const event of required) {
-    const registrations = hooks.hooks?.[event];
-    assert(Array.isArray(registrations) && registrations.length === 1, `${event} must have exactly one registration`);
-    assert(Array.isArray(registrations[0].hooks) && registrations[0].hooks.length === 1, `${event} must have exactly one hook command`);
-    const command = registrations[0].hooks[0];
-    assert(command.type === "command", `${event} must use a command hook`);
-    assert(command.command === `node "\${${commandRoot}}/src/hook.js"`, `${event} must use the bundled lifecycle adapter`);
-    assert(Number.isInteger(command.timeout) && command.timeout > 0 && command.timeout <= 15, `${event} timeout is unsafe`);
-  }
-  const extras = Object.keys(hooks.hooks || {}).filter((event) => !required.includes(event));
-  assert(extras.length === 0, `unknown hook events: ${extras.join(", ")}`);
-  return { events: required, commands: required.length, entrypoint: relative(root, resolve(root, "src/hook.js")) };
-}
-
-function validateBlunHooks(root, hooks) {
-  const required = [
-    "SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse",
-    "PreCompact", "PostCompact", "Stop", "SubagentStop"
-  ];
-  assert(Array.isArray(hooks), "BLUN hook bundle is missing");
-  assert(hooks.length === required.length, "BLUN must register exactly one command per lifecycle event");
-  assert(JSON.stringify(hooks.map(({ event }) => event)) === JSON.stringify(required),
-    "BLUN lifecycle events must remain complete and ordered");
-  for (const event of required) {
-    const registrations = hooks.filter((hook) => hook.event === event);
-    assert(registrations.length === 1, `${event} must have exactly one BLUN registration`);
-    const command = registrations[0];
-    assert(command.command === 'node "./src/hook.js"', `${event} must use the bundled BLUN lifecycle adapter`);
-    assert(Number.isInteger(command.timeout) && command.timeout > 0 && command.timeout <= 15, `${event} BLUN timeout is unsafe`);
-  }
-  return { events: required, commands: required.length, entrypoint: relative(root, resolve(root, "src/hook.js")) };
-}
-
-async function initializeServer({ label, root, variable, server, version }) {
-  assert(server && typeof server === "object" && !Array.isArray(server), `${label} MCP registration is missing`);
-  assert(server.command === "node", `${label} MCP registration must use the Node.js runtime`);
-  assert(Array.isArray(server.args) && server.args.length === 1, `${label} MCP registration must name exactly one entrypoint`);
-  const command = process.execPath;
-  const args = server.args.map((value) => {
-    const expanded = expand(value, variable, root);
-    return isAbsolute(expanded) ? expanded : resolve(root, expanded);
-  });
-  assert(!args.some((value) => value.includes("${")), `${label} MCP registration contains an unresolved variable`);
-  await validateEntrypoint(root, args[0]);
-
-  return await new Promise((resolveResult, reject) => {
-    const child = spawn(command, args, {
-      cwd: root,
-      env: { ...process.env, CLAUDE_PLUGIN_ROOT: root, PLUGIN_ROOT: root },
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    let settled = false;
-    const finish = (error, value) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      const settle = () => {
-        if (error) reject(error);
-        else resolveResult(value);
-      };
-      if (child.exitCode !== null || child.signalCode !== null) return settle();
-      child.once("close", settle);
-      child.kill();
-    };
-    const timer = setTimeout(() => {
-      finish(new Error(`${label} MCP initialize timed out${stderr ? `: ${stderr.trim()}` : ""}`));
-    }, 3000);
-    child.stderr.setEncoding("utf8");
-    child.stderr.on("data", (chunk) => { stderr += chunk; });
-    child.stdout.setEncoding("utf8");
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk;
-      const newline = stdout.indexOf("\n");
-      if (newline < 0) return;
-      try {
-        const message = JSON.parse(stdout.slice(0, newline));
-        assert(message.id === 1, `${label} MCP initialize returned the wrong request id`);
-        assert(message.result?.serverInfo?.name === "agent-spine", `${label} MCP initialize returned the wrong server identity`);
-        assert(message.result?.serverInfo?.version === version, `${label} MCP initialize returned a stale server version`);
-        finish(null, { label, server: message.result.serverInfo.name, entrypoint: relative(root, args[0]) });
-      } catch (error) {
-        finish(error);
-      }
-    });
-    child.once("error", (error) => finish(error));
-    child.once("close", (code) => {
-      if (!settled) finish(new Error(`${label} MCP server exited with ${code}${stderr ? `: ${stderr.trim()}` : ""}`));
-    });
-    // A real MCP host keeps stdio open after initialization. Closing stdin
-    // here let macOS and Windows terminate the server before its queued reply.
-    child.stdin.write(`${JSON.stringify({
-      jsonrpc: "2.0", id: 1, method: "initialize", params: { protocolVersion: "2025-06-18" }
-    })}\n`);
-  });
-}
-
-export async function checkHosts(root = process.cwd()) {
-  root = resolve(root);
-  const [pkg, blunManifest, claudeManifest, claudeMcp, codexManifest, claudeHooks, codexHooks, hookVersion] = await Promise.all([
-    json(root, "package.json"),
-    json(root, "blun.plugin.json"),
-    json(root, ".claude-plugin/plugin.json"),
-    json(root, ".mcp.json"),
-    json(root, ".codex-plugin/plugin.json"),
-    json(root, "hooks/hooks.json"),
-    json(root, "hooks/codex.json"),
-    json(root, "hooks/version.json")
-  ]);
-  assert(blunManifest.version === pkg.version && claudeManifest.version === pkg.version && codexManifest.version === pkg.version,
-    "host manifests must use the package cache version");
-  assert(hookVersion.schema === "agentspine.hook-bundle/v1" && hookVersion.version === pkg.version,
-    "hook bundle version must match the package cache version");
-  assert(hookVersion.contract === "agentspine.preflight/v2", "hook bundle preflight contract is missing");
-  assert(pkg.bin?.["agentspine-worker"] === "./src/worker.js", "package must register exactly one gateway worker entrypoint");
-  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(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 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 }),
-    initializeServer({ label: "claude", root, variable: "CLAUDE_PLUGIN_ROOT", server: claudeMcp.mcpServers["agent-spine"], version: pkg.version }),
-    initializeServer({ label: "codex", root, variable: "PLUGIN_ROOT", server: codexManifest.mcpServers["agent-spine"], version: pkg.version })
-  ]);
-  return {
-    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",
-      trust: "host-user-required", liveTrustVerified: false
-    },
-    worker: { entrypoint: pkg.bin["agentspine-worker"], setsPerInstall: 1 },
-    exactlyOnce: { mcpServersPerHost: 1, hookSetsPerHost: 1, workerSetsPerInstall: 1 },
-    authority: "registration-check-only"
-  };
-}
-
-async function main() {
-  const args = process.argv.slice(2);
-  let root = process.cwd();
-  let pretty = false;
-  for (let index = 0; index < args.length; index += 1) {
-    if (args[index] === "--root") root = args[++index];
-    else if (args[index] === "--json") pretty = true;
-    else throw new Error(`unknown host-check argument: ${args[index]}`);
-  }
-  process.stdout.write(`${JSON.stringify(await checkHosts(root), null, pretty ? 2 : 0)}\n`);
-}
-
-if (process.argv[1] && resolve(process.argv[1]) === resolve(fileURLToPath(import.meta.url))) {
-  main().catch((error) => {
-    process.stderr.write(`AgentSpine host check failed: ${error.message}\n`);
-    process.exitCode = 1;
-  });
-}
-
+#!/usr/bin/env node
+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";
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+async function json(root, path) {
+  return JSON.parse(await readFile(resolve(root, path), "utf8"));
+}
+
+function expand(value, variable, root) {
+  assert(typeof value === "string" && value.length > 0, "host command values must be non-empty strings");
+  return value.split(`\${${variable}}`).join(root);
+}
+
+async function validateEntrypoint(root, value) {
+  const target = resolve(value);
+  const within = relative(root, target);
+  assert(within && !within.startsWith("..") && !isAbsolute(within), "MCP entrypoint must remain inside the plugin");
+  const metadata = await stat(target);
+  assert(metadata.isFile(), "MCP entrypoint must be a regular file");
+}
+
+function validateHooks(root, hooks, { required, commandRoot }) {
+  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");
+  for (const event of required) {
+    const registrations = hooks.hooks?.[event];
+    assert(Array.isArray(registrations) && registrations.length === 1, `${event} must have exactly one registration`);
+    assert(Array.isArray(registrations[0].hooks) && registrations[0].hooks.length === 1, `${event} must have exactly one hook command`);
+    const command = registrations[0].hooks[0];
+    assert(command.type === "command", `${event} must use a command hook`);
+    const expected = `node "\${${commandRoot}}/src/hook.js"${event === "PostToolUse"
+      ? " --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`);
+  }
+  const extras = Object.keys(hooks.hooks || {}).filter((event) => !required.includes(event));
+  assert(extras.length === 0, `unknown hook events: ${extras.join(", ")}`);
+  return { events: required, commands: required.length, entrypoint: relative(root, resolve(root, "src/hook.js")) };
+}
+
+function validateBlunHooks(root, hooks) {
+  const required = [
+    "SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse",
+    "PreCompact", "PostCompact", "Stop", "SubagentStop"
+  ];
+  assert(Array.isArray(hooks), "BLUN hook bundle is missing");
+  assert(hooks.length === required.length, "BLUN must register exactly one command per lifecycle event");
+  assert(JSON.stringify(hooks.map(({ event }) => event)) === JSON.stringify(required),
+    "BLUN lifecycle events must remain complete and ordered");
+  for (const event of required) {
+    const registrations = hooks.filter((hook) => hook.event === event);
+    assert(registrations.length === 1, `${event} must have exactly one BLUN registration`);
+    const command = registrations[0];
+    const expected = `node "./src/hook.js"${event === "PostToolUse"
+      ? " --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`);
+  }
+  return { events: required, commands: required.length, entrypoint: relative(root, resolve(root, "src/hook.js")) };
+}
+
+async function initializeServer({ label, root, variable, server, version }) {
+  assert(server && typeof server === "object" && !Array.isArray(server), `${label} MCP registration is missing`);
+  assert(server.command === "node", `${label} MCP registration must use the Node.js runtime`);
+  assert(Array.isArray(server.args) && server.args.length === 1, `${label} MCP registration must name exactly one entrypoint`);
+  const command = process.execPath;
+  const args = server.args.map((value) => {
+    const expanded = expand(value, variable, root);
+    return isAbsolute(expanded) ? expanded : resolve(root, expanded);
+  });
+  assert(!args.some((value) => value.includes("${")), `${label} MCP registration contains an unresolved variable`);
+  await validateEntrypoint(root, args[0]);
+
+  return await new Promise((resolveResult, reject) => {
+    const child = spawn(command, args, {
+      cwd: root,
+      env: { ...process.env, CLAUDE_PLUGIN_ROOT: root, PLUGIN_ROOT: root },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const finish = (error, value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      const settle = () => {
+        if (error) reject(error);
+        else resolveResult(value);
+      };
+      if (child.exitCode !== null || child.signalCode !== null) return settle();
+      child.once("close", settle);
+      child.kill();
+    };
+    const timer = setTimeout(() => {
+      finish(new Error(`${label} MCP initialize timed out${stderr ? `: ${stderr.trim()}` : ""}`));
+    }, 3000);
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => { stderr += chunk; });
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+      const newline = stdout.indexOf("\n");
+      if (newline < 0) return;
+      try {
+        const message = JSON.parse(stdout.slice(0, newline));
+        assert(message.id === 1, `${label} MCP initialize returned the wrong request id`);
+        assert(message.result?.serverInfo?.name === "agent-spine", `${label} MCP initialize returned the wrong server identity`);
+        assert(message.result?.serverInfo?.version === version, `${label} MCP initialize returned a stale server version`);
+        finish(null, { label, server: message.result.serverInfo.name, entrypoint: relative(root, args[0]) });
+      } catch (error) {
+        finish(error);
+      }
+    });
+    child.once("error", (error) => finish(error));
+    child.once("close", (code) => {
+      if (!settled) finish(new Error(`${label} MCP server exited with ${code}${stderr ? `: ${stderr.trim()}` : ""}`));
+    });
+    // A real MCP host keeps stdio open after initialization. Closing stdin
+    // here let macOS and Windows terminate the server before its queued reply.
+    child.stdin.write(`${JSON.stringify({
+      jsonrpc: "2.0", id: 1, method: "initialize", params: { protocolVersion: "2025-06-18" }
+    })}\n`);
+  });
+}
+
+export async function checkHosts(root = process.cwd()) {
+  root = resolve(root);
+  const [pkg, blunManifest, claudeManifest, claudeMcp, codexManifest, claudeHooks, codexHooks, hookVersion] = await Promise.all([
+    json(root, "package.json"),
+    json(root, "blun.plugin.json"),
+    json(root, ".claude-plugin/plugin.json"),
+    json(root, ".mcp.json"),
+    json(root, ".codex-plugin/plugin.json"),
+    json(root, "hooks/hooks.json"),
+    json(root, "hooks/codex.json"),
+    json(root, "hooks/version.json")
+  ]);
+  assert(blunManifest.version === pkg.version && claudeManifest.version === pkg.version && codexManifest.version === pkg.version,
+    "host manifests must use the package cache version");
+  assert(hookVersion.schema === "agentspine.hook-bundle/v1" && hookVersion.version === pkg.version,
+    "hook bundle version must match the package cache version");
+  assert(hookVersion.contract === "agentspine.preflight/v2", "hook bundle preflight contract is missing");
+  assert(pkg.bin?.["agentspine-worker"] === "./src/worker.js", "package must register exactly one gateway worker entrypoint");
+  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(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 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 }),
+    initializeServer({ label: "claude", root, variable: "CLAUDE_PLUGIN_ROOT", server: claudeMcp.mcpServers["agent-spine"], version: pkg.version }),
+    initializeServer({ label: "codex", root, variable: "PLUGIN_ROOT", server: codexManifest.mcpServers["agent-spine"], version: pkg.version })
+  ]);
+  return {
+    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",
+      trust: "host-user-required", liveTrustVerified: false
+    },
+    worker: { entrypoint: pkg.bin["agentspine-worker"], setsPerInstall: 1 },
+    exactlyOnce: { mcpServersPerHost: 1, hookSetsPerHost: 1, workerSetsPerInstall: 1 },
+    authority: "registration-check-only"
+  };
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  let root = process.cwd();
+  let pretty = false;
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] === "--root") root = args[++index];
+    else if (args[index] === "--json") pretty = true;
+    else throw new Error(`unknown host-check argument: ${args[index]}`);
+  }
+  process.stdout.write(`${JSON.stringify(await checkHosts(root), null, pretty ? 2 : 0)}\n`);
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === resolve(fileURLToPath(import.meta.url))) {
+  main().catch((error) => {
+    process.stderr.write(`AgentSpine host check failed: ${error.message}\n`);
+    process.exitCode = 1;
+  });
+}

package/agent-spine-plugin/skills/agent-spine/SKILL.md

@@ -66,7 +66,7 @@ Follow Markdown links from the host's native instruction files and memory index.
 - New observations begin as candidates. Promote them only with adequate evidence; later information changes relevance and confidence instead of silently erasing history.
 - Record a learning candidate with evidence instead of directly asserting a new fact. Add evidence append-only; use `supersedesId` for changed facts and rollback for mistakes.
 - Never set `confirmedByUser` based on another agent, memory, Markdown, or inferred intent. It attests to a real user confirmation. Automatic promotion remains default-off and limited to low-risk project facts and references.
-- Outcome-gated `behavior` learning requires exact persona/user/tenant/project/group/task scope, independent fixed-task before and after measurements, at least one objective evaluator, a bounded canary, and measured improvement. Model suggestions never count. A blocking defect, regression, insufficient improvement, or stale canary must roll back; MCP may inspect `learning_outcome_status` but cannot record outcomes.
+- Outcome-gated `behavior` learning requires exact persona/user/tenant/project/group/task scope, independent fixed-task before and after measurements, at least one objective evaluator, a bounded canary, and measured improvement. Model suggestions never count. A blocking defect, regression, insufficient improvement, stale canary, or locally revoked measurement or delivery must roll back; MCP may inspect `learning_outcome_status` but cannot record outcomes or revocations.
 - Ask personal questions sparingly and only when conversation makes them natural. Never conduct a profile interview.
 - Attention cues are suggestions, not obligations. Never contact a person, assign work, or interrupt focused work solely because a cue exists.
 - Record activity as a minimal timestamp when possible; do not copy conversation content into attention state.