@zeroroot-ai/zerocool 0.8.0 → 0.9.0

package/dist/findings.d.ts

@@ -1,5 +1,25 @@
-import type { ToolDefinition } from "@opencode-ai/plugin";
 import { type Finding, type GibsonSession, type TaskHarness } from "@zeroroot-ai/sdk";
+/**
+ * Findings — emit what the agent discovers into the tenant World
+ * (zerocool-plugins#7).
+ *
+ * One code path, two backends. With a Gibson session a finding goes to the
+ * tenant graph through `ComponentService.SubmitFinding` under the agent's
+ * COMPONENT identity; standalone it is appended to a local JSONL log. The tool
+ * the model sees is identical either way, so a prompt that works standalone
+ * works on the platform.
+ *
+ * The agent decides what is a finding. Nothing here invents findings from file
+ * edits or message traffic: a `file.edited` event is not a security finding, and
+ * auto-emitting one would fill the tenant graph with noise that a human then has
+ * to triage.
+ *
+ * The `submit_finding` tool the model calls lives in the Gibson MCP server now
+ * (ADR-0008). What is left here is the backend the dispatched task kinds use
+ * when they submit a finding themselves, with no model in the loop:
+ * `source-analysis` triages semgrep candidates, and `dispatch` reports them
+ * under the task grant.
+ */
 export interface FindingsBackend {
     /** Submit a finding; returns the identifier it was recorded under. */
     submit(f: Finding): Promise<string>;
@@ -32,4 +52,3 @@ export interface SessionContext {
  * `agent_name` is fixed to "zerocool" rather than exposed as an argument — a
  * model must not be able to attribute its findings to another agent.
  */
-export declare function submitFindingTool(backend: FindingsBackend, context: SessionContext): ToolDefinition;

package/dist/findings.js

@@ -1,24 +1,6 @@
-import { tool } from "@opencode-ai/plugin";
-import { newFinding, submitFinding, } from "@zeroroot-ai/sdk";
+import { submitFinding, } from "@zeroroot-ai/sdk";
 import { appendFile, mkdir } from "node:fs/promises";
 import { dirname } from "node:path";
-/**
- * Findings — emit what the agent discovers into the tenant World
- * (zerocool-plugins#7).
- *
- * One code path, two backends. With a Gibson session a finding goes to the
- * tenant graph through `ComponentService.SubmitFinding` under the agent's
- * COMPONENT identity; standalone it is appended to a local JSONL log. The tool
- * the model sees is identical either way, so a prompt that works standalone
- * works on the platform.
- *
- * The agent decides what is a finding. Nothing here invents findings from file
- * edits or message traffic: a `file.edited` event is not a security finding, and
- * auto-emitting one would fill the tenant graph with noise that a human then has
- * to triage. The `event` hook only tracks session context used to stamp findings
- * with provenance.
- */
-const SEVERITIES = ["critical", "high", "medium", "low", "info"];
 /** Platform backend — findings land in the tenant knowledge graph. */
 export function gibsonFindingsBackend(session) {
     return {
@@ -82,64 +64,3 @@ export function localFindingsBackend(path) {
  * `agent_name` is fixed to "zerocool" rather than exposed as an argument — a
  * model must not be able to attribute its findings to another agent.
  */
-export function submitFindingTool(backend, context) {
-    const z = tool.schema;
-    return tool({
-        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.",
-        args: {
-            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("Supporting evidence — 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 execute(args, ctx) {
-            const finding = newFinding({
-                title: args.title,
-                description: args.description,
-                category: args.category,
-                severity: args.severity,
-                confidence: args.confidence,
-                missionID: context.sessionID ?? ctx.sessionID,
-                agentName: "zerocool",
-                ...(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(),
-                            },
-                        ],
-                    }
-                    : {}),
-            });
-            const id = await backend.submit(finding);
-            return {
-                title: `${args.severity}: ${args.title}`,
-                output: `Recorded finding ${id} in ${backend.describe()}.`,
-                metadata: { finding_id: id, severity: args.severity, category: args.category },
-            };
-        },
-    });
-}

package/dist/index.d.ts

@@ -20,11 +20,17 @@ import type { Plugin } from "@opencode-ai/plugin";
  *   - checks in as a Gibson component (Capability Grant + RegisterComponent + heartbeat),
  *   - starts a local OpenAI-compatible shim over the harness,
  *   - auto-registers a zero-config `gibson` provider via the `config` hook (#6),
- *   - emits findings into the tenant World (#7),
- *   - reads the tenant knowledge graph (#8),
- *   - exposes Gibson tools and plugins as opencode tools (#9),
- *   - delegates to other agents and drives missions (#10),
- *   - enrolls produced artifacts into the fleet (#11).
+ *   - reads the tenant knowledge graph and injects an ambient block (#8).
+ *
+ * THE TOOLS ARE NOT HERE. Every Gibson tool — findings, knowledge, delegation,
+ * componentize, and one per RPC of every SDK service — comes from the Gibson
+ * MCP server, which this plugin registers in opencode's own `mcp` block
+ * (ADR-0008). opencode spawns it, so the tools reach the model the same way
+ * they reach Claude Code, Cursor and the rest, and a new SDK release adds
+ * tools with no change here.
+ *
+ * What is left is what only a plugin can do: the model provider, the ambient
+ * knowledge injection, and the session id.
  *
  * The plugin fails open throughout. A coding agent that cannot reach its
  * platform must still be a working coding agent, so every platform failure

package/dist/index.js

@@ -2,12 +2,9 @@ import { connectGibson, startCompletionsShim } from "@zeroroot-ai/sdk";
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { componentizeTool, enrollComponentTool } from "./componentize.js";
-import { delegationTools } from "./delegate.js";
-import { buildGibsonTools } from "./gibson-tools.js";
-import { ambientKnowledge, recallTool } from "./knowledge.js";
+import { ambientKnowledge } from "./knowledge.js";
 import { selectKnowledgeSource } from "./knowledge-source.js";
-import { gibsonFindingsBackend, localFindingsBackend, submitFindingTool, } from "./findings.js";
+import { gibsonMcpServer } from "./mcp-config.js";
 /**
  * @zeroroot-ai/zerocool — the main Gibson plugin.
  *
@@ -29,11 +26,17 @@ import { gibsonFindingsBackend, localFindingsBackend, submitFindingTool, } from
  *   - checks in as a Gibson component (Capability Grant + RegisterComponent + heartbeat),
  *   - starts a local OpenAI-compatible shim over the harness,
  *   - auto-registers a zero-config `gibson` provider via the `config` hook (#6),
- *   - emits findings into the tenant World (#7),
- *   - reads the tenant knowledge graph (#8),
- *   - exposes Gibson tools and plugins as opencode tools (#9),
- *   - delegates to other agents and drives missions (#10),
- *   - enrolls produced artifacts into the fleet (#11).
+ *   - reads the tenant knowledge graph and injects an ambient block (#8).
+ *
+ * THE TOOLS ARE NOT HERE. Every Gibson tool — findings, knowledge, delegation,
+ * componentize, and one per RPC of every SDK service — comes from the Gibson
+ * MCP server, which this plugin registers in opencode's own `mcp` block
+ * (ADR-0008). opencode spawns it, so the tools reach the model the same way
+ * they reach Claude Code, Cursor and the rest, and a new SDK release adds
+ * tools with no change here.
+ *
+ * What is left is what only a plugin can do: the model provider, the ambient
+ * knowledge injection, and the session id.
  *
  * The plugin fails open throughout. A coding agent that cannot reach its
  * platform must still be a working coding agent, so every platform failure
@@ -57,12 +60,11 @@ export const GibsonPlugin = async () => {
     // the operator to keep a spent credential in their environment forever.
     const checkedIn = existsSync(hostKeyPath);
     const bootstrapToken = checkedIn ? undefined : process.env.GIBSON_BOOTSTRAP_TOKEN;
-    // Standalone: findings go to a local log, and componentize still works —
-    // producing a manifest needs no platform.
-    const standaloneTools = () => ({
-        submit_finding: submitFindingTool(localFindingsBackend(process.env.ZEROCOOL_FINDINGS_LOG ?? join(homedir(), ".zerocool", "findings.jsonl")), context),
-        gibson_componentize: componentizeTool(),
-    });
+    // Standalone: the MCP server still runs. It decides its own posture from
+    // what is present, reports it through gibson_status, and offers the tools
+    // that need no platform. A coding agent that cannot reach Gibson is still a
+    // working coding agent.
+    const standalone = () => ({ config: async (config) => addMcpServer(config) });
     // Standalone unless we can authenticate: a platform URL plus either a token
     // for the first check-in or an already-registered host key.
     if (!platformURL || (!bootstrapToken && !checkedIn)) {
@@ -72,7 +74,7 @@ export const GibsonPlugin = async () => {
                 "GIBSON_BOOTSTRAP_TOKEN=<one-time token>. After that the host key at " +
                 `${hostKeyPath} is enough — you can drop the token.`);
         }
-        return { tool: standaloneTools() };
+        return standalone();
     }
     let session;
     let shim;
@@ -102,34 +104,19 @@ export const GibsonPlugin = async () => {
         // Fail open to standalone: a coding agent must still work if the platform is unreachable.
         console.error(`[zerocool] Gibson connect failed; continuing standalone: ${e.message}`);
         await shim?.close();
-        return { tool: standaloneTools() };
+        return standalone();
     }
     const shimUrl = shim.url;
     const live = session;
-    // Tool discovery runs once at load — opencode reads the `tool` hook as a
-    // static object, so a tool registered mid-session would never reach the model.
     // Which grant this process reads the knowledge graph with. A dispatched run
     // reads as the TASK; an interactive one keeps the component grant. Chosen once
     // here so nothing downstream has to ask.
     const { knowledge, scope: knowledgeScope } = selectKnowledgeSource(live);
     console.error(`[zerocool] knowledge reads use the ${knowledgeScope} grant`);
-    const gibson = await buildGibsonTools(live);
-    if (gibson.note)
-        console.error(`[zerocool] Gibson tool discovery: ${gibson.note}`);
-    else
-        console.error(`[zerocool] ${gibson.discovered} Gibson tool(s) registered`);
-    const tools = {
-        submit_finding: submitFindingTool(gibsonFindingsBackend(live), context),
-        recall: recallTool(knowledge),
-        gibson_componentize: componentizeTool(),
-        gibson_enroll_component: enrollComponentTool(live),
-        ...gibson.tools,
-        ...delegationTools(live),
-    };
     const injectKnowledge = ambientKnowledge(knowledge, process.env.ZEROCOOL_AMBIENT_QUERY ?? "prior findings and security facts for this codebase");
     return {
-        tool: tools,
-        // Zero-config LLM: inject the Gibson provider at config-load time (#6).
+        // Zero-config LLM, and the one tool surface: inject both at config-load
+        // time (#6, ADR-0008).
         //
         // `shimUrl` is always live here, and that is a type-level guarantee rather
         // than a timing assumption: `Plugin` returns `Promise<Hooks>`, so opencode
@@ -146,13 +133,14 @@ export const GibsonPlugin = async () => {
                     options: { baseURL: shimUrl, apiKey: "gibson" },
                 };
             }
+            addMcpServer(config);
         },
         // Ambient knowledge (#8): one cached GraphRAG lookup per session, injected
         // into the system prompt from the second turn on.
         "experimental.chat.system.transform": injectKnowledge,
-        // Track the session so findings carry provenance (#7). This hook does not
-        // emit findings: a file edit is not a security finding, and inventing one
-        // would fill the tenant graph with noise a human then has to triage.
+        // Track the session id, which the ambient block and any local state key
+        // off. This hook emits nothing: a file edit is not a security finding, and
+        // inventing one would fill the tenant graph with noise a human must triage.
         event: async ({ event }) => {
             const sessionID = event.properties?.sessionID;
             if (sessionID)
@@ -164,4 +152,11 @@ export const GibsonPlugin = async () => {
         },
     };
 };
+/** Register the Gibson MCP server in opencode's own `mcp` block. */
+function addMcpServer(config) {
+    const cfg = config;
+    cfg.mcp = cfg.mcp ?? {};
+    if (!cfg.mcp.gibson)
+        cfg.mcp.gibson = gibsonMcpServer();
+}
 export default GibsonPlugin;

package/dist/knowledge.d.ts

@@ -1,13 +1,4 @@
-import type { ToolDefinition } from "@opencode-ai/plugin";
 import { type KnowledgeSource } from "@zeroroot-ai/sdk";
-export declare function recallTool(knowledge: KnowledgeSource): ToolDefinition;
-/**
- * Per-session ambient knowledge for the system prompt.
- *
- * Returns a transform that injects a short context block once a session has
- * produced one. The lookup is fired once and cached, so a session pays for at
- * most one GraphRAG query no matter how many turns it runs.
- */
 export declare function ambientKnowledge(knowledge: KnowledgeSource, seedQuery: string): (input: {
     sessionID?: string;
 }, output: {

package/dist/knowledge.js

@@ -1,5 +1,4 @@
-import { tool } from "@opencode-ai/plugin";
-import { formatKnowledgeForPrompt, isSeamUnavailable, } from "@zeroroot-ai/sdk";
+import { formatKnowledgeForPrompt, } from "@zeroroot-ai/sdk";
 /**
  * Knowledge — read the tenant graph so the agent sharpens across runs
  * (zerocool-plugins#8).
@@ -22,57 +21,6 @@ import { formatKnowledgeForPrompt, isSeamUnavailable, } from "@zeroroot-ai/sdk";
  */
 /** How many hits the ambient block injects. Kept small — it is prompt overhead. */
 const AMBIENT_LIMIT = 5;
-export function recallTool(knowledge) {
-    const z = tool.schema;
-    return tool({
-        description: "Search this tenant's Gibson knowledge graph for prior findings, targets and " +
-            "security facts recorded by earlier runs. Use it before starting work on an " +
-            "unfamiliar area, or to check whether an issue was already reported.",
-        args: {
-            query: z.string().describe("What to look for, in natural language."),
-            limit: z.number().min(1).max(50).optional().describe("Maximum hits to return. Defaults to 10."),
-            node_types: z
-                .array(z.string())
-                .optional()
-                .describe('Restrict to node types, e.g. ["finding"] or ["host", "technique"].'),
-        },
-        async execute(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 {
-                        title: "recall unavailable",
-                        output: "The Gibson knowledge graph is not available on this daemon: the GraphRAG " +
-                            "seam is not wired (gibson#1186). Continue without prior context.",
-                    };
-                }
-                throw e;
-            }
-            if (hits.length === 0) {
-                return { title: "no matches", output: `Nothing in the tenant graph matches "${args.query}".` };
-            }
-            return {
-                title: `${hits.length} match${hits.length === 1 ? "" : "es"}`,
-                output: formatKnowledgeForPrompt(hits),
-                metadata: { hit_count: hits.length, node_types: [...new Set(hits.map((h) => h.type))] },
-            };
-        },
-    });
-}
-/**
- * Per-session ambient knowledge for the system prompt.
- *
- * Returns a transform that injects a short context block once a session has
- * produced one. The lookup is fired once and cached, so a session pays for at
- * most one GraphRAG query no matter how many turns it runs.
- */
 export function ambientKnowledge(knowledge, seedQuery) {
     const cache = new Map();
     const inFlight = new Map();

package/dist/mcp-config.d.ts

@@ -0,0 +1,20 @@
+/**
+ * How opencode reaches the Gibson MCP server (ADR-0008, slice A7).
+ *
+ * opencode spawns a local MCP server from its `mcp` block, the same way every
+ * other host does from its own config file. The plugin writes that entry in
+ * the `config` hook, so a user configures nothing.
+ *
+ * The command is the published package, not a path inside this plugin: the
+ * server is shared by every host and released on the SDK train, so pinning it
+ * to whatever this plugin happens to bundle would freeze the tool set.
+ */
+export declare const GIBSON_MCP_PACKAGE = "@zeroroot-ai/gibson-mcp@latest";
+export interface OpencodeMcpLocal {
+    type: "local";
+    command: string[];
+    enabled: boolean;
+    environment?: Record<string, string>;
+}
+/** The `mcp.gibson` entry. `environment` carries nothing secret. */
+export declare function gibsonMcpServer(env?: NodeJS.ProcessEnv): OpencodeMcpLocal;

package/dist/mcp-config.js

@@ -0,0 +1,29 @@
+/**
+ * How opencode reaches the Gibson MCP server (ADR-0008, slice A7).
+ *
+ * opencode spawns a local MCP server from its `mcp` block, the same way every
+ * other host does from its own config file. The plugin writes that entry in
+ * the `config` hook, so a user configures nothing.
+ *
+ * The command is the published package, not a path inside this plugin: the
+ * server is shared by every host and released on the SDK train, so pinning it
+ * to whatever this plugin happens to bundle would freeze the tool set.
+ */
+export const GIBSON_MCP_PACKAGE = "@zeroroot-ai/gibson-mcp@latest";
+/** The `mcp.gibson` entry. `environment` carries nothing secret. */
+export function gibsonMcpServer(env = process.env) {
+    const environment = {};
+    // Addressing only. The server does its own check-in, and a grant is never
+    // written into a config file.
+    for (const name of ["GIBSON_PLATFORM_URL", "GIBSON_DAEMON_URL", "GIBSON_TARGET_ID", "GIBSON_CA_CERT"]) {
+        const value = env[name];
+        if (value)
+            environment[name] = value;
+    }
+    return {
+        type: "local",
+        command: ["npx", "--yes", "--package", GIBSON_MCP_PACKAGE, "gibson-mcp", "--transport", "stdio"],
+        enabled: true,
+        ...(Object.keys(environment).length > 0 ? { environment } : {}),
+    };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zeroroot-ai/zerocool",
-  "version": "0.8.0",
-  "description": "opencode plugin: Gibson platform integration (zerocool). Zero-config LLM, tools, findings, knowledge, delegate/missions.",
+  "version": "0.9.0",
+  "description": "opencode host adapter for Gibson (zerocool): zero-config LLM through the harness, ambient knowledge, and the Gibson MCP server registered for you. The tools come from @zeroroot-ai/gibson-mcp.",
   "license": "MIT",
   "repository": {
     "type": "git",

package/dist/componentize.d.ts

@@ -1,10 +0,0 @@
-import type { ToolDefinition } from "@opencode-ai/plugin";
-import { type GibsonSession } from "@zeroroot-ai/sdk";
-/**
- * Write a validated component manifest to disk. Available with or without a
- * Gibson session — the manifest is the artifact a build pipeline needs, and
- * producing it must not require a platform connection.
- */
-export declare function componentizeTool(): ToolDefinition;
-/** Register a produced artifact with the tenant registry. */
-export declare function enrollComponentTool(session: GibsonSession): ToolDefinition;

package/dist/componentize.js

@@ -1,149 +0,0 @@
-import { tool } from "@opencode-ai/plugin";
-import { buildComponentManifest, enrollComponent, enrollmentSupported, validateComponentSpec, } from "@zeroroot-ai/sdk";
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
-/**
- * Componentize produced artifacts into the tenant fleet (zerocool-plugins#11).
- *
- * The factory payoff: an artifact the agent built becomes a registered Gibson
- * component. The contract is language-neutral — `RegisterComponent` describes a
- * component by kind, name, version and contract fields, never by the language
- * it was written in.
- *
- * Two tools, because the work splits at a real boundary:
- *
- *  - `gibson_componentize` writes the manifest to disk without touching the
- *    platform. It is the step that can always run, and the artefact it produces
- *    is what a build pipeline consumes.
- *  - `gibson_enroll_component` registers the manifest with the daemon.
- *
- * WHAT THIS DOES NOT DO. Image build and publish is a build-system concern, not
- * an RPC; the OCI reference is an input here, carried in `metadata.image`. And
- * enrollment currently registers under the CALLING agent's identity — the
- * policy-bounded RPC that would give a produced component its own short-TTL
- * credential is gibson#1185 and does not exist yet. The tool says so in its
- * output rather than implying the artifact is independently dispatchable.
- */
-const KINDS = ["agent", "tool", "plugin"];
-/** Shared argument shape for both tools. */
-function specArgs() {
-    const z = tool.schema;
-    return {
-        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."),
-    };
-}
-/** Build a ComponentSpec from tool arguments. */
-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 } : {}),
-    };
-}
-/**
- * Write a validated component manifest to disk. Available with or without a
- * Gibson session — the manifest is the artifact a build pipeline needs, and
- * producing it must not require a platform connection.
- */
-export function componentizeTool() {
-    const z = tool.schema;
-    return tool({
-        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.",
-        args: {
-            ...specArgs(),
-            path: z
-                .string()
-                .optional()
-                .describe('Where to write the manifest. Defaults to "gibson-component.json".'),
-        },
-        async execute(args, ctx) {
-            const spec = toSpec(args);
-            const problems = validateComponentSpec(spec);
-            if (problems.length > 0) {
-                return {
-                    title: "invalid component spec",
-                    output: `This artifact does not satisfy Gibson's ${spec.kind} contract:\n${problems.map((p) => `- ${p}`).join("\n")}`,
-                };
-            }
-            const manifest = buildComponentManifest(spec);
-            const target = resolve(ctx.directory, 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 enrolling — a component without an image cannot be dispatched.";
-            return {
-                title: `${spec.kind} manifest: ${spec.name}`,
-                output: `Wrote a valid ${spec.kind} manifest for ${spec.name}@${spec.version} to ${target}.${missingImage}`,
-                metadata: { path: target, kind: spec.kind, name: spec.name },
-            };
-        },
-    });
-}
-/** Register a produced artifact with the tenant registry. */
-export function enrollComponentTool(session) {
-    return tool({
-        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.",
-        args: specArgs(),
-        async execute(args) {
-            const spec = toSpec(args);
-            const problems = validateComponentSpec(spec);
-            if (problems.length > 0) {
-                return {
-                    title: "invalid component spec",
-                    output: `This artifact does not satisfy Gibson's ${spec.kind} contract:\n${problems.map((p) => `- ${p}`).join("\n")}`,
-                };
-            }
-            const result = await enrollComponent(session.clients.component, spec);
-            const { reason } = enrollmentSupported();
-            return {
-                title: `enrolled ${spec.name}`,
-                output: `Registered ${spec.kind} ${spec.name}@${spec.version} as instance ${result.instanceId}.\n\n` +
-                    `Note: ${reason}. It is visible in the tenant registry, but it will drop out ` +
-                    `when heartbeats stop (every ${Math.round(result.heartbeatIntervalMs / 1000)}s) ` +
-                    `unless the artifact itself runs and checks in.`,
-                metadata: {
-                    instance_id: result.instanceId,
-                    has_own_identity: result.hasOwnIdentity,
-                    kind: spec.kind,
-                },
-            };
-        },
-    });
-}

package/dist/delegate.d.ts

@@ -1,11 +0,0 @@
-import type { ToolDefinition } from "@opencode-ai/plugin";
-import { type GibsonSession } from "@zeroroot-ai/sdk";
-export declare function listAgentsTool(session: GibsonSession): ToolDefinition;
-export declare function delegateTool(session: GibsonSession): ToolDefinition;
-export declare function createMissionTool(session: GibsonSession): ToolDefinition;
-export declare function runMissionTool(session: GibsonSession): ToolDefinition;
-export declare function missionStatusTool(session: GibsonSession): ToolDefinition;
-export declare function missionResultsTool(session: GibsonSession): ToolDefinition;
-export declare function cancelMissionTool(session: GibsonSession): ToolDefinition;
-/** Every delegation and mission tool, keyed for the opencode `tool` hook. */
-export declare function delegationTools(session: GibsonSession): Record<string, ToolDefinition>;

package/dist/delegate.js

@@ -1,216 +0,0 @@
-import { tool } from "@opencode-ai/plugin";
-import { cancelMission, createMission, delegateToAgent, getMissionResults, getMissionStatus, isSeamUnavailable, listAgents, newTask, runMission, waitMission, } from "@zeroroot-ai/sdk";
-/**
- * Delegation and missions — the factory's dispatch and recursion
- * (zerocool-plugins#10).
- *
- * Rules-of-engagement, authz and budget denials come back as daemon errors.
- * They are surfaced verbatim to the model rather than retried: a denial is a
- * policy decision, and an agent that retries a denied delegation is just
- * burning budget against a wall.
- *
- * Every RPC here needs the daemon's `agentDelegator` / `missionMgr` seams,
- * which are not wired (gibson#1186). Each tool reports that state plainly
- * instead of surfacing a bare "unimplemented" to the model.
- */
-const UNWIRED = "This daemon has no agent delegation or mission management wired (gibson#1186). " +
-    "Complete the work directly instead.";
-export function listAgentsTool(session) {
-    return tool({
-        description: "List the Gibson agents in this tenant that work can be delegated to, with " +
-            "their capabilities and the target types they handle.",
-        args: {},
-        async execute() {
-            const { agents, unavailable } = await listAgents(session.clients.component);
-            if (unavailable)
-                return { title: "delegation unavailable", output: UNWIRED };
-            if (agents.length === 0) {
-                return { title: "no agents", output: "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 {
-                title: `${agents.length} agent${agents.length === 1 ? "" : "s"}`,
-                output: lines.join("\n"),
-                metadata: { agent_count: agents.length },
-            };
-        },
-    });
-}
-export function delegateTool(session) {
-    const z = tool.schema;
-    return tool({
-        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.",
-        args: {
-            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 execute(args) {
-            const constraints = {
-                ...(args.max_turns ? { MaxTurns: args.max_turns } : {}),
-                ...(args.allowed_tools ? { AllowedTools: args.allowed_tools } : {}),
-            };
-            const task = newTask(args.goal, {
-                ...(args.context ? { Context: args.context } : {}),
-                ...(Object.keys(constraints).length > 0 ? { Constraints: constraints } : {}),
-            });
-            try {
-                const result = await delegateToAgent(session.clients.component, args.agent, task);
-                const output = typeof result.Output === "string" ? result.Output : JSON.stringify(result.Output, null, 2);
-                const findings = result.Findings && result.Findings.length > 0
-                    ? `\n\nFindings recorded: ${result.Findings.join(", ")}`
-                    : "";
-                const failure = result.error?.message ? `\n\nError: ${result.error.message}` : "";
-                return {
-                    title: `${args.agent}: ${result.Status}`,
-                    output: `${output ?? "(no output)"}${findings}${failure}`,
-                    metadata: { status: result.Status, finding_ids: result.Findings ?? [] },
-                };
-            }
-            catch (e) {
-                if (isSeamUnavailable(e))
-                    return { title: "delegation unavailable", output: UNWIRED };
-                // Authz / RoE / budget denials land here. Show the daemon's reason.
-                return {
-                    title: `${args.agent}: denied`,
-                    output: `Delegation to ${args.agent} was refused: ${e.message}`,
-                };
-            }
-        },
-    });
-}
-export function createMissionTool(session) {
-    const z = tool.schema;
-    return tool({
-        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.",
-        args: {
-            definition: z.record(z.string(), z.any()).describe("Mission definition object."),
-            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 execute(args) {
-            try {
-                const info = await createMission(session.clients.component, args.definition, args.target_id, args.opts);
-                const id = (info.id ?? info.mission_id ?? info.missionId);
-                return {
-                    title: id ? `mission ${id}` : "mission created",
-                    output: JSON.stringify(info, null, 2),
-                    ...(id ? { metadata: { mission_id: id } } : {}),
-                };
-            }
-            catch (e) {
-                if (isSeamUnavailable(e))
-                    return { title: "missions unavailable", output: UNWIRED };
-                throw e;
-            }
-        },
-    });
-}
-export function runMissionTool(session) {
-    const z = tool.schema;
-    return tool({
-        description: "Queue a created Gibson mission for execution. Returns as soon as it is queued.",
-        args: { mission_id: z.string().describe("Mission to run.") },
-        async execute(args) {
-            try {
-                await runMission(session.clients.component, args.mission_id);
-                return { title: "queued", output: `Mission ${args.mission_id} is queued for execution.` };
-            }
-            catch (e) {
-                if (isSeamUnavailable(e))
-                    return { title: "missions unavailable", output: UNWIRED };
-                throw e;
-            }
-        },
-    });
-}
-export function missionStatusTool(session) {
-    const z = tool.schema;
-    return tool({
-        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.",
-        args: {
-            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 execute(args) {
-            try {
-                const state = args.wait
-                    ? await waitMission(session.clients.component, args.mission_id, args.timeout_ms ?? 300_000)
-                    : await getMissionStatus(session.clients.component, args.mission_id);
-                return {
-                    title: `mission ${args.mission_id}`,
-                    output: JSON.stringify(state, null, 2),
-                };
-            }
-            catch (e) {
-                if (isSeamUnavailable(e))
-                    return { title: "missions unavailable", output: UNWIRED };
-                throw e;
-            }
-        },
-    });
-}
-export function missionResultsTool(session) {
-    const z = tool.schema;
-    return tool({
-        description: "Read the final results of a completed Gibson mission.",
-        args: { mission_id: z.string().describe("Mission whose results to read.") },
-        async execute(args) {
-            try {
-                const results = await getMissionResults(session.clients.component, args.mission_id);
-                return { title: `results ${args.mission_id}`, output: JSON.stringify(results, null, 2) };
-            }
-            catch (e) {
-                if (isSeamUnavailable(e))
-                    return { title: "missions unavailable", output: UNWIRED };
-                throw e;
-            }
-        },
-    });
-}
-export function cancelMissionTool(session) {
-    const z = tool.schema;
-    return tool({
-        description: "Request cancellation of a running Gibson mission.",
-        args: { mission_id: z.string().describe("Mission to cancel.") },
-        async execute(args) {
-            try {
-                await cancelMission(session.clients.component, args.mission_id);
-                return { title: "cancelled", output: `Cancellation requested for mission ${args.mission_id}.` };
-            }
-            catch (e) {
-                if (isSeamUnavailable(e))
-                    return { title: "missions unavailable", output: UNWIRED };
-                throw e;
-            }
-        },
-    });
-}
-/** Every delegation and mission tool, keyed for the opencode `tool` hook. */
-export function delegationTools(session) {
-    return {
-        gibson_list_agents: listAgentsTool(session),
-        gibson_delegate: delegateTool(session),
-        gibson_create_mission: createMissionTool(session),
-        gibson_run_mission: runMissionTool(session),
-        gibson_mission_status: missionStatusTool(session),
-        gibson_mission_results: missionResultsTool(session),
-        gibson_cancel_mission: cancelMissionTool(session),
-    };
-}

package/dist/gibson-tools.d.ts

@@ -1,45 +0,0 @@
-import type { ToolDefinition } from "@opencode-ai/plugin";
-import { type GibsonSession, type GibsonTool } from "@zeroroot-ai/sdk";
-/**
- * Gibson tools and plugins as opencode tools (zerocool-plugins#9).
- *
- * Discovered tools are registered **individually** — one opencode tool per
- * Gibson tool, named `gibson_<tool>` — so the model sees them in its tool list
- * with their own descriptions, rather than having to know that a generic
- * dispatcher exists and what to pass it.
- *
- * ON SCHEMAS — the catalog carries no JSON Schema. `ToolDescriptorProto` only
- * names the proto message types of a tool's input and output
- * (`gibson.tool.v1.ScanRequest`), and there is no RPC that resolves those to a
- * schema. So a per-tool wrapper takes a single free-form `input` object and
- * names the expected message type in its description. Inventing a Zod schema
- * from a message type name would be a guess, and a wrong guess would reject
- * valid input before it ever reached the tool.
- *
- * A generic `gibson_call_tool` is always registered as well: discovery is
- * `Unimplemented` on the current daemon (gibson#1186), and without it there
- * would be no way to reach a tool whose name the operator already knows.
- */
-/** Sanitise a Gibson tool name into an opencode tool key. */
-export declare function toolKey(name: string): string;
-/** Wrap one discovered Gibson tool as an opencode tool. */
-export declare function wrapGibsonTool(session: GibsonSession, t: GibsonTool): ToolDefinition;
-/** The always-present dispatcher for tools the catalog did not surface. */
-export declare function callToolTool(session: GibsonSession): ToolDefinition;
-/** List what Gibson exposes to this tenant — tools and enabled plugins. */
-export declare function listToolsTool(session: GibsonSession): ToolDefinition;
-/** Invoke a method on an enabled Gibson plugin. */
-export declare function queryPluginTool(session: GibsonSession): ToolDefinition;
-/**
- * Discover the tenant's tools and build one opencode tool for each, plus the
- * always-present dispatcher, catalog and plugin tools.
- *
- * Discovery runs once at plugin load. opencode reads the `tool` hook as a
- * static object, so a tool registered later in the session would not be visible
- * to the model anyway.
- */
-export declare function buildGibsonTools(session: GibsonSession): Promise<{
-    tools: Record<string, ToolDefinition>;
-    discovered: number;
-    note?: string;
-}>;

package/dist/gibson-tools.js

@@ -1,175 +0,0 @@
-import { tool } from "@opencode-ai/plugin";
-import { callGibsonTool, listGibsonPlugins, listGibsonTools, queryGibsonPlugin, } from "@zeroroot-ai/sdk";
-/**
- * Gibson tools and plugins as opencode tools (zerocool-plugins#9).
- *
- * Discovered tools are registered **individually** — one opencode tool per
- * Gibson tool, named `gibson_<tool>` — so the model sees them in its tool list
- * with their own descriptions, rather than having to know that a generic
- * dispatcher exists and what to pass it.
- *
- * ON SCHEMAS — the catalog carries no JSON Schema. `ToolDescriptorProto` only
- * names the proto message types of a tool's input and output
- * (`gibson.tool.v1.ScanRequest`), and there is no RPC that resolves those to a
- * schema. So a per-tool wrapper takes a single free-form `input` object and
- * names the expected message type in its description. Inventing a Zod schema
- * from a message type name would be a guess, and a wrong guess would reject
- * valid input before it ever reached the tool.
- *
- * A generic `gibson_call_tool` is always registered as well: discovery is
- * `Unimplemented` on the current daemon (gibson#1186), and without it there
- * would be no way to reach a tool whose name the operator already knows.
- */
-/** Sanitise a Gibson tool name into an opencode tool key. */
-export function toolKey(name) {
-    return `gibson_${name.replace(/[^a-zA-Z0-9_]/g, "_")}`;
-}
-/** Wrap one discovered Gibson tool as an opencode tool. */
-export function wrapGibsonTool(session, t) {
-    const z = tool.schema;
-    const schemaNote = t.inputMessageType
-        ? ` Input must match the Gibson message type ${t.inputMessageType}.`
-        : "";
-    return tool({
-        description: `${t.description || `Gibson tool "${t.name}"`}${schemaNote} Runs through the Gibson harness (authorized and metered).`,
-        args: {
-            input: z
-                .record(z.string(), z.any())
-                .describe(`Input object for the ${t.name} tool${t.inputMessageType ? ` (${t.inputMessageType})` : ""}.`),
-            timeout_ms: z.number().optional().describe("Per-call timeout in milliseconds."),
-        },
-        async execute(args) {
-            const result = await callGibsonTool(session.clients.component, {
-                name: t.name,
-                input: args.input,
-                ...(args.timeout_ms ? { timeoutMs: args.timeout_ms } : {}),
-            });
-            return formatToolResult(t.name, result);
-        },
-    });
-}
-/** The always-present dispatcher for tools the catalog did not surface. */
-export function callToolTool(session) {
-    const z = tool.schema;
-    return 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.",
-        args: {
-            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 execute(args) {
-            const result = await callGibsonTool(session.clients.component, {
-                name: args.name,
-                input: args.input,
-                ...(args.timeout_ms ? { timeoutMs: args.timeout_ms } : {}),
-            });
-            return formatToolResult(args.name, result);
-        },
-    });
-}
-/** List what Gibson exposes to this tenant — tools and enabled plugins. */
-export function listToolsTool(session) {
-    return tool({
-        description: "List the Gibson tools and plugins available to this tenant, with the input " +
-            "message type each tool expects.",
-        args: {},
-        async execute() {
-            const [discovery, plugins] = await Promise.all([
-                listGibsonTools(session.clients.component),
-                listGibsonPlugins(session.clients.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}`);
-                }
-            }
-            const enabled = plugins.filter((p) => p.enabled);
-            if (enabled.length > 0) {
-                lines.push("", "Enabled plugins:");
-                for (const p of enabled) {
-                    lines.push(`- ${p.name} (${p.version}) — methods: ${p.methods.join(", ") || "none"}`);
-                }
-            }
-            return {
-                title: `${discovery.tools.length} tools, ${enabled.length} plugins`,
-                output: lines.join("\n"),
-                metadata: { tool_count: discovery.tools.length, plugin_count: enabled.length },
-            };
-        },
-    });
-}
-/** Invoke a method on an enabled Gibson plugin. */
-export function queryPluginTool(session) {
-    const z = tool.schema;
-    return tool({
-        description: "Call a method on an enabled Gibson plugin through the harness. Use " +
-            "gibson_list_tools first to see which plugins and methods are available.",
-        args: {
-            plugin: z.string().describe("Registered plugin name."),
-            method: z.string().describe("Method to invoke on the plugin."),
-            params: z.record(z.string(), z.any()).optional().describe("Method parameters."),
-            timeout_ms: z.number().optional().describe("Per-call timeout in milliseconds."),
-        },
-        async execute(args) {
-            const result = await queryGibsonPlugin(session.clients.component, {
-                plugin: args.plugin,
-                method: args.method,
-                ...(args.params ? { params: args.params } : {}),
-                ...(args.timeout_ms ? { timeoutMs: args.timeout_ms } : {}),
-            });
-            return formatToolResult(`${args.plugin}.${args.method}`, result);
-        },
-    });
-}
-/**
- * Discover the tenant's tools and build one opencode tool for each, plus the
- * always-present dispatcher, catalog and plugin tools.
- *
- * Discovery runs once at plugin load. opencode reads the `tool` hook as a
- * static object, so a tool registered later in the session would not be visible
- * to the model anyway.
- */
-export async function buildGibsonTools(session) {
-    const tools = {
-        gibson_call_tool: callToolTool(session),
-        gibson_list_tools: listToolsTool(session),
-        gibson_query_plugin: queryPluginTool(session),
-    };
-    const discovery = await listGibsonTools(session.clients.component);
-    for (const t of discovery.tools) {
-        // Never let a discovered tool shadow the built-ins.
-        const key = toolKey(t.name);
-        if (!(key in tools))
-            tools[key] = wrapGibsonTool(session, t);
-    }
-    return {
-        tools,
-        discovered: discovery.tools.length,
-        ...(discovery.unavailable ? { note: discovery.unavailable } : {}),
-    };
-}
-/** Render a harness tool result, keeping an in-band tool error visible. */
-function formatToolResult(name, result) {
-    if (result.error) {
-        return {
-            title: `${name} failed`,
-            output: `Gibson tool ${name} failed [${result.error.code}]: ${result.error.message}${result.error.retryable ? " (retryable)" : ""}`,
-            metadata: { error_code: result.error.code, retryable: result.error.retryable },
-        };
-    }
-    const text = typeof result.output === "string" ? result.output : JSON.stringify(result.output, null, 2);
-    return { title: name, output: text ?? "(no output)" };
-}