@zeroroot-ai/zerocool-claude 0.1.0 → 0.1.1

package/.claude-plugin/plugin.json

@@ -3,11 +3,17 @@
   "name": "zerocool",
   "displayName": "Zerocool (Gibson)",
   "description": "Gibson platform integration for Claude Code. The session is a live mission. Memory and knowledge in the tenant graph, findings, Gibson tools, delegation. The model stays on your Claude subscription.",
-  "author": { "name": "ZeroRoot", "url": "https://zeroroot.ai" },
+  "author": {
+    "name": "ZeroRoot",
+    "url": "https://zeroroot.ai"
+  },
   "homepage": "https://github.com/zeroroot-ai/zerocool-plugins",
   "repository": "https://github.com/zeroroot-ai/zerocool-plugins",
   "license": "MIT",
-  "keywords": ["gibson", "security", "knowledge-graph", "mcp"],
-  "mcpServers": "./.mcp.json",
-  "hooks": "./hooks/hooks.json"
+  "keywords": [
+    "gibson",
+    "security",
+    "knowledge-graph",
+    "mcp"
+  ]
 }

package/dist/build.d.ts

@@ -0,0 +1,15 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type Gibson } from "./session.js";
+/**
+ * @zeroroot-ai/zerocool-claude: the MCP server Claude Code starts for a session.
+ *
+ * The model stays on the user's Claude subscription. This server adds Gibson:
+ * one live mission per session, memory and knowledge, findings, tools,
+ * delegation. It never routes LLM traffic and never reads an Anthropic key
+ * (ADR-0007).
+ */
+export declare const log: (line: string) => void;
+export declare function buildServer(env: NodeJS.ProcessEnv, cwd: string): Promise<{
+    server: McpServer;
+    gibson: Gibson;
+}>;

package/dist/build.js

@@ -0,0 +1,60 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ambientBlock } from "./ambient.js";
+import { openGibson } from "./session.js";
+import { stateDir, writeAmbient, writeLive } from "./state.js";
+import { registerComponentizeTool, registerEnrollTool } from "./tools/componentize.js";
+import { registerDelegationTools } from "./tools/delegate.js";
+import { gibsonFindingsBackend, localFindingsBackend, registerFindingTools } from "./tools/findings.js";
+import { registerGibsonTools } from "./tools/gibson-tools.js";
+import { registerMemoryTools } from "./tools/memory.js";
+import { registerStatusTool } from "./tools/status.js";
+/**
+ * @zeroroot-ai/zerocool-claude: the MCP server Claude Code starts for a session.
+ *
+ * The model stays on the user's Claude subscription. This server adds Gibson:
+ * one live mission per session, memory and knowledge, findings, tools,
+ * delegation. It never routes LLM traffic and never reads an Anthropic key
+ * (ADR-0007).
+ */
+export const log = (line) => {
+    process.stderr.write(`${line}\n`);
+};
+export async function buildServer(env, cwd) {
+    const gibson = await openGibson({ env, log });
+    const server = new McpServer({ name: "zerocool", version: "0.0.0" });
+    registerStatusTool(server, gibson);
+    registerComponentizeTool(server, cwd);
+    if (!gibson.session) {
+        registerFindingTools(server, gibson, localFindingsBackend(env.ZEROCOOL_FINDINGS_LOG ?? join(homedir(), ".zerocool", "findings.jsonl")));
+        return { server, gibson };
+    }
+    registerFindingTools(server, gibson, gibsonFindingsBackend(gibson));
+    registerMemoryTools(server, gibson);
+    registerEnrollTool(server, gibson.session);
+    registerDelegationTools(server, gibson.session);
+    const discovery = await registerGibsonTools(server, gibson.session);
+    log(discovery.note ? `[zerocool-claude] Gibson tool discovery: ${discovery.note}` : `[zerocool-claude] ${discovery.discovered} Gibson tool(s) registered`);
+    // Handoff for the hooks: the ambient block now, the live coordinates while
+    // the mission runs. Both fail open.
+    const dir = stateDir(env);
+    if (gibson.knowledge) {
+        const block = await ambientBlock(gibson.knowledge, env.ZEROCOOL_AMBIENT_QUERY ?? "memories, prior findings and security facts for this codebase");
+        if (block)
+            await writeAmbient(dir, cwd, block).catch((e) => log(`[zerocool-claude] ambient handoff failed: ${e.message}`));
+    }
+    if (gibson.live) {
+        const live = gibson.live;
+        const write = () => writeLive(dir, cwd, {
+            missionId: live.missionId,
+            workId: live.workId,
+            endpoint: live.harness.endpoint,
+            token: live.harness.token(),
+            insecure: env.GIBSON_CALLBACK_INSECURE === "1",
+            writtenAt: Date.now(),
+        }).catch((e) => log(`[zerocool-claude] live handoff failed: ${e.message}`));
+        await write();
+    }
+    return { server, gibson };
+}

package/dist/hook-run.d.ts

@@ -0,0 +1,21 @@
+import { readFile } from "node:fs/promises";
+/**
+ * The hook bin. Claude Code runs it as a separate process per event, with the
+ * event on stdin. It never talks to the MCP server. It reads what the server
+ * handed off through the state directory (state.ts) and fails open: a missing
+ * file means no output, and no output blocks nothing.
+ *
+ *  - SessionStart: inject the ambient knowledge block as additionalContext.
+ *  - SessionEnd: checkpoint the transcript to the daemon session store under
+ *    the live mission's task grant (zerocool-plugins#13, the session seam).
+ */
+export interface HookInput {
+    session_id?: string;
+    hook_event_name?: string;
+    cwd?: string;
+    transcript_path?: string;
+    reason?: string;
+}
+export declare function runHook(input: HookInput, env: NodeJS.ProcessEnv, deps?: {
+    readFile: typeof readFile;
+}): Promise<string>;

package/dist/hook-run.js

@@ -0,0 +1,51 @@
+import { readFile } from "node:fs/promises";
+import { openTaskHarness } from "@zeroroot-ai/sdk";
+import { readAmbient, readLive, stateDir } from "./state.js";
+/** The session store caps a blob at 8 MiB (gibson callback_session_context.go). */
+const MAX_TRANSCRIPT_BYTES = 8 * 1024 * 1024;
+export async function runHook(input, env, deps = { readFile }) {
+    const cwd = input.cwd ?? process.cwd();
+    const dir = stateDir(env);
+    switch (input.hook_event_name) {
+        case "SessionStart": {
+            const block = await readAmbient(dir, cwd);
+            if (!block)
+                return "";
+            return JSON.stringify({ hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: block } });
+        }
+        case "SessionEnd": {
+            const live = await readLive(dir, cwd);
+            if (!live || !input.transcript_path || !input.session_id)
+                return "";
+            let data;
+            try {
+                data = await deps.readFile(input.transcript_path);
+            }
+            catch {
+                return "";
+            }
+            if (data.byteLength > MAX_TRANSCRIPT_BYTES)
+                data = data.subarray(data.byteLength - MAX_TRANSCRIPT_BYTES);
+            const harness = openTaskHarness({ endpoint: live.endpoint, token: live.token, insecure: live.insecure, renew: false });
+            try {
+                const res = await harness.client.putSessionContext({
+                    context: harness.context,
+                    sessionId: input.session_id,
+                    data: new Uint8Array(data),
+                    ifMatch: "",
+                });
+                if (res.error)
+                    return JSON.stringify({ systemMessage: `zerocool: session checkpoint refused: ${res.error.message}` });
+            }
+            catch (e) {
+                return JSON.stringify({ systemMessage: `zerocool: session checkpoint failed: ${e.message}` });
+            }
+            finally {
+                harness.stop();
+            }
+            return "";
+        }
+        default:
+            return "";
+    }
+}

package/dist/hook.d.ts

@@ -1,23 +1,2 @@
 #!/usr/bin/env node
-import { readFile } from "node:fs/promises";
-/**
- * The hook bin. Claude Code runs it as a separate process per event, with the
- * event on stdin. It never talks to the MCP server. It reads what the server
- * handed off through the state directory (state.ts) and fails open: a missing
- * file means no output, and no output blocks nothing.
- *
- *  - SessionStart: inject the ambient knowledge block as additionalContext.
- *  - SessionEnd: checkpoint the transcript to the daemon session store under
- *    the live mission's task grant (zerocool-plugins#13, the session seam).
- */
-interface HookInput {
-    session_id?: string;
-    hook_event_name?: string;
-    cwd?: string;
-    transcript_path?: string;
-    reason?: string;
-}
-export declare function runHook(input: HookInput, env: NodeJS.ProcessEnv, deps?: {
-    readFile: typeof readFile;
-}): Promise<string>;
 export {};

package/dist/hook.js

@@ -1,72 +1,24 @@
 #!/usr/bin/env node
-import { readFile } from "node:fs/promises";
-import { openTaskHarness } from "@zeroroot-ai/sdk";
-import { readAmbient, readLive, stateDir } from "./state.js";
-/** The session store caps a blob at 8 MiB (gibson callback_session_context.go). */
-const MAX_TRANSCRIPT_BYTES = 8 * 1024 * 1024;
-export async function runHook(input, env, deps = { readFile }) {
-    const cwd = input.cwd ?? process.cwd();
-    const dir = stateDir(env);
-    switch (input.hook_event_name) {
-        case "SessionStart": {
-            const block = await readAmbient(dir, cwd);
-            if (!block)
-                return "";
-            return JSON.stringify({ hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: block } });
-        }
-        case "SessionEnd": {
-            const live = await readLive(dir, cwd);
-            if (!live || !input.transcript_path || !input.session_id)
-                return "";
-            let data;
-            try {
-                data = await deps.readFile(input.transcript_path);
-            }
-            catch {
-                return "";
-            }
-            if (data.byteLength > MAX_TRANSCRIPT_BYTES)
-                data = data.subarray(data.byteLength - MAX_TRANSCRIPT_BYTES);
-            const harness = openTaskHarness({ endpoint: live.endpoint, token: live.token, insecure: live.insecure, renew: false });
-            try {
-                const res = await harness.client.putSessionContext({
-                    context: harness.context,
-                    sessionId: input.session_id,
-                    data: new Uint8Array(data),
-                    ifMatch: "",
-                });
-                if (res.error)
-                    return JSON.stringify({ systemMessage: `zerocool: session checkpoint refused: ${res.error.message}` });
-            }
-            catch (e) {
-                return JSON.stringify({ systemMessage: `zerocool: session checkpoint failed: ${e.message}` });
-            }
-            finally {
-                harness.stop();
-            }
-            return "";
-        }
-        default:
-            return "";
-    }
-}
+import { runHook } from "./hook-run.js";
+/**
+ * The hook bin. Runs unconditionally: npm installs it as a symlink named
+ * `zerocool-claude-hook`, so an argv[1] guard would never match. Library
+ * code lives in hook-run.ts.
+ */
 async function readStdin() {
     const chunks = [];
     for await (const c of process.stdin)
         chunks.push(c);
     return Buffer.concat(chunks).toString("utf8");
 }
-const invokedDirectly = process.argv[1]?.endsWith("hook.js") ?? false;
-if (invokedDirectly) {
-    readStdin()
-        .then((raw) => runHook(raw ? JSON.parse(raw) : {}, process.env))
-        .then((out) => {
-        if (out)
-            process.stdout.write(out);
-        process.exit(0);
-    })
-        .catch((e) => {
-        process.stderr.write(`[zerocool-claude hook] ${e.message}\n`);
-        process.exit(0); // fail open: a hook error must not block the session
-    });
-}
+readStdin()
+    .then((raw) => runHook(raw ? JSON.parse(raw) : {}, process.env))
+    .then((out) => {
+    if (out)
+        process.stdout.write(out);
+    process.exit(0);
+})
+    .catch((e) => {
+    process.stderr.write(`[zerocool-claude hook] ${e.message}\n`);
+    process.exit(0); // fail open: a hook error must not block the session
+});

package/dist/index.d.ts

@@ -2,4 +2,5 @@ export * from "./mode.js";
 export * from "./session.js";
 export * from "./state.js";
 export * from "./ambient.js";
-export { buildServer } from "./server.js";
+export { buildServer } from "./build.js";
+export { runHook } from "./hook-run.js";

package/dist/index.js

@@ -4,4 +4,5 @@ export * from "./mode.js";
 export * from "./session.js";
 export * from "./state.js";
 export * from "./ambient.js";
-export { buildServer } from "./server.js";
+export { buildServer } from "./build.js";
+export { runHook } from "./hook-run.js";

package/dist/server.d.ts

@@ -1,7 +1,2 @@
 #!/usr/bin/env node
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { type Gibson } from "./session.js";
-export declare function buildServer(env: NodeJS.ProcessEnv, cwd: string): Promise<{
-    server: McpServer;
-    gibson: Gibson;
-}>;
+export {};

package/dist/server.js

@@ -1,65 +1,14 @@
 #!/usr/bin/env node
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { ambientBlock } from "./ambient.js";
-import { openGibson } from "./session.js";
-import { clearLive, stateDir, writeAmbient, writeLive } from "./state.js";
-import { registerComponentizeTool, registerEnrollTool } from "./tools/componentize.js";
-import { registerDelegationTools } from "./tools/delegate.js";
-import { gibsonFindingsBackend, localFindingsBackend, registerFindingTools } from "./tools/findings.js";
-import { registerGibsonTools } from "./tools/gibson-tools.js";
-import { registerMemoryTools } from "./tools/memory.js";
-import { describeGibson, registerStatusTool } from "./tools/status.js";
+import { buildServer, log } from "./build.js";
+import { clearLive, stateDir } from "./state.js";
+import { describeGibson } from "./tools/status.js";
 /**
- * @zeroroot-ai/zerocool-claude: the MCP server Claude Code starts for a session.
- *
- * The model stays on the user's Claude subscription. This server adds Gibson:
- * one live mission per session, memory and knowledge, findings, tools,
- * delegation. It never routes LLM traffic and never reads an Anthropic key
- * (ADR-0007).
+ * The MCP server bin. This file runs main() unconditionally: npm installs
+ * bins as symlinks named after the bin (`zerocool-claude-mcp`), so any
+ * "am I the entry point" check on argv[1] is false there and the process
+ * exits before it serves anything. Library code lives in build.ts.
  */
-const log = (line) => {
-    process.stderr.write(`${line}\n`);
-};
-export async function buildServer(env, cwd) {
-    const gibson = await openGibson({ env, log });
-    const server = new McpServer({ name: "zerocool", version: "0.0.0" });
-    registerStatusTool(server, gibson);
-    registerComponentizeTool(server, cwd);
-    if (!gibson.session) {
-        registerFindingTools(server, gibson, localFindingsBackend(env.ZEROCOOL_FINDINGS_LOG ?? join(homedir(), ".zerocool", "findings.jsonl")));
-        return { server, gibson };
-    }
-    registerFindingTools(server, gibson, gibsonFindingsBackend(gibson));
-    registerMemoryTools(server, gibson);
-    registerEnrollTool(server, gibson.session);
-    registerDelegationTools(server, gibson.session);
-    const discovery = await registerGibsonTools(server, gibson.session);
-    log(discovery.note ? `[zerocool-claude] Gibson tool discovery: ${discovery.note}` : `[zerocool-claude] ${discovery.discovered} Gibson tool(s) registered`);
-    // Handoff for the hooks: the ambient block now, the live coordinates while
-    // the mission runs. Both fail open.
-    const dir = stateDir(env);
-    if (gibson.knowledge) {
-        const block = await ambientBlock(gibson.knowledge, env.ZEROCOOL_AMBIENT_QUERY ?? "memories, prior findings and security facts for this codebase");
-        if (block)
-            await writeAmbient(dir, cwd, block).catch((e) => log(`[zerocool-claude] ambient handoff failed: ${e.message}`));
-    }
-    if (gibson.live) {
-        const live = gibson.live;
-        const write = () => writeLive(dir, cwd, {
-            missionId: live.missionId,
-            workId: live.workId,
-            endpoint: live.harness.endpoint,
-            token: live.harness.token(),
-            insecure: env.GIBSON_CALLBACK_INSECURE === "1",
-            writtenAt: Date.now(),
-        }).catch((e) => log(`[zerocool-claude] live handoff failed: ${e.message}`));
-        await write();
-    }
-    return { server, gibson };
-}
 async function main() {
     const cwd = process.cwd();
     const { server, gibson } = await buildServer(process.env, cwd);
@@ -78,10 +27,7 @@ async function main() {
         process.on(sig, () => void close().finally(() => process.exit(0)));
     await server.connect(new StdioServerTransport());
 }
-const invokedDirectly = process.argv[1]?.endsWith("server.js") ?? false;
-if (invokedDirectly) {
-    main().catch((e) => {
-        log(`[zerocool-claude] fatal: ${e.message}`);
-        process.exit(1);
-    });
-}
+main().catch((e) => {
+    log(`[zerocool-claude] fatal: ${e.message}`);
+    process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeroroot-ai/zerocool-claude",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Claude Code plugin: Gibson platform integration (zerocool). The session is a live mission. Memory, knowledge, findings, tools, delegation. The model stays on your Claude subscription.",
   "license": "MIT",
   "repository": {