@zeroroot-ai/zerocool 0.7.0 → 0.9.0

package/dist/watch.js

@@ -1,4 +1,4 @@
-import { remember, taskKnowledge } from "@zeroroot-ai/sdk";
+import { buildCreateMissionRequest, remember, taskKnowledge } from "@zeroroot-ai/sdk";
 import { TRIGGER_STATUS } from "./gitlab.js";
 /**
  * The always-on watch loop (zerocool-plugins#88).
@@ -222,81 +222,47 @@ export function worldCheckpoints(harness, application) {
 export function checkpointQueryText(application) {
     return `${CHECKPOINT_KIND} application=${application}`;
 }
+// ---------------------------------------------------------------------------
+// The Scan mission
+// ---------------------------------------------------------------------------
 /**
- * The Scan mission definition, as canonical proto JSON.
+ * The name of the checked-in Scan mission in gibson's mission catalog.
  *
- * STILL BUILT HERE, AND IT SHOULD NOT BE. gibson#1685 landed the Scan mission
- * as a checked-in definition in gibson's `missioncatalog`, and ADR-0018 makes
- * that copy authoritative: this function is meant to become a mission name plus
- * seven parameters, not a second description of the same graph.
+ * One file in `internal/platform/missioncatalog/missions/` is one mission,
+ * named for its file: `scan.cue` is `"scan"`.
+ */
+export const SCAN_CATALOG_MISSION = "scan";
+/**
+ * The seven parameters the checked-in Scan mission is rendered with.
  *
- * It cannot yet. `missioncatalog.Render` has no production caller, and
- * `CreateMission` carries only `mission_definition_json` — there is no field
- * naming a checked-in mission and none carrying its parameters, so an agent has
- * no way to ask for the catalog's copy. That is gibson#1688. Until it lands the
- * only way to originate a Scan is to send a graph, so this one stays, with the
- * shape the catalog definition expects: everything the fan-out needs is carried
- * in the node's task context, and the swap is this function's body alone.
+ * These names are the catalog's, not ours: `missioncatalog.Params.fields()` is
+ * the one declaration of them, and the daemon REFUSES an unrecognised key
+ * rather than ignoring it. That refusal is the smuggling defence — `Params` has
+ * no target or host field, so the runtime target binds from the mission's
+ * `target_id` alone and a caller cannot point a scan at a host the tenant never
+ * registered. A key renamed here without renaming it there fails loudly at the
+ * next launch, which is the intended outcome.
  *
- * The definition is built as protojson by hand rather than through the
- * generated schema because the SDK's package exports only its index, and the
- * mission schema is not re-exported from it.
+ * Every one is required. CUE refuses an incomplete render rather than
+ * substituting an empty string, so a missing commit fails instead of scanning
+ * HEAD and a missing image fails instead of scanning nothing.
  */
-export function scanMissionDefinition(inputs) {
-    const { application, pipeline } = inputs;
-    const context = {
-        "zerocool.task": "source-analysis",
-        application,
-        "pipeline.id": String(pipeline.id),
-        "pipeline.url": pipeline.webUrl,
-        "repository.url": inputs.repositoryUrl,
-        "repository.ref": pipeline.ref,
-        "repository.commit": pipeline.sha,
-        ...(inputs.imageRef ? { "image.ref": inputs.imageRef } : {}),
-        ...(inputs.targetId ? { "target.id": inputs.targetId } : {}),
-    };
+export function scanCatalogParams(inputs) {
+    const { pipeline } = inputs;
     return {
-        name: scanMissionName(inputs),
-        description: `Scan ${application} at ${pipeline.sha.slice(0, 12)}, originated by the always-on agent ` +
-            `for pipeline ${pipeline.id}.`,
-        version: "1.0.0",
-        nodes: {
-            scan: {
-                id: "scan",
-                type: "NODE_TYPE_AGENT",
-                name: "scan",
-                description: "Source analysis of the commit the pipeline built.",
-                agentConfig: {
-                    agentName: "zerocool",
-                    task: {
-                        id: "scan",
-                        goal: `Scan the ${application} repository at commit ${pipeline.sha} and submit a Finding for ` +
-                            "every real weakness you can support with evidence.",
-                        context: typedContext(context),
-                    },
-                },
-            },
-        },
-        entryPoints: ["scan"],
+        application: inputs.application,
+        repositoryUrl: inputs.repositoryUrl,
+        ref: pipeline.ref,
+        commit: pipeline.sha,
+        pipelineId: String(pipeline.id),
+        pipelineUrl: pipeline.webUrl,
+        imageRef: inputs.imageRef,
     };
 }
 /** The child mission's name, which is also how a person finds it in the dashboard. */
 export function scanMissionName(inputs) {
     return `scan ${inputs.application} pipeline ${inputs.pipeline.id}`;
 }
-/**
- * Render a string map as `map<string, gibson.common.v1.TypedValue>` in
- * protojson. Every value the loop passes is a string, so every entry is a
- * `stringValue`.
- */
-export function typedContext(ctx) {
-    const out = {};
-    for (const [k, v] of Object.entries(ctx)) {
-        if (v !== "")
-            out[k] = { stringValue: v };
-    }
-    return out;
-}
 /**
  * A {@link ScanLauncher} over the harness callbacks, on the dispatch grant.
  *
@@ -304,19 +270,43 @@ export function typedContext(ctx) {
  * daemon resolves the parent from this harness, so the Scan mission is a child
  * of the watch mission and inherits its tenant. Nothing in the request names a
  * parent, a tenant or an originator, so nothing here can widen them.
+ *
+ * THE MISSION IS NAMED, NOT BUILT (ADR-0018, gibson#1688). The Scan mission is
+ * checked into gibson's `missioncatalog` and that copy is authoritative; this
+ * launcher sends its name and seven parameters. It used to build its own graph,
+ * because `CreateMission` had no way to ask for the catalog's copy — two
+ * descriptions of one mission, which is the parallel definition ADR-0027
+ * forbids. There is no fallback to the old path: a definition that only one of
+ * the two knew about is the drift the single copy exists to prevent.
+ *
+ * The request goes through the SDK's `buildCreateMissionRequest` rather than
+ * being assembled here, because that builder normalises the one trap in this
+ * call. `JSON.stringify(undefined)` encodes to zero bytes but
+ * `JSON.stringify(null)` encodes to the four-byte string `"null"`, so a graph
+ * field filled in unconditionally puts a non-empty body on the wire beside the
+ * catalog name; the daemon refuses the pair, and the failure reads as "the
+ * catalog path does not work" rather than "you passed a null definition".
+ *
+ * The response is then sent by hand rather than through `createTaskMission`,
+ * for one reason: `CreateMissionResponse` carries an in-band `error`, and the
+ * daemon puts its most useful refusals there — an unknown parameter key naming
+ * the key and listing the known set, or every missing parameter reported at
+ * once. `createTaskMission` reads only `mission`, so those would surface as
+ * "returned no mission" and the operator would lose the sentence that says what
+ * to fix.
  */
 export function harnessScanLauncher(harness, opts) {
-    const build = opts.definition ?? scanMissionDefinition;
     const timeoutMs = BigInt(opts.scanTimeoutMs ?? DEFAULT_SCAN_TIMEOUT_MS);
     return {
         async launch(pipeline) {
-            const inputs = { ...opts.inputs, pipeline, targetId: opts.targetId };
-            const created = await harness.client.createMission({
-                context: harness.context,
-                missionDefinitionJson: new TextEncoder().encode(JSON.stringify(build(inputs))),
+            const inputs = { ...opts.inputs, pipeline };
+            const wire = buildCreateMissionRequest({
+                catalogMission: SCAN_CATALOG_MISSION,
+                catalogParams: scanCatalogParams(inputs),
                 targetId: opts.targetId,
                 name: scanMissionName(inputs),
             });
+            const created = await harness.client.createMission({ context: harness.context, ...wire });
             if (created.error) {
                 throw new Error(`CreateMission refused: ${created.error.message}`);
             }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zeroroot-ai/zerocool",
-  "version": "0.7.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",
@@ -23,7 +23,7 @@
     "test": "tsc -p tsconfig.test.json && node --test \"dist-test/**/*.test.js\""
   },
   "dependencies": {
-    "@zeroroot-ai/sdk": "^0.10.0"
+    "@zeroroot-ai/sdk": "^0.11.0"
   },
   "peerDependencies": {
     "@opencode-ai/plugin": "*"

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;
-}>;