@a5c-ai/tasks-adapter 5.1.1-staging.00ceebd28cf2

package/dist/mcp/server.js

@@ -0,0 +1,259 @@
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { EmptyResultSchema, SubscribeRequestSchema, UnsubscribeRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { askBreakpointDescription, askBreakpointParams, handleAskBreakpoint, } from "./tools/ask-breakpoint.js";
+import { checkBreakpointStatusDescription, checkBreakpointStatusParams, handleCheckBreakpointStatus, } from "./tools/check-status.js";
+import { listBreakpointsDescription, listBreakpointsParams, handleListBreakpoints, } from "./tools/list-breakpoints.js";
+import { answerBreakpointDescription, answerBreakpointParams, handleAnswerBreakpoint, } from "./tools/answer-breakpoint.js";
+import { verifyBreakpointAnswerDescription, verifyBreakpointAnswerParams, handleVerifyBreakpointAnswer, } from "./tools/verify-answer.js";
+import { listRespondersDescription, listRespondersParams, handleListResponders, } from "./tools/list-responders.js";
+import { assignTaskDescription, assignTaskParams, addCommentDescription, addCommentParams, addCommentToBreakpointDescription, addCommentToBreakpointParams, bulkUpdateTasksDescription, bulkUpdateTasksParams, cancelBreakpointDescription, cancelBreakpointParams, createTaskDescription, createTaskParams, createTodoDescription, createTodoParams, escalateDescription, escalateBreakpointDescription, escalateBreakpointParams, escalateParams, exportTasksDescription, exportTasksParams, handleAssignTask, handleAddComment, handleAddCommentToBreakpoint, handleBulkUpdateTasks, handleCancelBreakpoint, handleCreateTask, handleCreateTodo, handleEscalate, handleEscalateBreakpoint, handleExportTasks, handleSearchTasks, handleTaskStats, searchTasksDescription, searchTasksParams, taskStatsDescription, taskStatsParams, } from "./tools/native-tasks.js";
+import { claimBreakpointDescription, claimBreakpointParams, handleClaimBreakpoint, } from "./tools/claim-breakpoint.js";
+import { pollBreakpointsDescription, pollBreakpointsParams, handlePollBreakpoints, } from "./tools/poll-breakpoints.js";
+import { resolveBreakpointBackend } from "./backend-resolver.js";
+import { createDefaultBackend } from "../backends/index.js";
+/**
+ * Resolve the backend for an MCP tool call.
+ * Uses the backend-resolver (env var, routing config) or defaults to git-native.
+ */
+function resolveToolBackend(params) {
+    if (!params?.backend && params?.breakpointsDir) {
+        return createDefaultBackend({ breakpointsDir: params.breakpointsDir });
+    }
+    const { backend } = resolveBreakpointBackend({
+        explicitBackend: params?.backend,
+        breakpointsDir: params?.breakpointsDir,
+        domain: params?.domain,
+        tags: params?.tags,
+    });
+    return backend;
+}
+function toCompatShape(shape) {
+    return shape;
+}
+/**
+ * Create a tasks-adapter MCP server with breakpoint, responder, and native task tools registered.
+ */
+export function createBreakpointMcpServer() {
+    const server = new McpServer({
+        name: "tasks-adapter",
+        version: "0.1.0",
+    }, {
+        capabilities: {
+            resources: {
+                listChanged: true,
+                subscribe: true,
+            },
+        },
+    });
+    const subscribedResources = new Set();
+    server.server.setRequestHandler(SubscribeRequestSchema, (request) => {
+        subscribedResources.add(request.params.uri);
+        return EmptyResultSchema.parse({});
+    });
+    server.server.setRequestHandler(UnsubscribeRequestSchema, (request) => {
+        subscribedResources.delete(request.params.uri);
+        return EmptyResultSchema.parse({});
+    });
+    server.registerResource("breakpoint", new ResourceTemplate("breakpoint://{id}", {
+        list: async () => {
+            const backend = resolveToolBackend();
+            if (!backend.searchBreakpoints)
+                return { resources: [] };
+            const result = await backend.searchBreakpoints({});
+            return {
+                resources: result.items.map((breakpoint) => ({
+                    uri: `breakpoint://${breakpoint.id}`,
+                    name: breakpoint.id,
+                    description: breakpoint.text,
+                    mimeType: "application/json",
+                })),
+            };
+        },
+    }), {
+        title: "Breakpoint",
+        description: "Read a breakpoint by id using breakpoint://[id]. Subscribe to the URI to receive resource update notifications from transports that support them.",
+        mimeType: "application/json",
+    }, async (uri, variables) => {
+        const id = String(variables.id);
+        const breakpoint = await resolveToolBackend().getBreakpoint(id);
+        return {
+            contents: [{
+                    uri: uri.toString(),
+                    mimeType: "application/json",
+                    text: JSON.stringify({
+                        ...breakpoint,
+                        subscribed: subscribedResources.has(uri.toString()),
+                    }, null, 2),
+                }],
+        };
+    });
+    // ── Submitter-side tools ──────────────────────────────────────────────
+    server.tool("ask_breakpoint", askBreakpointDescription, toCompatShape(askBreakpointParams), async (args) => {
+        const backend = resolveToolBackend(args);
+        const result = await handleAskBreakpoint(args, backend);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("check_breakpoint_status", checkBreakpointStatusDescription, toCompatShape(checkBreakpointStatusParams), async (args) => {
+        const backend = resolveToolBackend(args);
+        const result = await handleCheckBreakpointStatus(args, backend);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("list_breakpoints", listBreakpointsDescription, toCompatShape(listBreakpointsParams), async (args) => {
+        const backend = resolveToolBackend(args);
+        const result = await handleListBreakpoints(args, backend);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("create_todo", createTodoDescription, toCompatShape(createTodoParams), async (args) => {
+        const backend = resolveToolBackend(args);
+        const result = await handleCreateTodo(args, backend);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("create_task", createTaskDescription, toCompatShape(createTaskParams), async (args) => {
+        const backend = resolveToolBackend(args);
+        const result = await handleCreateTask(args, backend);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("assign_task", assignTaskDescription, toCompatShape(assignTaskParams), async (args) => {
+        const backend = resolveToolBackend(args);
+        const result = await handleAssignTask(args, backend);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("search_tasks", searchTasksDescription, toCompatShape(searchTasksParams), async (args) => {
+        const backend = resolveToolBackend(args);
+        const result = await handleSearchTasks(args, backend);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("cancel_breakpoint", cancelBreakpointDescription, toCompatShape(cancelBreakpointParams), async (args) => {
+        const backend = resolveToolBackend(args);
+        const result = await handleCancelBreakpoint(args, backend);
+        await server.server.sendResourceUpdated({ uri: `breakpoint://${args.breakpointId}` }).catch(() => { });
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("add_comment", addCommentDescription, toCompatShape(addCommentParams), async (args) => {
+        const backend = resolveToolBackend(args);
+        const result = await handleAddComment(args, backend);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("add_comment_to_breakpoint", addCommentToBreakpointDescription, toCompatShape(addCommentToBreakpointParams), async (args) => {
+        const backend = resolveToolBackend(args);
+        const result = await handleAddCommentToBreakpoint(args, backend);
+        await server.server.sendResourceUpdated({ uri: `breakpoint://${args.breakpointId}` }).catch(() => { });
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("bulk_update_tasks", bulkUpdateTasksDescription, toCompatShape(bulkUpdateTasksParams), async (args) => {
+        const backend = resolveToolBackend(args);
+        const result = await handleBulkUpdateTasks(args, backend);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("task_stats", taskStatsDescription, toCompatShape(taskStatsParams), async (args) => {
+        const backend = resolveToolBackend(args);
+        const result = await handleTaskStats(args, backend);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("export_tasks", exportTasksDescription, toCompatShape(exportTasksParams), async (args) => {
+        const backend = resolveToolBackend(args);
+        const result = await handleExportTasks(args, backend);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("escalate", escalateDescription, toCompatShape(escalateParams), async (args) => {
+        const backend = resolveToolBackend(args);
+        const result = await handleEscalate(args, backend);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("escalate_breakpoint", escalateBreakpointDescription, toCompatShape(escalateBreakpointParams), async (args) => {
+        const backend = resolveToolBackend(args);
+        const result = await handleEscalateBreakpoint(args, backend);
+        await server.server.sendResourceUpdated({ uri: `breakpoint://${args.breakpointId}` }).catch(() => { });
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("answer_breakpoint", answerBreakpointDescription, toCompatShape(answerBreakpointParams), async (args) => {
+        const backend = resolveToolBackend(args);
+        const result = await handleAnswerBreakpoint(args, backend);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("verify_breakpoint_answer", verifyBreakpointAnswerDescription, toCompatShape(verifyBreakpointAnswerParams), async (args) => {
+        const backend = resolveToolBackend(args);
+        const result = await handleVerifyBreakpointAnswer(args, backend);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    // ── Responder-side tools ──────────────────────────────────────────────
+    server.tool("list_responders", listRespondersDescription, toCompatShape(listRespondersParams), async (args) => {
+        const backend = resolveToolBackend(args);
+        const result = await handleListResponders(args, backend);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("claim_breakpoint", claimBreakpointDescription, toCompatShape(claimBreakpointParams), async (args) => {
+        const backend = resolveToolBackend(args);
+        const result = await handleClaimBreakpoint(args, backend);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("poll_breakpoints", pollBreakpointsDescription, toCompatShape(pollBreakpointsParams), async (args) => {
+        const backend = resolveToolBackend(args);
+        const result = await handlePollBreakpoints(args, backend);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    return server;
+}
+/**
+ * Start the tasks-adapter MCP server on stdio transport.
+ */
+export async function startBreakpointMcpServer() {
+    const server = createBreakpointMcpServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+/**
+ * Start the tasks-adapter MCP server on HTTP transport with Streamable HTTP.
+ *
+ * The HTTP server provides:
+ * - POST/GET/DELETE /mcp -- MCP Streamable HTTP transport
+ * - GET /healthz -- health check
+ * - Bearer token authentication (when BPX_MCP_TOKEN is set or token is provided)
+ */
+export async function startHttpBreakpointMcpServer(options) {
+    // Dynamic import to avoid pulling in http-transport for stdio-only usage
+    const { startHttpMcpServer } = await import("./http-transport.js");
+    const server = createBreakpointMcpServer();
+    return startHttpMcpServer(server, options);
+}

package/dist/mcp/tools/answer-breakpoint.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import type { BreakpointBackend } from "../../backend.js";
+import type { BreakpointPublicAnswer } from "../../types.js";
+export declare const answerBreakpointDescription: string;
+export declare const answerBreakpointParams: {
+    breakpointId: z.ZodString;
+    text: z.ZodString;
+    approved: z.ZodOptional<z.ZodBoolean>;
+    responderId: z.ZodString;
+    responderName: z.ZodString;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    references: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    sign: z.ZodOptional<z.ZodBoolean>;
+    keyFingerprint: z.ZodOptional<z.ZodString>;
+    backend: z.ZodOptional<z.ZodString>;
+    breakpointsDir: z.ZodOptional<z.ZodString>;
+};
+export interface AnswerBreakpointParams {
+    breakpointId: string;
+    text: string;
+    approved?: boolean;
+    responderId: string;
+    responderName: string;
+    confidence?: number;
+    references?: string[];
+    sign?: boolean;
+    keyFingerprint?: string;
+    backend?: string;
+    breakpointsDir?: string;
+}
+export declare function handleAnswerBreakpoint(params: AnswerBreakpointParams, backend: BreakpointBackend): Promise<BreakpointPublicAnswer>;
+//# sourceMappingURL=answer-breakpoint.d.ts.map

package/dist/mcp/tools/answer-breakpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"answer-breakpoint.d.ts","sourceRoot":"","sources":["../../../src/mcp/tools/answer-breakpoint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,iBAAiB,EAAsB,MAAM,kBAAkB,CAAC;AAC9E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAI7D,eAAO,MAAM,2BAA2B,QAEC,CAAC;AAI1C,eAAO,MAAM,sBAAsB;;;;;;;;;;;;CAsBlC,CAAC;AAIF,MAAM,WAAW,sBAAsB;IACrC,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAID,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,sBAAsB,EAC9B,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,sBAAsB,CAAC,CA2BjC"}

package/dist/mcp/tools/answer-breakpoint.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+// ── Tool Description ────────────────────────────────────────────────────
+export const answerBreakpointDescription = "Submit an answer to a pending breakpoint. Optionally sign the answer " +
+    "cryptographically for verified trust.";
+// ── Tool Param Schema ───────────────────────────────────────────────────
+export const answerBreakpointParams = {
+    breakpointId: z.string().describe("The ID of the breakpoint to answer."),
+    text: z.string().describe("The answer text."),
+    approved: z.boolean().optional().describe("For approval-type breakpoints, whether to approve or reject."),
+    responderId: z.string().describe("Your responder identity."),
+    responderName: z.string().describe("Your display name."),
+    confidence: z.number().min(0).max(100).optional().describe("Confidence level 0-100. Defaults to 80."),
+    references: z.array(z.string()).optional().describe("Supporting references or links."),
+    sign: z.boolean().optional().describe("When true, cryptographically sign the answer with your private key."),
+    keyFingerprint: z.string().optional().describe("Ed25519 key fingerprint to use for signing. Required when sign=true."),
+    backend: z.string().optional(),
+    breakpointsDir: z.string().optional(),
+};
+// ── Handler ─────────────────────────────────────────────────────────────
+export async function handleAnswerBreakpoint(params, backend) {
+    if (!params.breakpointId || params.breakpointId.length === 0) {
+        throw new Error("breakpointId is required and must be non-empty");
+    }
+    if (!params.text && params.text !== "") {
+        throw new Error("text is required");
+    }
+    if (!params.responderId || params.responderId.length === 0) {
+        throw new Error("responderId is required and must be non-empty");
+    }
+    if (!params.responderName || params.responderName.length === 0) {
+        throw new Error("responderName is required and must be non-empty");
+    }
+    const answerParams = {
+        responderId: params.responderId,
+        responderName: params.responderName,
+        text: params.text,
+        approved: params.approved,
+        confidence: params.confidence,
+        references: params.references,
+        sign: params.sign,
+        keyFingerprint: params.keyFingerprint,
+    };
+    const answer = await backend.answerBreakpoint(params.breakpointId, answerParams);
+    return answer;
+}

package/dist/mcp/tools/ask-breakpoint.d.ts

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import type { BreakpointBackend } from "../../backend.js";
+import type { BreakpointWaitResult } from "../../types.js";
+export declare const askBreakpointDescription: string;
+export declare const askBreakpointParams: {
+    question: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    markdown: z.ZodOptional<z.ZodString>;
+    codeSnippets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        filename: z.ZodString;
+        code: z.ZodString;
+        language: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        filename: string;
+        language?: string | undefined;
+    }, {
+        code: string;
+        filename: string;
+        language?: string | undefined;
+    }>, "many">>;
+    fileReferences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    domain: z.ZodOptional<z.ZodString>;
+    urgency: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+    interactionKind: z.ZodOptional<z.ZodEnum<["clarification", "approval", "intervention", "notification", "handoff"]>>;
+    targetResponders: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    routingStrategy: z.ZodDefault<z.ZodEnum<["single", "first-response-wins", "collect-all", "quorum"]>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    breakpointId: z.ZodOptional<z.ZodString>;
+    backend: z.ZodOptional<z.ZodString>;
+    breakpointsDir: z.ZodOptional<z.ZodString>;
+    proven: z.ZodOptional<z.ZodBoolean>;
+};
+export interface AskBreakpointParams {
+    question: string;
+    context?: string;
+    markdown?: string;
+    codeSnippets?: Array<{
+        filename: string;
+        code: string;
+        language?: string;
+    }>;
+    fileReferences?: string[];
+    tags?: string[];
+    domain?: string;
+    urgency?: "low" | "medium" | "high";
+    interactionKind?: "clarification" | "approval" | "intervention" | "notification" | "handoff";
+    targetResponders?: string[];
+    routingStrategy?: "single" | "first-response-wins" | "collect-all" | "quorum";
+    timeout?: number;
+    breakpointId?: string;
+    backend?: string;
+    breakpointsDir?: string;
+    proven?: boolean;
+}
+export declare function handleAskBreakpoint(params: AskBreakpointParams, backend: BreakpointBackend): Promise<BreakpointWaitResult>;
+//# sourceMappingURL=ask-breakpoint.d.ts.map

package/dist/mcp/tools/ask-breakpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ask-breakpoint.d.ts","sourceRoot":"","sources":["../../../src/mcp/tools/ask-breakpoint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,OAAO,KAAK,EAAE,iBAAiB,EAA0B,MAAM,kBAAkB,CAAC;AAElF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAK3D,eAAO,MAAM,wBAAwB,QAImB,CAAC;AAIzD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqD/B,CAAC;AAIF,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC5E,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IACpC,eAAe,CAAC,EAAE,eAAe,GAAG,UAAU,GAAG,cAAc,GAAG,cAAc,GAAG,SAAS,CAAC;IAC7F,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,eAAe,CAAC,EAAE,QAAQ,GAAG,qBAAqB,GAAG,aAAa,GAAG,QAAQ,CAAC;IAC9E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAID,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,oBAAoB,CAAC,CA+C/B"}

package/dist/mcp/tools/ask-breakpoint.js

@@ -0,0 +1,78 @@
+import { z } from "zod";
+import { selectBreakpointAnswer, supportsProvenAnswers, unsupportedBackendFeatureMessage, } from "../../backend.js";
+import { isProvenBreakpointAnswer } from "../../types.js";
+import { DEFAULT_TIMEOUT_MS } from "../../types.js";
+// ── Tool Description ────────────────────────────────────────────────────
+export const askBreakpointDescription = "Submit a breakpoint question and wait for a human responder's answer. " +
+    "Use this when you encounter a decision, approval, or question that " +
+    "requires human judgment. The tool blocks until an answer is received, " +
+    "the timeout elapses, or the breakpoint is cancelled.";
+// ── Tool Param Schema ───────────────────────────────────────────────────
+export const askBreakpointParams = {
+    question: z.string().describe("The breakpoint question text."),
+    context: z.string().optional().describe("Additional context: what was tried, relevant code, etc."),
+    markdown: z.string().optional().describe("Rich markdown context for rendering."),
+    codeSnippets: z.array(z.object({
+        filename: z.string(),
+        code: z.string(),
+        language: z.string().optional(),
+    })).optional().describe("Structured code snippets with metadata."),
+    fileReferences: z.array(z.string()).optional().describe("File paths relevant to the breakpoint."),
+    tags: z.array(z.string()).optional().describe("Keywords for categorizing and routing the breakpoint."),
+    domain: z.string().optional().describe("Domain area (e.g., 'backend', 'security', 'devops')."),
+    urgency: z.enum(["low", "medium", "high"]).optional().describe("Urgency level of the breakpoint."),
+    interactionKind: z.enum([
+        "clarification", "approval", "intervention", "notification", "handoff",
+    ]).optional().describe("Semantic classification of the interaction type."),
+    targetResponders: z.array(z.string()).optional().describe("Specific responder IDs to route this breakpoint to."),
+    routingStrategy: z.enum([
+        "single", "first-response-wins", "collect-all", "quorum",
+    ]).default("first-response-wins").describe("How to route the breakpoint to responders."),
+    timeout: z.number().positive().optional().describe("Timeout in milliseconds. Defaults to 30 minutes."),
+    breakpointId: z.string().optional().describe("Canonical breakpoint identity for cross-run matching and auto-approval rules."),
+    backend: z.string().optional().describe("Explicit backend to use (e.g., 'git-native'). Defaults to configured backend."),
+    breakpointsDir: z.string().optional().describe("Path to .breakpoints directory (git-native backend)."),
+    proven: z.boolean().optional().describe("When true, require the answer to be cryptographically signed."),
+};
+// ── Handler ─────────────────────────────────────────────────────────────
+export async function handleAskBreakpoint(params, backend) {
+    if (!params.question || params.question.length === 0) {
+        throw new Error("question is required and must be non-empty");
+    }
+    const timeoutMs = params.timeout ?? DEFAULT_TIMEOUT_MS;
+    const submitParams = {
+        text: params.question,
+        context: {
+            description: params.context ?? "",
+            codeSnippets: params.codeSnippets ?? [],
+            fileReferences: params.fileReferences ?? [],
+            tags: params.tags ?? [],
+            markdown: params.markdown,
+            domain: params.domain,
+            urgency: params.urgency,
+            interactionKind: params.interactionKind,
+        },
+        routing: {
+            strategy: params.routingStrategy ?? "first-response-wins",
+            targetResponders: params.targetResponders ?? [],
+            timeoutMs,
+            presentToUser: false,
+            breakpointId: params.breakpointId,
+        },
+        proven: params.proven,
+    };
+    if (params.proven && !supportsProvenAnswers(backend.name)) {
+        throw new Error(unsupportedBackendFeatureMessage(backend.name, "ask_breakpoint.proven"));
+    }
+    const breakpoint = await backend.submitBreakpoint(submitParams);
+    const waitResult = await backend.waitForAnswer(breakpoint.id, {
+        timeoutMs,
+    });
+    if (params.proven && waitResult.answered) {
+        const answer = waitResult.answer ?? selectBreakpointAnswer(waitResult.breakpoint);
+        if (!answer || !isProvenBreakpointAnswer(answer)) {
+            throw new Error(`Breakpoint ${breakpoint.id} required a signed answer, but the returned answer was unsigned.`);
+        }
+    }
+    return waitResult;
+}

package/dist/mcp/tools/check-status.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import type { BreakpointBackend } from "../../backend.js";
+import type { Breakpoint } from "../../types.js";
+export declare const checkBreakpointStatusDescription: string;
+export declare const checkBreakpointStatusParams: {
+    breakpointId: z.ZodString;
+    backend: z.ZodOptional<z.ZodString>;
+    breakpointsDir: z.ZodOptional<z.ZodString>;
+};
+export interface CheckBreakpointStatusParams {
+    breakpointId: string;
+    backend?: string;
+    breakpointsDir?: string;
+}
+export declare function handleCheckBreakpointStatus(params: CheckBreakpointStatusParams, backend: BreakpointBackend): Promise<Breakpoint>;
+//# sourceMappingURL=check-status.d.ts.map

package/dist/mcp/tools/check-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-status.d.ts","sourceRoot":"","sources":["../../../src/mcp/tools/check-status.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAIjD,eAAO,MAAM,gCAAgC,QAEW,CAAC;AAIzD,eAAO,MAAM,2BAA2B;;;;CAIvC,CAAC;AAIF,MAAM,WAAW,2BAA2B;IAC1C,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAID,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,2BAA2B,EACnC,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,UAAU,CAAC,CAOrB"}

package/dist/mcp/tools/check-status.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+// ── Tool Description ────────────────────────────────────────────────────
+export const checkBreakpointStatusDescription = "Check the current status of a pending breakpoint. Returns the breakpoint " +
+    "state, any answers received, and timing information.";
+// ── Tool Param Schema ───────────────────────────────────────────────────
+export const checkBreakpointStatusParams = {
+    breakpointId: z.string().describe("The ID of the breakpoint to check."),
+    backend: z.string().optional(),
+    breakpointsDir: z.string().optional(),
+};
+// ── Handler ─────────────────────────────────────────────────────────────
+export async function handleCheckBreakpointStatus(params, backend) {
+    if (!params.breakpointId || params.breakpointId.length === 0) {
+        throw new Error("breakpointId is required and must be non-empty");
+    }
+    const breakpoint = await backend.getBreakpoint(params.breakpointId);
+    return breakpoint;
+}

package/dist/mcp/tools/claim-breakpoint.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import type { BreakpointBackend } from "../../backend.js";
+import type { Breakpoint } from "../../types.js";
+export declare const claimBreakpointDescription: string;
+export declare const claimBreakpointParams: {
+    breakpointId: z.ZodString;
+    responderId: z.ZodString;
+    backend: z.ZodOptional<z.ZodString>;
+    breakpointsDir: z.ZodOptional<z.ZodString>;
+};
+export interface ClaimBreakpointToolParams {
+    breakpointId: string;
+    responderId: string;
+    backend?: string;
+    breakpointsDir?: string;
+}
+export declare function handleClaimBreakpoint(params: ClaimBreakpointToolParams, backend: BreakpointBackend): Promise<Breakpoint>;
+//# sourceMappingURL=claim-breakpoint.d.ts.map

package/dist/mcp/tools/claim-breakpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claim-breakpoint.d.ts","sourceRoot":"","sources":["../../../src/mcp/tools/claim-breakpoint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAIjD,eAAO,MAAM,0BAA0B,QAGsC,CAAC;AAI9E,eAAO,MAAM,qBAAqB;;;;;CAOjC,CAAC;AAIF,MAAM,WAAW,yBAAyB;IACxC,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAID,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,yBAAyB,EACjC,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,UAAU,CAAC,CAgBrB"}

package/dist/mcp/tools/claim-breakpoint.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+// ── Tool Description ────────────────────────────────────────────────────
+export const claimBreakpointDescription = "Claim a pending breakpoint so other responders know you are working on it. " +
+    "You should claim a breakpoint before answering it. " +
+    "Only responders listed in the breakpoint's targetResponders can claim it.";
+// ── Tool Param Schema ───────────────────────────────────────────────────
+export const claimBreakpointParams = {
+    breakpointId: z.string().describe("The ID of the breakpoint to claim."),
+    responderId: z
+        .string()
+        .describe("The responder ID claiming this breakpoint."),
+    backend: z.string().optional(),
+    breakpointsDir: z.string().optional(),
+};
+// ── Handler ─────────────────────────────────────────────────────────────
+export async function handleClaimBreakpoint(params, backend) {
+    if (!params.breakpointId || params.breakpointId.length === 0) {
+        throw new Error("breakpointId is required and must be non-empty");
+    }
+    if (!params.responderId || params.responderId.length === 0) {
+        throw new Error("responderId is required and must be non-empty");
+    }
+    if (!backend.claimBreakpoint) {
+        throw new Error(`Backend "${backend.name}" does not support claiming breakpoints`);
+    }
+    const breakpoint = await backend.claimBreakpoint(params.breakpointId, params.responderId);
+    return breakpoint;
+}

package/dist/mcp/tools/list-breakpoints.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import type { BreakpointBackend } from "../../backend.js";
+import type { Breakpoint } from "../../types.js";
+export declare const listBreakpointsDescription = "List pending breakpoints awaiting answers. Optionally filter by responder.";
+export declare const listBreakpointsParams: {
+    responderId: z.ZodOptional<z.ZodString>;
+    backend: z.ZodOptional<z.ZodString>;
+    breakpointsDir: z.ZodOptional<z.ZodString>;
+};
+export interface ListBreakpointsParams {
+    responderId?: string;
+    backend?: string;
+    breakpointsDir?: string;
+}
+export declare function handleListBreakpoints(params: ListBreakpointsParams, backend: BreakpointBackend): Promise<Breakpoint[]>;
+//# sourceMappingURL=list-breakpoints.d.ts.map

package/dist/mcp/tools/list-breakpoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-breakpoints.d.ts","sourceRoot":"","sources":["../../../src/mcp/tools/list-breakpoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAIjD,eAAO,MAAM,0BAA0B,+EACuC,CAAC;AAI/E,eAAO,MAAM,qBAAqB;;;;CAMjC,CAAC;AAIF,MAAM,WAAW,qBAAqB;IACpC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAID,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,qBAAqB,EAC7B,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,UAAU,EAAE,CAAC,CAGvB"}

package/dist/mcp/tools/list-breakpoints.js

@@ -0,0 +1,14 @@
+import { z } from "zod";
+// ── Tool Description ────────────────────────────────────────────────────
+export const listBreakpointsDescription = "List pending breakpoints awaiting answers. Optionally filter by responder.";
+// ── Tool Param Schema ───────────────────────────────────────────────────
+export const listBreakpointsParams = {
+    responderId: z.string().optional().describe("Filter by responder ID. Omit to list all pending breakpoints."),
+    backend: z.string().optional(),
+    breakpointsDir: z.string().optional(),
+};
+// ── Handler ─────────────────────────────────────────────────────────────
+export async function handleListBreakpoints(params, backend) {
+    const breakpoints = await backend.listPendingBreakpoints(params.responderId);
+    return breakpoints;
+}

package/dist/mcp/tools/list-responders.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import type { BreakpointBackend } from "../../backend.js";
+import type { ResponderProfile } from "../../types.js";
+export declare const listRespondersDescription: string;
+export declare const listRespondersParams: {
+    domain: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    backend: z.ZodOptional<z.ZodString>;
+    breakpointsDir: z.ZodOptional<z.ZodString>;
+};
+export interface ListRespondersToolParams {
+    domain?: string;
+    tags?: string[];
+    backend?: string;
+    breakpointsDir?: string;
+}
+export declare function handleListResponders(params: ListRespondersToolParams, backend: BreakpointBackend): Promise<ResponderProfile[]>;
+//# sourceMappingURL=list-responders.d.ts.map

package/dist/mcp/tools/list-responders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-responders.d.ts","sourceRoot":"","sources":["../../../src/mcp/tools/list-responders.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAIvD,eAAO,MAAM,yBAAyB,QAGmB,CAAC;AAI1D,eAAO,MAAM,oBAAoB;;;;;CAWhC,CAAC;AAIF,MAAM,WAAW,wBAAwB;IACvC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAID,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,wBAAwB,EAChC,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAyB7B"}