@bridge_gpt/mcp-server 0.2.45 → 0.2.48

package/build/conductor/tools.js

@@ -1,41 +1,20 @@
 /**
  * Conductor MCP tool registration.
  *
- * Exposes the local SQLite ledger operations as strict, Zod-backed MCP tools
- * that follow the existing Bridge MCP return convention
- * (`{ content: [{ type: "text", text }] }`). All ledger access is LOCAL — these
- * tools never round-trip through the Bridge API HTTP helpers. Every handler is
+ * Registers the conductor's single MCP tool, `get_epic_snapshot`, which reads
+ * the server-side Epic Run snapshot through the Bridge API. Its handler is
  * wrapped by {@link withConductorToolErrorHandling} so failures surface as
  * sanitized, structured JSON without raw payloads, stack traces, or secrets.
+ *
+ * BAPI-909: the local SQLite ledger, mailbox, event, and done-gate MCP tools
+ * (`emit_event`, `poll_events`, `wait_for_event`, `get_supervisor_snapshot`,
+ * `wait_for_done_gate`, `send_message`, `check_messages`) were removed. The
+ * conductor CLI and git hooks remain the ledger's real readers and writers —
+ * those paths are untouched and do not go through MCP.
  */
 import { z } from "zod";
-import { SEMANTIC_EVENT_TYPES } from "./taxonomy.js";
-import { ConductorValidationError, ConductorWorkerContextRequiredError, toConductorErrorEnvelope, } from "./errors.js";
-import { emitConductorEvent, pollConductorEvents, waitForConductorEvent, getSupervisorSnapshot, sendWorkerMessage, } from "./store.js";
-import { normalizePrNumber, normalizeSha } from "./git-ci-types.js";
-import { waitForDoneGate, resolveDispatchRunIdForBinding } from "./pr-ci-producer.js";
-// BAPI-527: worker-facing ledger operations run through the conductor CLI
-// subprocess (under the captured conductor Node), NOT the in-process SQLite store,
-// so the worker Node never loads the `better-sqlite3` native binary. `store.ts`'s
-// `checkWorkerMessages` is intentionally NOT imported here anymore.
-import { checkWorkerMessagesViaCli, emitConductorEventIfNewViaCli } from "./worker-ledger-cli.js";
+import { ConductorValidationError, toConductorErrorEnvelope } from "./errors.js";
 import { resolveConductorBridgeApiAccess, fetchEpicRunState, ConductorBridgeApiError } from "./bridge-api-client.js";
-/** Build a Zod enum from the semantic taxonomy so arbitrary types are rejected up front. */
-export function buildEventTypeZodEnum() {
-    return z.enum(SEMANTIC_EVENT_TYPES);
-}
-/** Allowlisted, parameterized read filter schema (shared by poll + wait). */
-const EventFilterSchema = z
-    .object({
-    type: buildEventTypeZodEnum().optional(),
-    types: z.array(buildEventTypeZodEnum()).optional(),
-    source: z.string().optional(),
-    run_id: z.string().optional(),
-    worker_id: z.string().optional(),
-    subject: z.string().optional(),
-    producer: z.string().optional(),
-})
-    .strict();
 function jsonResult(value) {
     return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
 }
@@ -57,128 +36,6 @@ export function withConductorToolErrorHandling(handler) {
         }
     };
 }
-function registerEmitEventTool(registerTool) {
-    registerTool("emit_event", {
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-        description: "Append a semantic coordination event to the LOCAL conductor ledger (~/.config/bridge/events.db). " +
-            "This is a local, append-only event store for multi-agent coordination — it does NOT call the Bridge API. " +
-            "Only the fixed semantic event taxonomy is accepted (e.g. run.started, agent.notification, ci.passed). " +
-            "Place tool-native fields (branch, commitSha, etc.) under data.raw — non-allowlisted top-level data keys are rejected. " +
-            "Secrets are redacted before storage and large payloads must be passed by reference (data.payload_ref / data.references).",
-        inputSchema: {
-            source: z.string().describe("Logical producer of the event (e.g. 'claude-code', 'git-hook')."),
-            type: buildEventTypeZodEnum().describe("Semantic event type from the fixed conductor taxonomy."),
-            subject: z.string().optional().describe("Optional subject the event is about (e.g. a ticket key)."),
-            run_id: z.string().optional().describe("Optional run/session identifier this event belongs to."),
-            worker_id: z.string().optional().describe("Optional worker/agent identifier."),
-            producer: z.string().optional().describe("Optional finer-grained producer identity."),
-            schema_version: z.number().int().positive().optional().describe("Event schema version (default 1)."),
-            time: z.string().optional().describe("Optional ISO-8601 event time (defaults to now)."),
-            data: z
-                .record(z.string(), z.unknown())
-                .optional()
-                .describe("Normalized event data. Allowed top-level keys: summary, status, message, details, reason, metrics, labels, references, payload_ref, raw. Tool-native fields go under 'raw'."),
-            confidence: z.number().min(0).max(1).optional().describe("Optional confidence in [0,1]."),
-            observed_via: z.string().optional().describe("Optional channel the event was observed through."),
-        },
-    }, withConductorToolErrorHandling(async (args) => {
-        const result = await emitConductorEvent({
-            source: args.source,
-            type: args.type,
-            subject: args.subject,
-            run_id: args.run_id,
-            worker_id: args.worker_id,
-            producer: args.producer,
-            schema_version: args.schema_version,
-            time: args.time,
-            data: args.data ?? {},
-            confidence: args.confidence,
-            observed_via: args.observed_via,
-        });
-        return jsonResult(result);
-    }));
-}
-function registerPollEventsTool(registerTool) {
-    registerTool("poll_events", {
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: false,
-        },
-        description: "Read ordered events from the LOCAL conductor ledger starting at an inclusive 'since_seq' cursor. " +
-            "Returns compact metadata-first summaries by default (data.raw omitted; raw_keys surfaced) and a 'next_seq' cursor to pass on the next call. " +
-            "Set data_mode='full' to retrieve complete (redacted) event data. Local read-only; does not call the Bridge API.",
-        inputSchema: {
-            since_seq: z.number().int().nonnegative().optional().describe("Inclusive sequence cursor (default 1)."),
-            filter: EventFilterSchema.optional().describe("Optional allowlisted filter."),
-            data_mode: z.enum(["summary", "full"]).optional().describe("Projection mode (default 'summary')."),
-            limit: z.number().int().positive().optional().describe("Max events to return (default 100, max 1000)."),
-        },
-    }, withConductorToolErrorHandling(async (args) => {
-        const result = await pollConductorEvents({
-            since_seq: args.since_seq ?? 1,
-            filter: args.filter,
-            data_mode: args.data_mode ?? "summary",
-            limit: args.limit,
-        });
-        return jsonResult(result);
-    }));
-}
-function registerWaitForEventTool(registerTool) {
-    registerTool("wait_for_event", {
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: false,
-        },
-        description: "Long-poll the LOCAL conductor ledger: block up to 'timeout_ms' (bounded, max 120000) until events matching the filter appear at/after 'since_seq'. " +
-            "Returns the same shape as poll_events plus 'timed_out'. SQLite locks are never held between polls. Local read-only; does not call the Bridge API.",
-        inputSchema: {
-            since_seq: z.number().int().nonnegative().optional().describe("Inclusive sequence cursor (default 1)."),
-            filter: EventFilterSchema.optional().describe("Optional allowlisted filter."),
-            data_mode: z.enum(["summary", "full"]).optional().describe("Projection mode (default 'summary')."),
-            timeout_ms: z.number().int().nonnegative().optional().describe("Max wait in ms (bounded, max 120000)."),
-            limit: z.number().int().positive().optional().describe("Max events to return (default 100, max 1000)."),
-        },
-    }, withConductorToolErrorHandling(async (args) => {
-        const result = await waitForConductorEvent({
-            since_seq: args.since_seq ?? 1,
-            filter: args.filter,
-            data_mode: args.data_mode ?? "summary",
-            timeout_ms: args.timeout_ms,
-            limit: args.limit,
-        });
-        return jsonResult(result);
-    }));
-}
-function registerGetSupervisorSnapshotTool(registerTool) {
-    registerTool("get_supervisor_snapshot", {
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: false,
-        },
-        description: "Read the supervisor projection for a run_id from the LOCAL conductor ledger. " +
-            "The projection is maintained by the conductor supervisor runtime (`conductor supervise --run-id <id>`), " +
-            "which owns the deterministic worker watchdog state; this tool ONLY reads that projection and never derives state from raw events. " +
-            "Returns { run_id, status, projection } where projection is null and status is 'unknown' when no projection exists yet. " +
-            "Local read-only; does not call the Bridge API.",
-        inputSchema: {
-            run_id: z.string().describe("The run/session identifier to read the supervisor projection for."),
-        },
-    }, withConductorToolErrorHandling(async (args) => {
-        const result = await getSupervisorSnapshot(args.run_id);
-        return jsonResult(result);
-    }));
-}
 function registerGetEpicSnapshotTool(registerTool) {
     registerTool("get_epic_snapshot", {
         annotations: {
@@ -213,206 +70,18 @@ function registerGetEpicSnapshotTool(registerTool) {
         }
     }));
 }
-const SHA_PATTERN = /^[0-9a-fA-F]{40}$|^[0-9a-fA-F]{64}$/;
-function registerWaitForDoneGateTool(registerTool) {
-    registerTool("wait_for_done_gate", {
-        annotations: {
-            // Read/write + non-idempotent: this tool can EMIT conductor events
-            // (git.pr_opened, ci.passed/failed, gate.met) as a side effect of observing.
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: true,
-        },
-        description: "Bounded wait for the conductor done-gate on a pull request. Resolves the PR number + immutable head SHA " +
-            "once, polls CI for that SHA on a clamped interval, and emits conductor events (git.pr_opened, ci.passed/ci.failed, " +
-            "and gate.met when the configured required CI checks are green). " +
-            "This EMITS conductor coordination events only — it does NOT merge the PR, transition Jira, or mutate any repository state. " +
-            "Fails closed: an unset/disabled/malformed conductor_done_gate config never produces gate.met.",
-        inputSchema: {
-            repo_name: z.string().optional().describe("Optional repo name override (defaults to BAPI_REPO_NAME/.bridge/config)."),
-            pr_number: z.number().int().positive().optional().describe("Optional explicit PR number (positive integer)."),
-            head_sha: z
-                .string()
-                .regex(SHA_PATTERN)
-                .optional()
-                .describe("Optional explicit head SHA (40- or 64-character hex)."),
-            timeout_ms: z.number().int().nonnegative().optional().describe("Max wait in ms (clamped, max 120000)."),
-            poll_interval_ms: z.number().int().nonnegative().optional().describe("CI poll interval in ms (clamped)."),
-            worktree_path: z.string().optional().describe("Optional worktree path to resolve git/PR context from."),
-        },
-    }, withConductorToolErrorHandling(async (args) => {
-        // Defensive boundary validation (mirrors the schema) so an invalid identifier
-        // is a sanitized 400 and never reaches waitForDoneGate.
-        if (args.pr_number !== undefined && normalizePrNumber(args.pr_number) === null) {
-            throw new ConductorValidationError("'pr_number' must be a positive integer.");
-        }
-        if (args.head_sha !== undefined && normalizeSha(args.head_sha) === null) {
-            throw new ConductorValidationError("'head_sha' must be a 40- or 64-character hex SHA.");
-        }
-        const result = await waitForDoneGate({
-            repoName: args.repo_name,
-            prNumber: args.pr_number,
-            headSha: args.head_sha,
-            timeoutMs: args.timeout_ms,
-            pollIntervalMs: args.poll_interval_ms,
-            worktreePath: args.worktree_path,
-        }, {
-            resolveRunId: resolveDispatchRunIdForBinding,
-            // BAPI-527: route the gate's ENTIRE dedup+emit through the conductor CLI
-            // subprocess. Injecting `emitIfNew` (not just the write sink) replaces the
-            // in-process `emitConductorEventIfNew`, whose `eventAlreadyExists` poll
-            // pre-check would load better-sqlite3 in the worker Node. The dedupe key +
-            // deterministic id are derived purely and the id is forwarded to the CLI,
-            // so dedup happens server-side on the events.id UNIQUE constraint — the
-            // worker path performs NO in-process ledger read or write.
-            //
-            // BAPI-772: this emit leg inherits the runtime contract from
-            // `resolveWorkerLedgerCliRuntime`, which is reached only when an emit is
-            // actually attempted — read-only gate work (binding resolution, CI
-            // polling) is never preemptively rejected. In a plain session with no
-            // worker env at all, that resolver raises WORKER_CONTEXT_REQUIRED, so the
-            // gate explains itself instead of surfacing an opaque 503; a partially
-            // configured or corrupted worker runtime still fails loud with
-            // LEDGER_SUBPROCESS_RUNTIME_UNAVAILABLE. Nothing falls back in-process.
-            emitIfNew: (input, dimensions) => emitConductorEventIfNewViaCli(input, dimensions),
-        });
-        return jsonResult({
-            gate_met: result.gate_met,
-            timed_out: result.timed_out,
-            reason: result.reason,
-            repo: result.repo,
-            pr_number: result.pr_number,
-            head_sha: result.head_sha,
-            gate_event_summary: result.gate_event_summary,
-        });
-    }));
-}
-function registerSendMessageTool(registerTool) {
-    registerTool("send_message", {
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            // Enqueueing the same idempotency key (run_id+worker_id+type+cause_seq)
-            // never inserts a second message, so the tool is idempotent.
-            idempotentHint: true,
-            openWorldHint: false,
-        },
-        description: "Enqueue a typed, auditable message for ONE worker through the LOCAL cooperative conductor relay " +
-            "(~/.config/bridge/events.db). The supervisor sends; the worker reads/acknowledges later via check_messages. " +
-            "This is COOPERATIVE — it does NOT inject into, mutate, or prompt-inject a live worker session. " +
-            "Idempotent: a duplicate idempotency key (run_id+worker_id+type+cause_seq) does not enqueue a second message, " +
-            "and a same-type message inside the cooldown window is suppressed. Local only; does not call the Bridge API.",
-        inputSchema: {
-            run_id: z.string().min(1).describe("Run/session identifier the message is scoped to."),
-            worker_id: z.string().min(1).describe("Target worker/agent identifier."),
-            type: z.string().min(1).describe("Typed message kind (e.g. 'supervisor.worker_stalled')."),
-            cause_seq: z
-                .number()
-                .int()
-                .nonnegative()
-                .describe("Idempotency cause sequence (the supervisor's last_seq at decision time)."),
-            payload: z
-                .record(z.string(), z.unknown())
-                .optional()
-                .default({})
-                .describe("Optional compact payload. Allowed top-level keys: summary, status, message, details, reason, metrics, labels, references, payload_ref, raw."),
-            available_at: z.string().optional().describe("Optional ISO-8601 time the message becomes available (default now)."),
-            cooldown_ms: z
-                .number()
-                .int()
-                .nonnegative()
-                .optional()
-                .describe("Optional per-call cooldown override in ms (falls back to the configured cooldown)."),
-        },
-    }, withConductorToolErrorHandling(async (args) => {
-        const result = await sendWorkerMessage({
-            run_id: args.run_id,
-            worker_id: args.worker_id,
-            type: args.type,
-            cause_seq: args.cause_seq,
-            payload: args.payload ?? {},
-            available_at: args.available_at,
-            cooldown_ms: args.cooldown_ms,
-        });
-        return jsonResult(result);
-    }));
-}
-function registerCheckMessagesTool(registerTool) {
-    registerTool("check_messages", {
-        annotations: {
-            // Reads AND acknowledges (mutates pending -> acked), so not read-only and
-            // not idempotent: the first call returns+acks pending messages, later
-            // calls return none.
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-        description: "Worker checkpoint poll for the LOCAL cooperative conductor relay. Call this at natural checkpoints to read " +
-            "any supervisor messages addressed to this worker. Returned messages are ACKNOWLEDGED by this call and are " +
-            "NOT redelivered on later polls. This is cooperative polling — it is NOT live prompt injection. " +
-            "run_id/worker_id default to BAPI_CONDUCTOR_RUN_ID / BAPI_CONDUCTOR_WORKER_ID from the environment when omitted. " +
-            "Local only; does not call the Bridge API.",
-        inputSchema: {
-            run_id: z.string().optional().describe("Run identifier (defaults to BAPI_CONDUCTOR_RUN_ID)."),
-            worker_id: z.string().optional().describe("Worker identifier (defaults to BAPI_CONDUCTOR_WORKER_ID)."),
-            limit: z.number().int().positive().max(100).optional().describe("Max messages to deliver/ack (default 10, max 100)."),
-        },
-    }, withConductorToolErrorHandling(async (args) => {
-        const runIdArg = args.run_id;
-        const workerIdArg = args.worker_id;
-        const runIdEnv = process.env.BAPI_CONDUCTOR_RUN_ID;
-        const workerIdEnv = process.env.BAPI_CONDUCTOR_WORKER_ID;
-        // BAPI-772: a call with NEITHER argument supplied and NEITHER env var set is
-        // a plain MCP session — nothing is broken, the tool is simply worker-scoped.
-        // Return the typed guidance envelope instead of an opaque validation error.
-        // Any other shape (an explicit blank id, one id present and the other not, a
-        // partially-set worker env) is still malformed identity and keeps the
-        // existing fail-loud VALIDATION_ERROR: a broken worker context must never be
-        // relabeled as an ordinary session.
-        if (runIdArg === undefined &&
-            workerIdArg === undefined &&
-            runIdEnv === undefined &&
-            workerIdEnv === undefined) {
-            throw new ConductorWorkerContextRequiredError([
-                "BAPI_CONDUCTOR_RUN_ID",
-                "BAPI_CONDUCTOR_WORKER_ID",
-            ]);
-        }
-        const runId = runIdArg ?? runIdEnv ?? "";
-        const workerId = workerIdArg ?? workerIdEnv ?? "";
-        if (runId.trim().length === 0 || workerId.trim().length === 0) {
-            throw new ConductorValidationError("Conductor worker identity is unavailable: provide run_id + worker_id, or set BAPI_CONDUCTOR_RUN_ID and BAPI_CONDUCTOR_WORKER_ID.");
-        }
-        // BAPI-527: read+ack through the conductor CLI subprocess (captured
-        // conductor Node), NOT the in-process store, so the worker Node never loads
-        // better-sqlite3. A missing/invalid CONDUCTOR_NODE_PATH surfaces as the
-        // typed LEDGER_SUBPROCESS_RUNTIME_UNAVAILABLE envelope via the wrapper below.
-        const result = await checkWorkerMessagesViaCli({
-            runId,
-            workerId,
-            limit: args.limit,
-        });
-        return jsonResult(result);
-    }));
-}
 /**
- * Register all conductor MCP tools through the host's `registerTool` wrapper.
- * Keeping registration in this single module keeps `index.ts` thin. The host's
- * `registerTool` is the SDK's heavily-generic signature, so it is accepted as
- * `unknown` here and narrowed once to {@link RegisterToolFn} — our handlers
- * return the same `{ content: [{ type: "text", text }] }` shape every Bridge
- * tool uses, just expressed with a simpler local type.
+ * Register the conductor MCP tool surface through the host's `registerTool`
+ * wrapper. Keeping registration in this single module keeps `index.ts` thin.
+ * The host's `registerTool` is the SDK's heavily-generic signature, so it is
+ * accepted as `unknown` here and narrowed once to {@link RegisterToolFn} — our
+ * handler returns the same `{ content: [{ type: "text", text }] }` shape every
+ * Bridge tool uses, just expressed with a simpler local type.
+ *
+ * BAPI-909 reduced this registrar to `get_epic_snapshot`. It stays a registrar
+ * rather than a bare call so the `conductor` group keeps one registration seam.
  */
 export function registerConductorTools(registerTool) {
     const reg = registerTool;
-    registerEmitEventTool(reg);
-    registerPollEventsTool(reg);
-    registerWaitForEventTool(reg);
-    registerGetSupervisorSnapshotTool(reg);
     registerGetEpicSnapshotTool(reg);
-    registerWaitForDoneGateTool(reg);
-    registerSendMessageTool(reg);
-    registerCheckMessagesTool(reg);
 }