@zeroroot-ai/zerocool 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ZeroRoot
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/componentize.d.ts

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,149 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,216 @@
+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/findings.d.ts

@@ -0,0 +1,27 @@
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import { type Finding, type GibsonSession } from "@zeroroot-ai/sdk";
+export interface FindingsBackend {
+    /** Submit a finding; returns the identifier it was recorded under. */
+    submit(f: Finding): Promise<string>;
+    /** Where findings go, for the tool's result message. */
+    describe(): string;
+}
+/** Platform backend — findings land in the tenant knowledge graph. */
+export declare function gibsonFindingsBackend(session: GibsonSession): FindingsBackend;
+/**
+ * Standalone backend — findings are appended as JSONL. The same Finding shape is
+ * written, so a local log can be replayed into Gibson later.
+ */
+export declare function localFindingsBackend(path: string): FindingsBackend;
+/** Provenance stamped onto every finding this session emits. */
+export interface SessionContext {
+    /** opencode session ID, recorded as the finding's mission correlation. */
+    sessionID?: string;
+}
+/**
+ * Build the `submit_finding` tool.
+ *
+ * `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

@@ -0,0 +1,109 @@
+import { tool } from "@opencode-ai/plugin";
+import { newFinding, 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 {
+        submit: (f) => submitFinding(session.clients.component, f),
+        describe: () => "the tenant Gibson graph",
+    };
+}
+/**
+ * Standalone backend — findings are appended as JSONL. The same Finding shape is
+ * written, so a local log can be replayed into Gibson later.
+ */
+export function localFindingsBackend(path) {
+    return {
+        submit: async (f) => {
+            await mkdir(dirname(path), { recursive: true });
+            await appendFile(path, `${JSON.stringify(f)}\n`, "utf8");
+            return f.id;
+        },
+        describe: () => path,
+    };
+}
+/**
+ * Build the `submit_finding` tool.
+ *
+ * `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/gibson-tools.d.ts

@@ -0,0 +1,45 @@
+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;
+}>;