@zeroroot-ai/zerocool-claude 0.5.2 → 0.6.1

package/dist/server.js

@@ -1,34 +0,0 @@
-#!/usr/bin/env node
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { buildServer, log } from "./build.js";
-import { clearLive, stateDir } from "./state.js";
-import { describeGibson } from "./tools/status.js";
-/**
- * The MCP server bin. This file runs main() unconditionally: npm installs
- * bins as symlinks named after the bin (`zerocool-claude-mcp`), so any
- * "am I the entry point" check on argv[1] is false there and the process
- * exits before it serves anything. Library code lives in build.ts.
- */
-async function main() {
-    const cwd = process.cwd();
-    const surface = await buildServer(process.env, cwd);
-    const { server } = surface;
-    log(`[zerocool-claude] ${describeGibson(surface.current()).replaceAll("\n", "; ")}`);
-    let closing = false;
-    const close = async () => {
-        if (closing)
-            return;
-        closing = true;
-        await clearLive(stateDir(process.env), cwd).catch(() => { });
-        await surface.current().close().catch((e) => log(`[zerocool-claude] close: ${e.message}`));
-    };
-    // Claude Code ends the session by closing stdio. The mission ends with it.
-    process.stdin.on("close", () => void close().finally(() => process.exit(0)));
-    for (const sig of ["SIGINT", "SIGTERM"])
-        process.on(sig, () => void close().finally(() => process.exit(0)));
-    await server.connect(new StdioServerTransport());
-}
-main().catch((e) => {
-    log(`[zerocool-claude] fatal: ${e.message}`);
-    process.exit(1);
-});

package/dist/session.d.ts

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

package/dist/session.js

@@ -1,142 +0,0 @@
-import { existsSync } from "node:fs";
-import { componentKnowledge, connectGibson, readSandboxDispatch, sandboxHarness, SANDBOX_ENV, startLiveMission, taskKnowledge, } from "@zeroroot-ai/sdk";
-import { submitMission } from "./cli.js";
-import { decideMode } from "./mode.js";
-import { trustCA } from "./tls.js";
-export { DEFAULT_AGENT_NAME } from "./config.js";
-/**
- * Check in, then make the session a live mission. Fails open at every step:
- * a platform failure lands one posture down, never in a refusal to start.
- */
-export async function openGibson(opts) {
-    const { settings, log } = opts;
-    const env = opts.env ?? {};
-    if (env[SANDBOX_ENV.grant] && env[SANDBOX_ENV.callbackEndpoint]) {
-        return openSandboxTask(env, settings, log, opts.trust);
-    }
-    const { hostKeyPath, agentName } = settings;
-    const hostKeyExists = (opts.hostKeyExists ?? existsSync)(hostKeyPath);
-    const decision = decideMode({ platformURL: settings.platformURL, bootstrapToken: settings.bootstrapToken, hostKeyExists, targetId: settings.targetId }, hostKeyPath);
-    const standalone = (reason) => ({ mode: "standalone", reason, agentName, hostKeyPath, settings, close: async () => { } });
-    if (decision.mode === "standalone") {
-        log(`[zerocool-claude] standalone: ${decision.reason}`);
-        return standalone(decision.reason);
-    }
-    if (settings.caCertPath) {
-        try {
-            await (opts.trust ?? trustCA)(settings.caCertPath);
-        }
-        catch (e) {
-            log(`[zerocool-claude] CA at ${settings.caCertPath} not loaded: ${e.message}`);
-        }
-    }
-    // The bootstrap token is passed ONLY when no host key exists yet. Replaying a
-    // one-time token on every start would be rejected (gibson
-    // capabilitygrant_register.go:134-155).
-    const bootstrapToken = hostKeyExists ? undefined : settings.bootstrapToken;
-    let session;
-    try {
-        session = await (opts.connect ?? connectGibson)({
-            platformURL: settings.platformURL,
-            daemonURL: settings.daemonURL,
-            bootstrapToken,
-            hostKeyPath,
-            agentName,
-            agentMode: "interactive",
-            agent: { name: agentName, version: "0.0.0", capabilities: ["code"] },
-        });
-    }
-    catch (e) {
-        const reason = `Gibson connect failed: ${e.message}`;
-        log(`[zerocool-claude] ${reason}; continuing standalone`);
-        return standalone(reason);
-    }
-    log(`[zerocool-claude] checked in via ${hostKeyExists ? "the registered host key" : "first check-in"} ` +
-        `as ${agentName} (component_scope=${session.componentScope})`);
-    if (!hostKeyExists)
-        log(`[zerocool-claude] host key written to ${hostKeyPath}; the bootstrap token is spent`);
-    const component = {
-        mode: "component",
-        reason: decision.reason,
-        agentName,
-        hostKeyPath,
-        settings,
-        session,
-        knowledge: componentKnowledge(session.clients.component),
-        close: async () => session.stop(),
-    };
-    if (decision.mode === "component") {
-        log(`[zerocool-claude] component posture: ${decision.reason}`);
-        return component;
-    }
-    let live;
-    try {
-        live = await (opts.start ?? startLiveMission)(session, {
-            agentName,
-            targetId: settings.targetId,
-            // The person originates the session mission through the CLI login
-            // session; the component only claims its dispatch (gibson ADR-0063).
-            originate: opts.originate ?? ((definition, targetId) => submitMission(definition, targetId)),
-            harness: { insecure: settings.callbackInsecure },
-        });
-    }
-    catch (e) {
-        const reason = `live mission failed: ${e.message}`;
-        log(`[zerocool-claude] ${reason}; continuing as a component`);
-        return { ...component, reason };
-    }
-    log(`[zerocool-claude] live mission ${live.missionId} (work ${live.workId}); reads and writes use the task grant`);
-    let closed = false;
-    return {
-        mode: "live",
-        reason: "",
-        agentName,
-        hostKeyPath,
-        settings,
-        session,
-        live,
-        knowledge: taskKnowledge(live.harness),
-        close: async () => {
-            if (closed)
-                return;
-            closed = true;
-            try {
-                await live.end({ output: { ended: "session closed" } });
-            }
-            finally {
-                session.stop();
-            }
-        },
-    };
-}
-/**
- * The task posture: this process is a sandboxed dispatch. The launch already
- * decided everything; the plugin only opens the task harness from the grant
- * and serves the tools that run under it. No host key, no check-in, no
- * mission creation, and nothing to fail open to: a sandbox without a
- * usable grant has no reason to exist, so this throws.
- */
-async function openSandboxTask(env, settings, log, trust) {
-    const d = readSandboxDispatch(env);
-    if (settings.caCertPath)
-        await (trust ?? trustCA)(settings.caCertPath).catch((e) => log(`[zerocool-claude] CA not loaded: ${e.message}`));
-    const harness = sandboxHarness(d, { insecure: settings.callbackInsecure });
-    const live = {
-        missionId: d.missionId,
-        workId: d.missionRunId,
-        harness,
-        // The sandbox reports completion by exiting; the launcher owns the node.
-        end: async () => harness.stop(),
-    };
-    log(`[zerocool-claude] task posture: mission ${d.missionId} run ${d.missionRunId}; reads and writes use the dispatch grant`);
-    return {
-        mode: "task",
-        reason: "",
-        agentName: settings.agentName,
-        hostKeyPath: settings.hostKeyPath,
-        settings,
-        live,
-        knowledge: taskKnowledge(harness),
-        close: async () => harness.stop(),
-    };
-}

package/dist/tls.d.ts

@@ -1 +0,0 @@
-export declare function trustCA(path: string): Promise<void>;

package/dist/tls.js

@@ -1,19 +0,0 @@
-import { readFile } from "node:fs/promises";
-import tls from "node:tls";
-/**
- * Trust a private CA for every TLS client in this process, at runtime.
- *
- * A self-hosted Gibson (kind, on-prem) fronts its edge with its own CA. Node
- * reads NODE_EXTRA_CA_CERTS only at start, and the connect happens mid-session,
- * so the CA is added through `tls.setDefaultCACertificates` (Node 22.15+).
- * Both `fetch` (the Capability Grant register call) and the gRPC transports
- * use the default CA set, so one call covers all of them.
- */
-const trusted = new Set();
-export async function trustCA(path) {
-    if (trusted.has(path))
-        return;
-    const pem = await readFile(path, "utf8");
-    tls.setDefaultCACertificates([...tls.getCACertificates("default"), pem]);
-    trusted.add(path);
-}

package/dist/tools/componentize.d.ts

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

package/dist/tools/componentize.js

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

package/dist/tools/delegate.d.ts

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

package/dist/tools/delegate.js

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

package/dist/tools/findings.d.ts

@@ -1,24 +0,0 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { type Finding, type TaskHarness } from "@zeroroot-ai/sdk";
-import type { Gibson } from "../session.js";
-export interface FindingsBackend {
-    submit(f: Finding): Promise<string>;
-    describe(): string;
-}
-/** Platform backend: the finding lands in the tenant knowledge graph. */
-export declare function gibsonFindingsBackend(g: Gibson): FindingsBackend;
-/**
- * Task backend: the callback service's typed SubmitFinding, under the
- * dispatch grant. Fields map from the SDK's JSON finding onto
- * gibson.types.v1.Finding; the daemon assigns the id and the mission.
- */
-export declare function taskFindingsBackend(harness: TaskHarness): FindingsBackend;
-/** Standalone backend: an append-only JSONL log. */
-export declare function localFindingsBackend(path: string): FindingsBackend;
-/**
- * Findings: emit what the agent discovers (zerocool-plugins#7). The model
- * calls this when it finds something. Nothing here emits on its own: a file
- * edit is not a security finding, and inventing one fills the tenant graph
- * with noise a person then has to triage.
- */
-export declare function registerFindingTools(server: McpServer, g: Gibson, backend: FindingsBackend): void;

package/dist/tools/findings.js

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

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

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