@zeroroot-ai/zerocool-claude 0.1.0

package/.claude-plugin/plugin.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
+  "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" },
+  "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"
+}

package/.mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "gibson": {
+      "command": "npx",
+      "args": ["--yes", "--package", "@zeroroot-ai/zerocool-claude@latest", "zerocool-claude-mcp"]
+    }
+  }
+}

package/dist/ambient.d.ts

@@ -0,0 +1,7 @@
+import { type KnowledgeSource } from "@zeroroot-ai/sdk";
+/**
+ * One GraphRAG lookup per session, injected by the SessionStart hook. A
+ * knowledge failure never breaks a start: the agent works without prior
+ * context, it just works less well.
+ */
+export declare function ambientBlock(knowledge: KnowledgeSource, seedQuery: string): Promise<string>;

package/dist/ambient.js

@@ -0,0 +1,18 @@
+import { formatKnowledgeForPrompt } from "@zeroroot-ai/sdk";
+/** How many hits the ambient block carries. Small: it is prompt overhead on every session. */
+const AMBIENT_LIMIT = 5;
+/**
+ * One GraphRAG lookup per session, injected by the SessionStart hook. A
+ * knowledge failure never breaks a start: the agent works without prior
+ * context, it just works less well.
+ */
+export async function ambientBlock(knowledge, seedQuery) {
+    try {
+        const hits = await knowledge.query({ text: seedQuery, topK: AMBIENT_LIMIT });
+        const body = formatKnowledgeForPrompt(hits);
+        return body ? `Prior context from the Gibson knowledge graph (recall for more):\n${body}` : "";
+    }
+    catch {
+        return "";
+    }
+}

package/dist/hook.d.ts

@@ -0,0 +1,23 @@
+#!/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

@@ -0,0 +1,72 @@
+#!/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 "";
+    }
+}
+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
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./mode.js";
+export * from "./session.js";
+export * from "./state.js";
+export * from "./ambient.js";
+export { buildServer } from "./server.js";

package/dist/index.js

@@ -0,0 +1,7 @@
+// @zeroroot-ai/zerocool-claude: library surface, for tests and for anyone who
+// embeds the server. The bins are server.ts and hook.ts.
+export * from "./mode.js";
+export * from "./session.js";
+export * from "./state.js";
+export * from "./ambient.js";
+export { buildServer } from "./server.js";

package/dist/mode.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Which of three postures this process runs in. Pure: decided from what the
+ * environment says and whether the host key exists, so it is testable and the
+ * reasons are printed once at start instead of discovered per tool call.
+ *
+ *  - `standalone`: no platform. Findings go to a local log, componentize works.
+ *  - `component`: checked in, no live mission. Reads and findings run under the
+ *    component grant. No memory writes: a memory is a World observation and
+ *    the World is written under a mission (gibson ADR-0012).
+ *  - `live`: checked in, and this session is a mission (gibson#1593, decision 9).
+ *
+ * The postures are one path with fewer tools at each step down, the same
+ * fail-open shape as the opencode plugin: a coding agent that cannot reach its
+ * platform is still a working coding agent.
+ */
+export type Mode = "standalone" | "component" | "live";
+export interface ModeDecision {
+    mode: Mode;
+    /** One line a person can act on. Empty when nothing is missing. */
+    reason: string;
+}
+export interface ModeInputs {
+    platformURL?: string;
+    bootstrapToken?: string;
+    hostKeyExists: boolean;
+    targetId?: string;
+}
+export declare function decideMode(env: ModeInputs, hostKeyPath: string): ModeDecision;

package/dist/mode.js

@@ -0,0 +1,21 @@
+export function decideMode(env, hostKeyPath) {
+    if (!env.platformURL) {
+        return { mode: "standalone", reason: "GIBSON_PLATFORM_URL is not set." };
+    }
+    if (!env.hostKeyExists && !env.bootstrapToken) {
+        return {
+            mode: "standalone",
+            reason: "GIBSON_PLATFORM_URL is set but this host has not checked in. Run `gibson login` then " +
+                "`gibson agent enroll`, and start once with GIBSON_BOOTSTRAP_TOKEN=<one-time token>. " +
+                `After that the host key at ${hostKeyPath} is enough.`,
+        };
+    }
+    if (!env.targetId) {
+        return {
+            mode: "component",
+            reason: "GIBSON_TARGET_ID is not set, so this session cannot be a live mission and cannot " +
+                "write memories. Create a target once (`gibson target create`) and set GIBSON_TARGET_ID.",
+        };
+    }
+    return { mode: "live", reason: "" };
+}

package/dist/server.d.ts

@@ -0,0 +1,7 @@
+#!/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;
+}>;

package/dist/server.js

@@ -0,0 +1,87 @@
+#!/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";
+/**
+ * @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).
+ */
+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);
+    log(`[zerocool-claude] ${describeGibson(gibson).replaceAll("\n", "; ")}`);
+    let closing = false;
+    const close = async () => {
+        if (closing)
+            return;
+        closing = true;
+        await clearLive(stateDir(process.env), cwd).catch(() => { });
+        await gibson.close().catch((e) => log(`[zerocool-claude] close: ${e.message}`));
+    };
+    // Claude Code ends the session by closing stdio. The mission ends with it.
+    process.stdin.on("close", () => void close().finally(() => process.exit(0)));
+    for (const sig of ["SIGINT", "SIGTERM"])
+        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);
+    });
+}

package/dist/session.d.ts

@@ -0,0 +1,28 @@
+import { connectGibson, startLiveMission, type GibsonSession, type KnowledgeSource, type LiveMission } from "@zeroroot-ai/sdk";
+import { type Mode } from "./mode.js";
+/** Everything the tools need, decided once at start. */
+export interface Gibson {
+    mode: Mode;
+    reason: string;
+    agentName: string;
+    hostKeyPath: string;
+    session?: GibsonSession;
+    live?: LiveMission;
+    knowledge?: KnowledgeSource;
+    /** Release the mission and the component registration. Idempotent. */
+    close(): Promise<void>;
+}
+export interface OpenGibsonOptions {
+    env: NodeJS.ProcessEnv;
+    log: (line: string) => void;
+    /** Test seams. */
+    connect?: typeof connectGibson;
+    start?: typeof startLiveMission;
+    hostKeyExists?: (path: string) => boolean;
+}
+export declare const DEFAULT_AGENT_NAME = "zerocool-claude";
+/**
+ * Check in, then make the session a live mission. Fails open at every step:
+ * a platform failure lands one posture down, never in a refusal to start.
+ */
+export declare function openGibson(opts: OpenGibsonOptions): Promise<Gibson>;

package/dist/session.js

@@ -0,0 +1,107 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { componentKnowledge, connectGibson, startLiveMission, taskKnowledge, } from "@zeroroot-ai/sdk";
+import { decideMode } from "./mode.js";
+export const DEFAULT_AGENT_NAME = "zerocool-claude";
+/**
+ * Check in, then make the session a live mission. Fails open at every step:
+ * a platform failure lands one posture down, never in a refusal to start.
+ */
+export async function openGibson(opts) {
+    const { env, log } = opts;
+    const hostKeyPath = env.GIBSON_HOST_KEY_PATH ?? join(homedir(), ".zerocool", "host.key");
+    const hostKeyExists = (opts.hostKeyExists ?? existsSync)(hostKeyPath);
+    const agentName = env.ZEROCOOL_AGENT_NAME ?? DEFAULT_AGENT_NAME;
+    const decision = decideMode({
+        platformURL: env.GIBSON_PLATFORM_URL,
+        bootstrapToken: env.GIBSON_BOOTSTRAP_TOKEN,
+        hostKeyExists,
+        targetId: env.GIBSON_TARGET_ID,
+    }, hostKeyPath);
+    const standalone = (reason) => ({
+        mode: "standalone",
+        reason,
+        agentName,
+        hostKeyPath,
+        close: async () => { },
+    });
+    if (decision.mode === "standalone") {
+        log(`[zerocool-claude] standalone: ${decision.reason}`);
+        return standalone(decision.reason);
+    }
+    // The bootstrap token is passed ONLY when no host key exists yet. Replaying a
+    // one-time token on every start would be rejected (gibson
+    // capabilitygrant_register.go:134-155).
+    const bootstrapToken = hostKeyExists ? undefined : env.GIBSON_BOOTSTRAP_TOKEN;
+    let session;
+    try {
+        session = await (opts.connect ?? connectGibson)({
+            platformURL: env.GIBSON_PLATFORM_URL,
+            daemonURL: env.GIBSON_DAEMON_URL,
+            bootstrapToken,
+            hostKeyPath,
+            agentName,
+            agentMode: env.GIBSON_AGENT_MODE ?? "interactive",
+            agent: { name: agentName, version: "0.0.0", capabilities: ["code"] },
+        });
+    }
+    catch (e) {
+        const reason = `Gibson connect failed: ${e.message}`;
+        log(`[zerocool-claude] ${reason}; continuing standalone`);
+        return standalone(reason);
+    }
+    log(`[zerocool-claude] checked in via ${hostKeyExists ? "the registered host key" : "first check-in"} ` +
+        `as ${agentName} (component_scope=${session.componentScope})`);
+    if (!hostKeyExists) {
+        log(`[zerocool-claude] host key written to ${hostKeyPath}; unset GIBSON_BOOTSTRAP_TOKEN, it is spent`);
+    }
+    const component = {
+        mode: "component",
+        reason: decision.reason,
+        agentName,
+        hostKeyPath,
+        session,
+        knowledge: componentKnowledge(session.clients.component),
+        close: async () => session.stop(),
+    };
+    if (decision.mode === "component") {
+        log(`[zerocool-claude] component posture: ${decision.reason}`);
+        return component;
+    }
+    let live;
+    try {
+        live = await (opts.start ?? startLiveMission)(session, {
+            agentName,
+            targetId: env.GIBSON_TARGET_ID,
+            harness: { insecure: env.GIBSON_CALLBACK_INSECURE === "1" },
+        });
+    }
+    catch (e) {
+        const reason = `live mission failed: ${e.message}`;
+        log(`[zerocool-claude] ${reason}; continuing as a component`);
+        return { ...component, reason };
+    }
+    log(`[zerocool-claude] live mission ${live.missionId} (work ${live.workId}); reads and writes use the task grant`);
+    let closed = false;
+    return {
+        mode: "live",
+        reason: "",
+        agentName,
+        hostKeyPath,
+        session,
+        live,
+        knowledge: taskKnowledge(live.harness),
+        close: async () => {
+            if (closed)
+                return;
+            closed = true;
+            try {
+                await live.end({ output: { ended: "session closed" } });
+            }
+            finally {
+                session.stop();
+            }
+        },
+    };
+}

package/dist/state.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The handoff between the MCP server and the hook processes.
+ *
+ * Hooks run as separate processes and cannot reach the MCP server's session.
+ * The server writes one small file per working directory: the ambient
+ * knowledge block for SessionStart, and the live-mission coordinates for
+ * SessionEnd. The file is the server's and lives beside the host key. The task
+ * grant in it is bounded (30 minutes, renewed by the server), and a hook that
+ * finds a stale one fails open.
+ */
+export interface LiveState {
+    missionId: string;
+    workId: string;
+    endpoint: string;
+    token: string;
+    insecure: boolean;
+    /** Unix ms. */
+    writtenAt: number;
+}
+export declare function stateDir(env?: NodeJS.ProcessEnv): string;
+export declare function keyFor(cwd: string): string;
+export declare function writeAmbient(dir: string, cwd: string, block: string): Promise<void>;
+export declare function readAmbient(dir: string, cwd: string): Promise<string>;
+export declare function writeLive(dir: string, cwd: string, state: LiveState): Promise<void>;
+export declare function readLive(dir: string, cwd: string): Promise<LiveState | undefined>;
+export declare function clearLive(dir: string, cwd: string): Promise<void>;

package/dist/state.js

@@ -0,0 +1,37 @@
+import { mkdir, readFile, writeFile, rm } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+export function stateDir(env = process.env) {
+    return env.ZEROCOOL_STATE_DIR ?? join(homedir(), ".zerocool", "claude");
+}
+export function keyFor(cwd) {
+    return createHash("sha256").update(cwd).digest("hex").slice(0, 16);
+}
+export async function writeAmbient(dir, cwd, block) {
+    await mkdir(dir, { recursive: true, mode: 0o700 });
+    await writeFile(join(dir, `ambient-${keyFor(cwd)}.md`), block, { encoding: "utf8", mode: 0o600 });
+}
+export async function readAmbient(dir, cwd) {
+    try {
+        return await readFile(join(dir, `ambient-${keyFor(cwd)}.md`), "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+export async function writeLive(dir, cwd, state) {
+    await mkdir(dir, { recursive: true, mode: 0o700 });
+    await writeFile(join(dir, `live-${keyFor(cwd)}.json`), JSON.stringify(state), { encoding: "utf8", mode: 0o600 });
+}
+export async function readLive(dir, cwd) {
+    try {
+        return JSON.parse(await readFile(join(dir, `live-${keyFor(cwd)}.json`), "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function clearLive(dir, cwd) {
+    await rm(join(dir, `live-${keyFor(cwd)}.json`), { force: true });
+}

package/dist/tools/componentize.d.ts

@@ -0,0 +1,18 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type ComponentSpec, type GibsonSession } from "@zeroroot-ai/sdk";
+type SpecArgs = {
+    kind: string;
+    name: string;
+    version: string;
+    image?: string;
+    language?: string;
+    capabilities?: string[];
+    methods?: string[];
+    input_message_type?: string;
+    output_message_type?: string;
+    config_schema_json?: string;
+};
+export declare function toSpec(args: SpecArgs): ComponentSpec;
+export declare function registerComponentizeTool(server: McpServer, cwd: string): void;
+export declare function registerEnrollTool(server: McpServer, session: GibsonSession): void;
+export {};

package/dist/tools/componentize.js

@@ -0,0 +1,80 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { buildComponentManifest, enrollComponent, enrollmentSupported, validateComponentSpec, } from "@zeroroot-ai/sdk";
+import { z } from "zod";
+import { failure, text } from "./result.js";
+/** Componentize and enroll (zerocool-plugins#11): produced artifacts join the fleet. */
+const KINDS = ["agent", "tool", "plugin"];
+const specSchema = {
+    kind: z.enum(KINDS).describe("Component kind."),
+    name: z.string().describe("Component name, as it will appear in the tenant registry."),
+    version: z.string().describe('Semantic version of the artifact, e.g. "0.1.0".'),
+    image: z.string().optional().describe("OCI image reference of the built artifact. Required before it can be dispatched."),
+    language: z.string().optional().describe("Language the artifact is written in, for the catalog."),
+    capabilities: z.array(z.string()).optional().describe('Agent capabilities. Required when kind is "agent".'),
+    methods: z.array(z.string()).optional().describe('Plugin method names. Required when kind is "plugin".'),
+    input_message_type: z.string().optional().describe('Fully-qualified proto input type. Required when kind is "tool".'),
+    output_message_type: z.string().optional().describe('Fully-qualified proto output type. Required when kind is "tool".'),
+    config_schema_json: z.string().optional().describe("JSON Schema for a plugin's configuration."),
+};
+export function toSpec(args) {
+    const metadata = {};
+    if (args.image)
+        metadata.image = args.image;
+    if (args.language)
+        metadata.language = args.language;
+    return {
+        kind: args.kind,
+        name: args.name,
+        version: args.version,
+        metadata,
+        ...(args.capabilities ? { capabilities: args.capabilities } : {}),
+        ...(args.methods ? { methods: args.methods } : {}),
+        ...(args.input_message_type ? { inputMessageType: args.input_message_type } : {}),
+        ...(args.output_message_type ? { outputMessageType: args.output_message_type } : {}),
+        ...(args.config_schema_json ? { configSchemaJson: args.config_schema_json } : {}),
+    };
+}
+function invalid(spec, problems) {
+    return failure("invalid component spec", `This artifact does not satisfy Gibson's ${spec.kind} contract:\n${problems.map((p) => `- ${p}`).join("\n")}`);
+}
+export function registerComponentizeTool(server, cwd) {
+    server.registerTool("gibson_componentize", {
+        description: "Turn a built artifact into a Gibson component manifest and write it to disk. Use this after " +
+            "building a tool or agent you want to add to the fleet. Validates the artifact against " +
+            "Gibson's component contract. Does not build or push an image.",
+        inputSchema: { ...specSchema, path: z.string().optional().describe('Where to write the manifest. Defaults to "gibson-component.json".') },
+    }, async (args) => {
+        const spec = toSpec(args);
+        const problems = validateComponentSpec(spec);
+        if (problems.length > 0)
+            return invalid(spec, problems);
+        const manifest = buildComponentManifest(spec);
+        const target = resolve(cwd, args.path ?? "gibson-component.json");
+        await mkdir(dirname(target), { recursive: true });
+        await writeFile(target, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+        const missingImage = spec.metadata?.image
+            ? ""
+            : "\n\nNo image reference was given. Build and push an image, then re-run with image=<oci-ref> before you enroll. A component without an image cannot be dispatched.";
+        return text(`${spec.kind} manifest: ${spec.name}`, `Wrote a valid ${spec.kind} manifest for ${spec.name}@${spec.version} to ${target}.${missingImage}`);
+    });
+}
+export function registerEnrollTool(server, session) {
+    server.registerTool("gibson_enroll_component", {
+        description: "Register a produced artifact with Gibson so it joins the tenant fleet. Run gibson_componentize first to check the artifact against the component contract.",
+        inputSchema: specSchema,
+    }, async (args) => {
+        const spec = toSpec(args);
+        const problems = validateComponentSpec(spec);
+        if (problems.length > 0)
+            return invalid(spec, problems);
+        try {
+            const result = await enrollComponent(session.clients.component, spec);
+            const { reason } = enrollmentSupported();
+            return text(`enrolled ${spec.name}`, `Registered ${spec.kind} ${spec.name}@${spec.version} as instance ${result.instanceId}.\n\nNote: ${reason}. It is visible in the tenant registry, but it drops out when heartbeats stop (every ${Math.round(result.heartbeatIntervalMs / 1000)}s) unless the artifact itself runs and checks in.`);
+        }
+        catch (e) {
+            return failure("enroll failed", e.message);
+        }
+    });
+}

package/dist/tools/delegate.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type GibsonSession } from "@zeroroot-ai/sdk";
+/** Delegation and missions (zerocool-plugins#10): the network of agents in the tenant. */
+export declare function registerDelegationTools(server: McpServer, session: GibsonSession): void;

package/dist/tools/delegate.js

@@ -0,0 +1,108 @@
+import { cancelMission, createMission, delegateToAgent, getMissionResults, getMissionStatus, isSeamUnavailable, listAgents, newTask, runMission, waitMission, } from "@zeroroot-ai/sdk";
+import { z } from "zod";
+import { failure, text } from "./result.js";
+const UNWIRED = "This daemon has no agent delegation or mission management wired (gibson#1186). Complete the work directly instead.";
+/** Delegation and missions (zerocool-plugins#10): the network of agents in the tenant. */
+export function registerDelegationTools(server, session) {
+    const component = session.clients.component;
+    const seam = (e, what) => (isSeamUnavailable(e) ? text(`${what} unavailable`, UNWIRED) : failure(`${what} failed`, e.message));
+    server.registerTool("gibson_list_agents", {
+        description: "List the Gibson agents in this tenant that work can be delegated to, with their capabilities and the target types they handle.",
+        inputSchema: {},
+    }, async () => {
+        const { agents, unavailable } = await listAgents(component);
+        if (unavailable)
+            return text("delegation unavailable", UNWIRED);
+        if (agents.length === 0)
+            return text("no agents", "No agents are registered for this tenant.");
+        const lines = agents.map((a) => {
+            const caps = a.capabilities.length > 0 ? `, capabilities: ${a.capabilities.join(", ")}` : "";
+            const targets = a.targetTypes.length > 0 ? `, targets: ${a.targetTypes.join(", ")}` : "";
+            return `- ${a.name} (${a.version}) ${a.description}${caps}${targets}`;
+        });
+        return text(`${agents.length} agent${agents.length === 1 ? "" : "s"}`, lines.join("\n"));
+    });
+    server.registerTool("gibson_delegate", {
+        description: "Delegate a sub-task to another Gibson agent and wait for its result. Use gibson_list_agents " +
+            "first to pick an agent whose capabilities match the task.",
+        inputSchema: {
+            agent: z.string().describe("Name of the agent to delegate to."),
+            goal: z.string().describe("What the delegate should accomplish."),
+            context: z.record(z.string(), z.any()).optional().describe("Target details, prior findings, or other context the delegate needs."),
+            max_turns: z.number().optional().describe("Cap on the delegate's LLM turns."),
+            allowed_tools: z.array(z.string()).optional().describe("Restrict the delegate to these tools."),
+        },
+    }, async (args) => {
+        try {
+            const task = newTask(args.goal, {
+                ...(args.context ? { Context: args.context } : {}),
+                ...(args.max_turns || args.allowed_tools
+                    ? { Constraints: { ...(args.max_turns ? { MaxTurns: args.max_turns } : {}), ...(args.allowed_tools ? { AllowedTools: args.allowed_tools } : {}) } }
+                    : {}),
+            });
+            const result = await delegateToAgent(component, args.agent, task);
+            return text(`${args.agent}: ${result.Status}`, JSON.stringify(result, null, 2));
+        }
+        catch (e) {
+            return seam(e, "delegation");
+        }
+    });
+    server.registerTool("gibson_create_mission", {
+        description: "Create a Gibson mission from a mission definition, bound to a target. The mission is not started. Call gibson_run_mission to queue it.",
+        inputSchema: {
+            definition: z.record(z.string(), z.any()).describe("Mission definition object (gibson.mission.v1.MissionDefinition as JSON)."),
+            target_id: z.string().describe("Identifier of the target the mission runs against."),
+            opts: z.record(z.string(), z.any()).optional().describe("Optional mission creation options."),
+        },
+    }, async (args) => {
+        try {
+            const info = await createMission(component, args.definition, args.target_id, args.opts);
+            return text("mission created", JSON.stringify(info, null, 2));
+        }
+        catch (e) {
+            return seam(e, "create mission");
+        }
+    });
+    server.registerTool("gibson_run_mission", { description: "Queue a created Gibson mission for execution. Returns as soon as it is queued.", inputSchema: { mission_id: z.string().describe("Mission to run.") } }, async (args) => {
+        try {
+            await runMission(component, args.mission_id);
+            return text("queued", `Mission ${args.mission_id} is queued.`);
+        }
+        catch (e) {
+            return seam(e, "run mission");
+        }
+    });
+    server.registerTool("gibson_mission_status", {
+        description: "Check a Gibson mission's status, or block until it finishes. Use wait=true only when you intend to stop and wait for the result.",
+        inputSchema: {
+            mission_id: z.string().describe("Mission to inspect."),
+            wait: z.boolean().optional().describe("Block until the mission reaches a terminal state."),
+            timeout_ms: z.number().optional().describe("How long to block when wait is true. Defaults to 5 minutes."),
+        },
+    }, async (args) => {
+        try {
+            const status = args.wait ? await waitMission(component, args.mission_id, args.timeout_ms) : await getMissionStatus(component, args.mission_id);
+            return text(`mission ${args.mission_id}`, JSON.stringify(status, null, 2));
+        }
+        catch (e) {
+            return seam(e, "mission status");
+        }
+    });
+    server.registerTool("gibson_mission_results", { description: "Read the final results of a completed Gibson mission.", inputSchema: { mission_id: z.string().describe("Mission whose results to read.") } }, async (args) => {
+        try {
+            return text(`results ${args.mission_id}`, JSON.stringify(await getMissionResults(component, args.mission_id), null, 2));
+        }
+        catch (e) {
+            return seam(e, "mission results");
+        }
+    });
+    server.registerTool("gibson_cancel_mission", { description: "Request cancellation of a running Gibson mission.", inputSchema: { mission_id: z.string().describe("Mission to cancel.") } }, async (args) => {
+        try {
+            await cancelMission(component, args.mission_id);
+            return text("cancel requested", `Cancellation of ${args.mission_id} is requested.`);
+        }
+        catch (e) {
+            return seam(e, "cancel mission");
+        }
+    });
+}

package/dist/tools/findings.d.ts

@@ -0,0 +1,18 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type Finding } from "@zeroroot-ai/sdk";
+import type { Gibson } from "../session.js";
+export interface FindingsBackend {
+    submit(f: Finding): Promise<string>;
+    describe(): string;
+}
+/** Platform backend: the finding lands in the tenant knowledge graph. */
+export declare function gibsonFindingsBackend(g: Gibson): FindingsBackend;
+/** Standalone backend: an append-only JSONL log. */
+export declare function localFindingsBackend(path: string): FindingsBackend;
+/**
+ * Findings: emit what the agent discovers (zerocool-plugins#7). The model
+ * calls this when it finds something. Nothing here emits on its own: a file
+ * edit is not a security finding, and inventing one fills the tenant graph
+ * with noise a person then has to triage.
+ */
+export declare function registerFindingTools(server: McpServer, g: Gibson, backend: FindingsBackend): void;

package/dist/tools/findings.js

@@ -0,0 +1,69 @@
+import { appendFile, mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import { newFinding, submitFinding } from "@zeroroot-ai/sdk";
+import { z } from "zod";
+import { failure, text } from "./result.js";
+const SEVERITIES = ["critical", "high", "medium", "low", "info"];
+/** Platform backend: the finding lands in the tenant knowledge graph. */
+export function gibsonFindingsBackend(g) {
+    const component = g.session.clients.component;
+    return { submit: (f) => submitFinding(component, f), describe: () => "the tenant Gibson graph" };
+}
+/** Standalone backend: an append-only JSONL log. */
+export function localFindingsBackend(path) {
+    return {
+        submit: async (f) => {
+            await mkdir(dirname(path), { recursive: true });
+            await appendFile(path, `${JSON.stringify(f)}\n`, "utf8");
+            return f.id;
+        },
+        describe: () => path,
+    };
+}
+/**
+ * Findings: emit what the agent discovers (zerocool-plugins#7). The model
+ * calls this when it finds something. Nothing here emits on its own: a file
+ * edit is not a security finding, and inventing one fills the tenant graph
+ * with noise a person then has to triage.
+ */
+export function registerFindingTools(server, g, backend) {
+    server.registerTool("submit_finding", {
+        description: "Record a security finding in the Gibson knowledge graph. Use this when you discover a " +
+            "real vulnerability, misconfiguration or notable security fact about the target or " +
+            "codebase. Not for progress updates or general observations.",
+        inputSchema: {
+            title: z.string().describe("One-line summary of the finding."),
+            description: z.string().describe("What the issue is, where it is, and why it matters."),
+            category: z.string().describe('Type of issue, e.g. "injection", "auth", "secrets-exposure", "misconfiguration".'),
+            severity: z.enum(SEVERITIES).describe("Impact level of the finding."),
+            confidence: z.number().min(0).max(1).optional().describe("How certain you are, from 0 to 1. Defaults to 1."),
+            evidence: z.string().optional().describe("A code excerpt, request/response, or log line."),
+            remediation: z.string().optional().describe("How to fix or mitigate the issue."),
+            target_id: z.string().optional().describe("Identifier of the affected target or component."),
+            tags: z.array(z.string()).optional().describe("Labels for filtering."),
+        },
+    }, async (args) => {
+        const finding = newFinding({
+            title: args.title,
+            description: args.description,
+            category: args.category,
+            severity: args.severity,
+            confidence: args.confidence,
+            missionID: g.live?.missionId ?? "",
+            agentName: g.agentName,
+            ...(args.remediation ? { remediation: args.remediation } : {}),
+            ...(args.target_id ? { targetID: args.target_id } : {}),
+            ...(args.tags ? { tags: args.tags } : {}),
+            ...(args.evidence
+                ? { evidence: [{ type: "text", title: "evidence", content: args.evidence, timestamp: new Date().toISOString() }] }
+                : {}),
+        });
+        try {
+            const id = await backend.submit(finding);
+            return text(`${args.severity}: ${args.title}`, `Recorded finding ${id} in ${backend.describe()}.`);
+        }
+        catch (e) {
+            return failure("submit_finding failed", e.message);
+        }
+    });
+}

package/dist/tools/gibson-tools.d.ts

@@ -0,0 +1,20 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type GibsonSession, type GibsonTool } from "@zeroroot-ai/sdk";
+/**
+ * Gibson tools and plugins as MCP tools (zerocool-plugins#9).
+ *
+ * Discovered tools register individually, one MCP tool per Gibson tool, named
+ * `gibson_<tool>`, so the model sees each with its own description. The
+ * catalog carries no JSON Schema, only a proto message type name, so a wrapper
+ * takes one free-form `input` object and names the expected type. A generic
+ * `gibson_call_tool` is always present: discovery is `Unimplemented` on some
+ * daemons (gibson#1186), and the operator may know a tool by name.
+ */
+export declare function toolKey(name: string): string;
+export declare function registerDiscoveredTool(server: McpServer, session: GibsonSession, t: GibsonTool): void;
+export interface DiscoveryOutcome {
+    discovered: number;
+    note?: string;
+}
+/** Register the generic tools, then one tool per discovered Gibson tool. */
+export declare function registerGibsonTools(server: McpServer, session: GibsonSession): Promise<DiscoveryOutcome>;

package/dist/tools/gibson-tools.js

@@ -0,0 +1,89 @@
+import { callGibsonTool, listGibsonPlugins, listGibsonTools, queryGibsonPlugin, } from "@zeroroot-ai/sdk";
+import { z } from "zod";
+import { failure, text } from "./result.js";
+/**
+ * Gibson tools and plugins as MCP tools (zerocool-plugins#9).
+ *
+ * Discovered tools register individually, one MCP tool per Gibson tool, named
+ * `gibson_<tool>`, so the model sees each with its own description. The
+ * catalog carries no JSON Schema, only a proto message type name, so a wrapper
+ * takes one free-form `input` object and names the expected type. A generic
+ * `gibson_call_tool` is always present: discovery is `Unimplemented` on some
+ * daemons (gibson#1186), and the operator may know a tool by name.
+ */
+export function toolKey(name) {
+    return `gibson_${name.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+}
+function formatToolResult(name, result) {
+    if (result.error) {
+        return failure(`${name} failed`, `Gibson tool ${name} failed [${result.error.code}]: ${result.error.message}${result.error.retryable ? " (retryable)" : ""}`);
+    }
+    const body = typeof result.output === "string" ? result.output : JSON.stringify(result.output, null, 2);
+    return text(name, body ?? "(no output)");
+}
+export function registerDiscoveredTool(server, session, t) {
+    const schemaNote = t.inputMessageType ? ` Input must match the Gibson message type ${t.inputMessageType}.` : "";
+    server.registerTool(toolKey(t.name), {
+        description: `${t.description || `Gibson tool "${t.name}"`}${schemaNote} Runs through the Gibson harness (authorized and metered).`,
+        inputSchema: {
+            input: z.record(z.string(), z.any()).describe(`Input object for the ${t.name} tool.`),
+            timeout_ms: z.number().optional().describe("Per-call timeout in milliseconds."),
+        },
+    }, async (args) => formatToolResult(t.name, await callGibsonTool(session.clients.component, {
+        name: t.name,
+        input: args.input,
+        ...(args.timeout_ms ? { timeoutMs: args.timeout_ms } : {}),
+    })));
+}
+/** Register the generic tools, then one tool per discovered Gibson tool. */
+export async function registerGibsonTools(server, session) {
+    const component = session.clients.component;
+    server.registerTool("gibson_call_tool", {
+        description: "Invoke a Gibson tool by name through the harness. Use this when you know a tool's name " +
+            "but it is not in your tool list. Gibson tool discovery is not available on every daemon.",
+        inputSchema: {
+            name: z.string().describe("Registered Gibson tool name."),
+            input: z.record(z.string(), z.any()).describe("Input object matching the tool's input schema."),
+            timeout_ms: z.number().optional().describe("Per-call timeout in milliseconds."),
+        },
+    }, async (args) => formatToolResult(args.name, await callGibsonTool(component, { name: args.name, input: args.input, ...(args.timeout_ms ? { timeoutMs: args.timeout_ms } : {}) })));
+    server.registerTool("gibson_list_tools", {
+        description: "List the Gibson tools and plugins available to this tenant, with the input message type each tool expects.",
+        inputSchema: {},
+    }, async () => {
+        const [discovery, plugins] = await Promise.all([listGibsonTools(component), listGibsonPlugins(component).catch(() => [])]);
+        const lines = [];
+        if (discovery.unavailable)
+            lines.push(`Tool discovery is unavailable: ${discovery.unavailable}.`);
+        else if (discovery.tools.length === 0)
+            lines.push("No Gibson tools are registered for this tenant.");
+        else {
+            lines.push("Gibson tools:");
+            for (const t of discovery.tools) {
+                lines.push(`- ${t.name} (${t.version}): ${t.description || "no description"}`);
+                if (t.inputMessageType)
+                    lines.push(`    input: ${t.inputMessageType}`);
+            }
+        }
+        if (plugins.length > 0) {
+            lines.push("", "Gibson plugins:");
+            for (const p of plugins)
+                lines.push(`- ${p.name} (${p.version}): ${p.description || "no description"}`);
+        }
+        return text("", lines.join("\n"));
+    });
+    server.registerTool("gibson_query_plugin", {
+        description: "Call a method on a tenant Gibson plugin (a connector or an integration) through the harness.",
+        inputSchema: {
+            plugin: z.string().describe("Plugin name."),
+            method: z.string().describe("Method name."),
+            params: z.record(z.string(), z.any()).optional().describe("Method parameters."),
+        },
+    }, async (args) => formatToolResult(`${args.plugin}.${args.method}`, await queryGibsonPlugin(component, { plugin: args.plugin, method: args.method, params: args.params ?? {} })));
+    const discovery = await listGibsonTools(component);
+    if (discovery.unavailable)
+        return { discovered: 0, note: discovery.unavailable };
+    for (const t of discovery.tools)
+        registerDiscoveredTool(server, session, t);
+    return { discovered: discovery.tools.length };
+}

package/dist/tools/memory.d.ts

@@ -0,0 +1,14 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { Gibson } from "../session.js";
+/**
+ * Memory and knowledge (gibson#1593, decisions 9 and 10).
+ *
+ * `remember` is `Observe(MemoryObservation)`: the memory lands in the tenant
+ * World as a Timeline event and the projector writes the graph node. It exists
+ * only in the live posture, because the World is written under a mission.
+ *
+ * `recall` reads the graph. In the live posture it reads as the task, in the
+ * component posture as the component. The model decides when a lookup is worth
+ * a round trip, and the query it writes beats anything derived from the prompt.
+ */
+export declare function registerMemoryTools(server: McpServer, g: Gibson): void;

package/dist/tools/memory.js

@@ -0,0 +1,96 @@
+import { formatKnowledgeForPrompt, isSeamUnavailable, remember, WorldEntityKind } from "@zeroroot-ai/sdk";
+import { z } from "zod";
+import { failure, text } from "./result.js";
+/**
+ * Memory and knowledge (gibson#1593, decisions 9 and 10).
+ *
+ * `remember` is `Observe(MemoryObservation)`: the memory lands in the tenant
+ * World as a Timeline event and the projector writes the graph node. It exists
+ * only in the live posture, because the World is written under a mission.
+ *
+ * `recall` reads the graph. In the live posture it reads as the task, in the
+ * component posture as the component. The model decides when a lookup is worth
+ * a round trip, and the query it writes beats anything derived from the prompt.
+ */
+export function registerMemoryTools(server, g) {
+    if (g.knowledge) {
+        const knowledge = g.knowledge;
+        server.registerTool("recall", {
+            description: "Search this tenant's Gibson knowledge graph for memories, prior findings, targets and " +
+                "security facts recorded by earlier sessions and runs. Use it before you start on an " +
+                "unfamiliar area, or to check whether something was already recorded.",
+            inputSchema: {
+                query: z.string().describe("What to look for, in natural language."),
+                limit: z.number().int().min(1).max(50).optional().describe("Maximum hits. Defaults to 10."),
+                node_types: z
+                    .array(z.string())
+                    .optional()
+                    .describe('Restrict to node types, e.g. ["Observation"] for memories or ["Finding"].'),
+            },
+        }, async (args) => {
+            let hits;
+            try {
+                hits = await knowledge.query({
+                    text: args.query,
+                    topK: args.limit ?? 10,
+                    ...(args.node_types ? { nodeTypes: args.node_types } : {}),
+                });
+            }
+            catch (e) {
+                if (isSeamUnavailable(e)) {
+                    return text("recall unavailable", "The Gibson knowledge graph is not available on this daemon (gibson#1186). Continue without prior context.");
+                }
+                return failure("recall failed", e.message);
+            }
+            if (hits.length === 0)
+                return text("no matches", `Nothing in the tenant graph matches "${args.query}".`);
+            return text(`${hits.length} match${hits.length === 1 ? "" : "es"}`, formatKnowledgeForPrompt(hits));
+        });
+    }
+    if (g.live) {
+        const harness = g.live.harness;
+        server.registerTool("remember", {
+            description: "Keep a fact for later sessions, in this tenant's Gibson knowledge graph. Use it for a " +
+                "convention, a decision, a layout fact or a gotcha you would want back next time. Not for " +
+                "progress notes. A security finding goes to submit_finding instead.",
+            inputSchema: {
+                text: z.string().describe("The fact, in one or two sentences."),
+                kind: z.string().optional().describe('A short category: "convention", "decision", "layout", "gotcha".'),
+                tags: z.array(z.string()).optional().describe("Lower-case labels that help recall."),
+                source_ref: z.string().optional().describe("Where it came from: a path, a URL, or a work id."),
+            },
+        }, async (args) => {
+            try {
+                await remember(harness, { text: args.text, kind: args.kind, tags: args.tags, sourceRef: args.source_ref });
+            }
+            catch (e) {
+                return failure("remember failed", e.message);
+            }
+            return text("remembered", `Recorded in the tenant graph under mission ${g.live.missionId}.`);
+        });
+        server.registerTool("world_view", {
+            description: "Read this mission's slice of the tenant World: the hosts, domains, credentials, accounts " +
+                "and findings the platform knows about the target. Pass handles from a previous call in " +
+                "focus to zoom into entities.",
+            inputSchema: {
+                focus: z.array(z.string()).optional().describe("Entity handles from an earlier world_view call."),
+            },
+        }, async (args) => {
+            try {
+                const res = await harness.client.worldView({ context: harness.context, focus: args.focus ?? [] });
+                if (res.error)
+                    return failure("world_view refused", res.error.message);
+                if (res.entities.length === 0)
+                    return text("empty slice", "The World holds nothing for this target yet.");
+                const lines = res.entities.map((e) => {
+                    const attrs = Object.entries(e.attributes).map(([k, v]) => `${k}=${v}`).join(", ");
+                    return `- [${e.handle}] ${WorldEntityKind[e.kind] ?? e.kind} ${e.label}${attrs ? ` (${attrs})` : ""}`;
+                });
+                return text(`${res.entities.length} entit${res.entities.length === 1 ? "y" : "ies"}${res.truncated ? " (truncated)" : ""}`, lines.join("\n"));
+            }
+            catch (e) {
+                return failure("world_view failed", e.message);
+            }
+        });
+    }
+}

package/dist/tools/result.d.ts

@@ -0,0 +1,5 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+/** One text block. MCP has no title/metadata split, so the title leads the text. */
+export declare function text(title: string, body: string, isError?: boolean): CallToolResult;
+/** Error text for a failure the model can act on. */
+export declare function failure(title: string, body: string): CallToolResult;

package/dist/tools/result.js

@@ -0,0 +1,8 @@
+/** One text block. MCP has no title/metadata split, so the title leads the text. */
+export function text(title, body, isError = false) {
+    return { content: [{ type: "text", text: title ? `${title}\n\n${body}` : body }], ...(isError ? { isError } : {}) };
+}
+/** Error text for a failure the model can act on. */
+export function failure(title, body) {
+    return text(title, body, true);
+}

package/dist/tools/status.d.ts

@@ -0,0 +1,5 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { Gibson } from "../session.js";
+/** One tool that says what posture this session runs in and why. */
+export declare function registerStatusTool(server: McpServer, g: Gibson): void;
+export declare function describeGibson(g: Gibson): string;

package/dist/tools/status.js

@@ -0,0 +1,17 @@
+import { text } from "./result.js";
+/** One tool that says what posture this session runs in and why. */
+export function registerStatusTool(server, g) {
+    server.registerTool("gibson_status", { description: "Show how this session is connected to Gibson: standalone, component, or a live mission, and what is missing if anything.", inputSchema: {} }, async () => text("", describeGibson(g)));
+}
+export function describeGibson(g) {
+    const lines = [`posture: ${g.mode}`, `agent: ${g.agentName}`];
+    if (g.session)
+        lines.push(`component_scope: ${g.session.componentScope}`, `instance: ${g.session.instance.current()}`);
+    if (g.live) {
+        const exp = g.live.harness.expiresAt();
+        lines.push(`mission: ${g.live.missionId}`, `work: ${g.live.workId}`, `grant expires: ${exp ? new Date(exp).toISOString() : "unknown"}`);
+    }
+    if (g.reason)
+        lines.push(`note: ${g.reason}`);
+    return lines.join("\n");
+}

package/hooks/hooks.json

@@ -0,0 +1,30 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume|clear",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx",
+            "args": ["--yes", "--package", "@zeroroot-ai/zerocool-claude@latest", "zerocool-claude-hook"],
+            "timeout": 30,
+            "statusMessage": "Loading Gibson context"
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx",
+            "args": ["--yes", "--package", "@zeroroot-ai/zerocool-claude@latest", "zerocool-claude-hook"],
+            "timeout": 60
+          }
+        ]
+      }
+    ]
+  }
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@zeroroot-ai/zerocool-claude",
+  "version": "0.1.0",
+  "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": {
+    "type": "git",
+    "url": "git+https://github.com/zeroroot-ai/zerocool-plugins.git",
+    "directory": "packages/claude-gibson"
+  },
+  "homepage": "https://github.com/zeroroot-ai/zerocool-plugins",
+  "bugs": "https://github.com/zeroroot-ai/zerocool-plugins/issues",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    ".claude-plugin",
+    ".mcp.json",
+    "hooks"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "tsc -p tsconfig.test.json && node --test \"dist-test/**/*.test.js\""
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "@zeroroot-ai/sdk": "^0.6.1",
+    "zod": "^4.4.3"
+  },
+  "bin": {
+    "zerocool-claude-mcp": "dist/server.js",
+    "zerocool-claude-hook": "dist/hook.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  }
+}