@zeroroot-ai/zerocool 0.8.0 → 0.9.1

package/dist/http-probe.js

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Elastic-2.0
+// Copyright 2026 Zero Root AI
 import { decodeToolInput } from "@zeroroot-ai/sdk";
 export const HTTP_PROBE_TIMEOUT_MS = 15_000;
 /** Perform the probe. Exported separately from the handler so it is testable without a work item. */

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

@@ -1,13 +1,12 @@
+// SPDX-License-Identifier: Elastic-2.0
+// Copyright 2026 Zero Root AI
 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 +28,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 +62,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 +76,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 +106,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);
+    const { knowledge, scope: knowledgeScope, stop: stopKnowledge } = 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,22 +135,33 @@ 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)
                 context.sessionID = sessionID;
         },
         dispose: async () => {
+            // A task-scoped source holds a grant-renewal timer. Leaving it running
+            // would keep renewing a grant for a session that has ended.
+            stopKnowledge();
             session?.stop();
             await shim?.close();
         },
     };
 };
+/** 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-source.d.ts

@@ -1,12 +1,35 @@
-import { type GibsonSession, type KnowledgeSource } from "@zeroroot-ai/sdk";
+import { type GibsonSession, type KnowledgeSource, type OpenTaskHarnessOptions, type TaskHarness } from "@zeroroot-ai/sdk";
+/** The chosen knowledge source, and the way to release what it opened. */
+export interface SelectedKnowledge {
+    knowledge: KnowledgeSource;
+    scope: "task" | "component";
+    /**
+     * Release the task harness. Safe to call on either scope, and safe to call
+     * twice. A component-scoped run opens nothing, so this does nothing.
+     */
+    stop: () => void;
+}
+/** Seams, so a test can read what a dispatched run actually sends. */
+export interface KnowledgeSourceDeps {
+    /** Opens the task harness. Defaults to `openTaskHarness` on the dispatch grant. */
+    openHarness?: (opts: OpenTaskHarnessOptions) => TaskHarness;
+}
 /**
  * Pick the grant this process should read the knowledge graph with.
  *
  * A DISPATCHED run must read as the TASK, not as the component. gibson mints a
- * per-dispatch capability grant and `zerocool-agent` passes it to the child as
- * GIBSON_CALLBACK_ENDPOINT / GIBSON_CALLBACK_TOKEN. Reading with the component's
- * own grant instead is broader authority than the dispatch intended and leaves
- * no per-task attribution on anything the run reads — the gap ADR-0006 recorded.
+ * per-dispatch capability grant, and the driver passes it to this opencode
+ * child as GIBSON_CALLBACK_ENDPOINT / GIBSON_CALLBACK_TOKEN. Reading with the
+ * component's own grant instead is broader authority than the dispatch
+ * intended and leaves no per-task attribution on anything the run reads — the
+ * gap ADR-0006 recorded.
+ *
+ * THESE TWO NAMES ARE THE CHILD CONTRACT, NOT THE LAUNCHER CONTRACT. The
+ * launcher writes GIBSON_CG_JWT and GIBSON_AGENT_TASK_B64 into the sandbox,
+ * and `readSandboxDispatch` in `@zeroroot-ai/sdk` is the one reader of those
+ * (see `dispatch.ts`). This module runs one process further down, inside
+ * opencode, whose environment `dispatchChildEnv` writes. It never sees the
+ * launch environment, so it reads the child names and nothing else.
  *
  * An INTERACTIVE run has no callback seam and keeps the component grant, which
  * is correct: a human started it, and there is no task to scope to.
@@ -14,8 +37,10 @@ import { type GibsonSession, type KnowledgeSource } from "@zeroroot-ai/sdk";
  * A dispatch that carries an endpoint but no token FAILS rather than falling
  * back. Falling back is how the gap reappears silently, and a caller who wanted
  * task-scoped reads would get component-scoped ones without being told.
+ *
+ * `openTaskHarness` derives the `ContextInfo` every callback RPC carries from
+ * the grant's own claims, so a task-scoped read reaches the daemon naming the
+ * mission it belongs to. It also renews the grant on a timer, which is why the
+ * caller must {@link SelectedKnowledge.stop} the source when the session ends.
  */
-export declare function selectKnowledgeSource(session: GibsonSession): {
-    knowledge: KnowledgeSource;
-    scope: "task" | "component";
-};
+export declare function selectKnowledgeSource(session: GibsonSession, deps?: KnowledgeSourceDeps): SelectedKnowledge;

package/dist/knowledge-source.js

@@ -1,12 +1,22 @@
+// SPDX-License-Identifier: Elastic-2.0
+// Copyright 2026 Zero Root AI
 import { componentKnowledge, openTaskHarness, taskKnowledge, } from "@zeroroot-ai/sdk";
 /**
  * Pick the grant this process should read the knowledge graph with.
  *
  * A DISPATCHED run must read as the TASK, not as the component. gibson mints a
- * per-dispatch capability grant and `zerocool-agent` passes it to the child as
- * GIBSON_CALLBACK_ENDPOINT / GIBSON_CALLBACK_TOKEN. Reading with the component's
- * own grant instead is broader authority than the dispatch intended and leaves
- * no per-task attribution on anything the run reads — the gap ADR-0006 recorded.
+ * per-dispatch capability grant, and the driver passes it to this opencode
+ * child as GIBSON_CALLBACK_ENDPOINT / GIBSON_CALLBACK_TOKEN. Reading with the
+ * component's own grant instead is broader authority than the dispatch
+ * intended and leaves no per-task attribution on anything the run reads — the
+ * gap ADR-0006 recorded.
+ *
+ * THESE TWO NAMES ARE THE CHILD CONTRACT, NOT THE LAUNCHER CONTRACT. The
+ * launcher writes GIBSON_CG_JWT and GIBSON_AGENT_TASK_B64 into the sandbox,
+ * and `readSandboxDispatch` in `@zeroroot-ai/sdk` is the one reader of those
+ * (see `dispatch.ts`). This module runs one process further down, inside
+ * opencode, whose environment `dispatchChildEnv` writes. It never sees the
+ * launch environment, so it reads the child names and nothing else.
  *
  * An INTERACTIVE run has no callback seam and keeps the component grant, which
  * is correct: a human started it, and there is no task to scope to.
@@ -14,25 +24,36 @@ import { componentKnowledge, openTaskHarness, taskKnowledge, } from "@zeroroot-a
  * A dispatch that carries an endpoint but no token FAILS rather than falling
  * back. Falling back is how the gap reappears silently, and a caller who wanted
  * task-scoped reads would get component-scoped ones without being told.
+ *
+ * `openTaskHarness` derives the `ContextInfo` every callback RPC carries from
+ * the grant's own claims, so a task-scoped read reaches the daemon naming the
+ * mission it belongs to. It also renews the grant on a timer, which is why the
+ * caller must {@link SelectedKnowledge.stop} the source when the session ends.
  */
-export function selectKnowledgeSource(session) {
+export function selectKnowledgeSource(session, deps = {}) {
     const endpoint = process.env.GIBSON_CALLBACK_ENDPOINT;
     const token = process.env.GIBSON_CALLBACK_TOKEN;
     if (!endpoint) {
-        return { knowledge: componentKnowledge(session.clients.component), scope: "component" };
+        return {
+            knowledge: componentKnowledge(session.clients.component),
+            scope: "component",
+            stop: () => { },
+        };
     }
     if (!token) {
         throw new Error("GIBSON_CALLBACK_ENDPOINT is set but GIBSON_CALLBACK_TOKEN is not. A dispatched run " +
             "must read with its task grant; falling back to the component grant would silently " +
             "widen this run's authority.");
     }
+    const harness = (deps.openHarness ?? openTaskHarness)({
+        endpoint,
+        token,
+        // A local or kind daemon may serve the callback listener without TLS.
+        insecure: process.env.GIBSON_CALLBACK_INSECURE === "1",
+    });
     return {
-        knowledge: taskKnowledge(openTaskHarness({
-            endpoint,
-            token,
-            // A local or kind daemon may serve the callback listener without TLS.
-            insecure: process.env.GIBSON_CALLBACK_INSECURE === "1",
-        })),
+        knowledge: taskKnowledge(harness),
         scope: "task",
+        stop: () => harness.stop(),
     };
 }

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,6 @@
-import { tool } from "@opencode-ai/plugin";
-import { formatKnowledgeForPrompt, isSeamUnavailable, } from "@zeroroot-ai/sdk";
+// SPDX-License-Identifier: Elastic-2.0
+// Copyright 2026 Zero Root AI
+import { formatKnowledgeForPrompt, } from "@zeroroot-ai/sdk";
 /**
  * Knowledge — read the tenant graph so the agent sharpens across runs
  * (zerocool-plugins#8).
@@ -22,57 +23,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,31 @@
+// SPDX-License-Identifier: Elastic-2.0
+// Copyright 2026 Zero Root AI
+/**
+ * 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/dist/opencode-run.js

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Elastic-2.0
+// Copyright 2026 Zero Root AI
 import { spawn } from "node:child_process";
 /** Parse the NDJSON `opencode run --format json` writes to stdout. */
 export function parseOpencodeEvents(stdout) {

package/dist/semgrep.js

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Elastic-2.0
+// Copyright 2026 Zero Root AI
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 /**

package/dist/serve-agent.js

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+// SPDX-License-Identifier: Elastic-2.0
+// Copyright 2026 Zero Root AI
 /**
  * zerocool-agent — run zerocool headless as a daemon-driven `kind=agent`.
  *

package/dist/serve.js

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+// SPDX-License-Identifier: Elastic-2.0
+// Copyright 2026 Zero Root AI
 /**
  * zerocool-serve — run zerocool headless as a dispatched fleet component.
  *

package/dist/source-analysis.js

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Elastic-2.0
+// Copyright 2026 Zero Root AI
 import { newFinding } from "@zeroroot-ai/sdk";
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";

package/dist/watch.js

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: Elastic-2.0
+// Copyright 2026 Zero Root AI
 import { buildCreateMissionRequest, remember, taskKnowledge } from "@zeroroot-ai/sdk";
 import { TRIGGER_STATUS } from "./gitlab.js";
 /**

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@zeroroot-ai/zerocool",
-  "version": "0.8.0",
-  "description": "opencode plugin: Gibson platform integration (zerocool). Zero-config LLM, tools, findings, knowledge, delegate/missions.",
-  "license": "MIT",
+  "version": "0.9.1",
+  "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": "Elastic-2.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/zeroroot-ai/zerocool-plugins.git",
@@ -23,13 +23,13 @@
     "test": "tsc -p tsconfig.test.json && node --test \"dist-test/**/*.test.js\""
   },
   "dependencies": {
-    "@zeroroot-ai/sdk": "^0.11.0"
+    "@zeroroot-ai/sdk": "^0.12.0"
   },
   "peerDependencies": {
     "@opencode-ai/plugin": "*"
   },
   "devDependencies": {
-    "@opencode-ai/plugin": "^1.18.11"
+    "@opencode-ai/plugin": "^1.18.27"
   },
   "bin": {
     "zerocool-serve": "dist/serve.js",

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;