@a5c-ai/tasks-adapter 5.1.1-staging.0007199a1cb2

package/dist/mcp/tools/native-tasks.js

@@ -0,0 +1,481 @@
+import { z } from "zod";
+import { BreakpointStatusSchema, DEFAULT_TIMEOUT_MS, TaskPrioritySchema, } from "../../types.js";
+const responderTypeSchema = z.enum(["human", "agent", "tracker", "internal", "auto"]);
+const urgencySchema = z.enum(["low", "medium", "high"]);
+const taskPrioritySchema = TaskPrioritySchema;
+const taskStatusSchema = BreakpointStatusSchema;
+const nativeRoutingParams = {
+    responderId: z.string().min(1).optional(),
+    responderType: responderTypeSchema.optional(),
+    adapter: z.string().min(1).optional(),
+    model: z.string().min(1).optional(),
+    provider: z.string().min(1).optional(),
+    trackerBackend: z.string().min(1).optional(),
+    fallbackType: responderTypeSchema.optional(),
+};
+const nativeContextParams = {
+    tags: z.array(z.string()).optional(),
+    domain: z.string().min(1).optional(),
+    urgency: urgencySchema.optional(),
+    priority: taskPrioritySchema.optional(),
+    dependsOn: z.array(z.string().min(1)).optional(),
+    sourceUrl: z.string().url().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    projectId: z.string().min(1).optional(),
+    repoId: z.string().min(1).optional(),
+};
+export const createTodoDescription = "Create a todo routed through tasks-adapter. The todo is stored as a task-like breakpoint so existing responder backends, routing, and audit trails remain the source of truth.";
+export const createTodoParams = {
+    title: z.string().min(1).describe("Short todo title."),
+    description: z.string().optional().describe("Optional todo details."),
+    ...nativeRoutingParams,
+    ...nativeContextParams,
+    backend: z.string().optional(),
+    breakpointsDir: z.string().optional(),
+};
+export const createTaskDescription = "Create a task routed through tasks-adapter. This is an alias-friendly task surface backed by the same breakpoint storage as assign_task.";
+export const createTaskParams = {
+    title: z.string().min(1).describe("Task title."),
+    instructions: z.string().optional().describe("Task instructions or acceptance notes."),
+    ...nativeRoutingParams,
+    ...nativeContextParams,
+    backend: z.string().optional(),
+    breakpointsDir: z.string().optional(),
+};
+export const assignTaskDescription = "Assign a task through tasks-adapter responder routing. Use this instead of direct agent delegation when the work should be visible to the task router.";
+export const assignTaskParams = {
+    taskId: z.string().min(1).optional().describe("Existing task or breakpoint id to assign. If omitted, creates a new task."),
+    title: z.string().min(1).describe("Task title."),
+    instructions: z.string().optional().describe("Task instructions or acceptance notes."),
+    assignee: z.string().min(1).optional().describe("Responder id to assign to."),
+    ...nativeRoutingParams,
+    ...nativeContextParams,
+    backend: z.string().optional(),
+    breakpointsDir: z.string().optional(),
+};
+export const searchTasksDescription = "Search task-like breakpoints currently visible to tasks-adapter. This is read-only and uses the configured BreakpointBackend.";
+export const searchTasksParams = {
+    query: z.string().optional(),
+    status: z.union([taskStatusSchema, z.array(taskStatusSchema)]).optional(),
+    priority: z.union([taskPrioritySchema, z.array(taskPrioritySchema)]).optional(),
+    assigneeId: z.string().optional(),
+    responderId: z.string().optional(),
+    domain: z.string().optional(),
+    tags: z.array(z.string()).optional(),
+    sortBy: z.enum(["createdAt", "updatedAt", "priority", "status"]).optional(),
+    sortDirection: z.enum(["asc", "desc"]).optional(),
+    offset: z.number().int().nonnegative().optional(),
+    limit: z.number().int().positive().optional(),
+    backend: z.string().optional(),
+    breakpointsDir: z.string().optional(),
+};
+export const addCommentDescription = "Add a discussion comment to a task-like breakpoint through the configured BreakpointBackend.";
+export const addCommentParams = {
+    taskId: z.string().min(1),
+    authorId: z.string().min(1),
+    authorName: z.string().min(1).optional(),
+    text: z.string().min(1),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    backend: z.string().optional(),
+    breakpointsDir: z.string().optional(),
+};
+export const addCommentToBreakpointDescription = "Add a discussion comment to a breakpoint through the configured BreakpointBackend.";
+export const addCommentToBreakpointParams = {
+    breakpointId: z.string().min(1),
+    authorId: z.string().min(1),
+    authorName: z.string().min(1).optional(),
+    text: z.string().min(1),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    backend: z.string().optional(),
+    breakpointsDir: z.string().optional(),
+};
+export const bulkUpdateTasksDescription = "Apply a backend-agnostic bulk operation to task-like breakpoints with per-item success and failure details.";
+export const bulkUpdateTasksParams = {
+    ids: z.array(z.string().min(1)).min(1),
+    action: z.enum(["approve", "close", "cancel", "reassign", "transition"]),
+    actorId: z.string().min(1).optional(),
+    assigneeId: z.string().min(1).optional(),
+    assigneeName: z.string().min(1).optional(),
+    status: taskStatusSchema.optional(),
+    message: z.string().optional(),
+    backend: z.string().optional(),
+    breakpointsDir: z.string().optional(),
+};
+export const taskStatsDescription = "Compute deterministic task metrics grouped by status and priority.";
+export const taskStatsParams = {
+    status: z.union([taskStatusSchema, z.array(taskStatusSchema)]).optional(),
+    priority: z.union([taskPrioritySchema, z.array(taskPrioritySchema)]).optional(),
+    assigneeId: z.string().optional(),
+    responderId: z.string().optional(),
+    tags: z.array(z.string()).optional(),
+    domain: z.string().optional(),
+    backend: z.string().optional(),
+    breakpointsDir: z.string().optional(),
+};
+export const exportTasksDescription = "Export matching task-like breakpoints with credential-bearing notification targets redacted.";
+export const exportTasksParams = {
+    status: z.union([taskStatusSchema, z.array(taskStatusSchema)]).optional(),
+    priority: z.union([taskPrioritySchema, z.array(taskPrioritySchema)]).optional(),
+    assigneeId: z.string().optional(),
+    responderId: z.string().optional(),
+    tags: z.array(z.string()).optional(),
+    domain: z.string().optional(),
+    backend: z.string().optional(),
+    breakpointsDir: z.string().optional(),
+};
+export const escalateDescription = "Escalate an existing task or create a high-urgency intervention through tasks-adapter routing.";
+export const escalateParams = {
+    taskId: z.string().min(1).optional().describe("Existing task or breakpoint id to escalate."),
+    title: z.string().min(1).optional().describe("Escalation title. Defaults from taskId when available."),
+    reason: z.string().min(1).describe("Why escalation is required."),
+    targetResponderId: z.string().min(1).optional().describe("Responder id that should receive the escalation."),
+    ...nativeRoutingParams,
+    ...nativeContextParams,
+    backend: z.string().optional(),
+    breakpointsDir: z.string().optional(),
+};
+export const cancelBreakpointDescription = "Cancel a pending breakpoint through the configured BreakpointBackend.";
+export const cancelBreakpointParams = {
+    breakpointId: z.string().min(1),
+    backend: z.string().optional(),
+    breakpointsDir: z.string().optional(),
+};
+export const escalateBreakpointDescription = "Escalate an existing breakpoint through tasks-adapter routing and lifecycle state.";
+export const escalateBreakpointParams = {
+    breakpointId: z.string().min(1).describe("Existing breakpoint id to escalate."),
+    reason: z.string().min(1).describe("Why escalation is required."),
+    targetResponderId: z.string().min(1).optional().describe("Responder id that should receive the escalation."),
+    ...nativeRoutingParams,
+    ...nativeContextParams,
+    backend: z.string().optional(),
+    breakpointsDir: z.string().optional(),
+};
+export async function handleCreateTodo(params, backend) {
+    const parsed = z.object(createTodoParams).parse(params);
+    const breakpoint = await backend.submitBreakpoint({
+        text: parsed.title,
+        context: buildContext({
+            title: parsed.title,
+            description: parsed.description ?? parsed.title,
+            interactionKind: "notification",
+            nativeTool: "create_todo",
+            nativeKind: "todo",
+            tags: parsed.tags,
+            domain: parsed.domain,
+            urgency: parsed.urgency,
+            sourceUrl: parsed.sourceUrl,
+            metadata: parsed.metadata,
+        }),
+        routing: buildRouting(parsed),
+        priority: parsed.priority,
+        dependsOn: parsed.dependsOn?.map((id) => ({ id, blocking: true })),
+        projectId: parsed.projectId,
+        repoId: parsed.repoId,
+    });
+    return nativeResult("create_todo", breakpoint);
+}
+export async function handleAssignTask(params, backend) {
+    const parsed = z.object(assignTaskParams).parse(params);
+    const responderId = parsed.assignee ?? parsed.responderId;
+    if (parsed.taskId && responderId && backend.assignBreakpoint) {
+        const breakpoint = await backend.assignBreakpoint(parsed.taskId, {
+            assigneeId: responderId,
+            actorId: parsed.metadata?.actorId,
+        });
+        return nativeResult("assign_task", breakpoint);
+    }
+    const breakpoint = await backend.submitBreakpoint({
+        text: parsed.title,
+        context: buildContext({
+            title: parsed.title,
+            description: parsed.instructions ?? parsed.title,
+            interactionKind: "handoff",
+            nativeTool: "assign_task",
+            nativeKind: "task",
+            tags: parsed.tags,
+            domain: parsed.domain,
+            urgency: parsed.urgency,
+            sourceUrl: parsed.sourceUrl,
+            metadata: { ...parsed.metadata, assignee: responderId },
+        }),
+        routing: buildRouting({ ...parsed, responderId }),
+        priority: parsed.priority,
+        dependsOn: parsed.dependsOn?.map((id) => ({ id, blocking: true })),
+        projectId: parsed.projectId,
+        repoId: parsed.repoId,
+    });
+    return nativeResult("assign_task", breakpoint);
+}
+export async function handleCreateTask(params, backend) {
+    const parsed = z.object(createTaskParams).parse(params);
+    const breakpoint = await backend.submitBreakpoint({
+        text: parsed.title,
+        context: buildContext({
+            title: parsed.title,
+            description: parsed.instructions ?? parsed.title,
+            interactionKind: "handoff",
+            nativeTool: "create_task",
+            nativeKind: "task",
+            tags: parsed.tags,
+            domain: parsed.domain,
+            urgency: parsed.urgency,
+            sourceUrl: parsed.sourceUrl,
+            metadata: parsed.metadata,
+        }),
+        routing: buildRouting(parsed),
+        priority: parsed.priority,
+        dependsOn: parsed.dependsOn?.map((id) => ({ id, blocking: true })),
+        projectId: parsed.projectId,
+        repoId: parsed.repoId,
+    });
+    return nativeResult("create_task", breakpoint);
+}
+export async function handleSearchTasks(params, backend) {
+    const parsed = z.object(searchTasksParams).parse(params);
+    if (backend.searchBreakpoints) {
+        const result = await backend.searchBreakpoints({
+            query: parsed.query,
+            status: normalizeArray(parsed.status),
+            priority: normalizeArray(parsed.priority),
+            assigneeId: parsed.assigneeId,
+            responderId: parsed.responderId,
+            domain: parsed.domain,
+            tags: parsed.tags,
+            sortBy: parsed.sortBy,
+            sortDirection: parsed.sortDirection,
+            offset: parsed.offset,
+            limit: parsed.limit,
+        });
+        return { tool: "search_tasks", count: result.total, tasks: result.items };
+    }
+    const pending = await backend.listPendingBreakpoints(parsed.responderId);
+    const query = parsed.query?.toLowerCase();
+    const tags = parsed.tags?.map((tag) => tag.toLowerCase()) ?? [];
+    const domain = parsed.domain?.toLowerCase();
+    const statuses = normalizeArray(parsed.status);
+    const priorities = normalizeArray(parsed.priority);
+    const filtered = pending.filter((task) => {
+        if (statuses && !statuses.includes(task.status))
+            return false;
+        if (priorities && !priorities.includes(task.priority ?? "medium"))
+            return false;
+        if (parsed.assigneeId && task.assigneeId !== parsed.assigneeId)
+            return false;
+        if (parsed.responderId && !matchesResponder(task, parsed.responderId))
+            return false;
+        if (domain && !task.context.domain?.toLowerCase().includes(domain))
+            return false;
+        if (tags.length > 0) {
+            const taskTags = new Set(task.context.tags.map((tag) => tag.toLowerCase()));
+            if (!tags.every((tag) => taskTags.has(tag)))
+                return false;
+        }
+        if (query && !searchText(task).includes(query))
+            return false;
+        return true;
+    });
+    const tasks = typeof parsed.limit === "number" ? filtered.slice(0, parsed.limit) : filtered;
+    return { tool: "search_tasks", count: tasks.length, tasks };
+}
+export async function handleEscalate(params, backend) {
+    const parsed = z.object(escalateParams).parse(params);
+    const existing = parsed.taskId ? await getExistingTask(backend, parsed.taskId) : undefined;
+    if (existing && backend.transitionBreakpoint) {
+        const breakpoint = await backend.transitionBreakpoint(existing.id, {
+            status: "escalated",
+            actorId: parsed.metadata?.actorId,
+            message: parsed.reason,
+        });
+        return nativeResult("escalate", breakpoint);
+    }
+    const title = parsed.title ?? (existing ? `Escalate: ${existing.text}` : "Escalation required");
+    const responderId = parsed.targetResponderId ?? parsed.responderId;
+    const breakpoint = await backend.submitBreakpoint({
+        text: title,
+        context: buildContext({
+            title,
+            description: existing
+                ? `${parsed.reason}\n\nEscalated task: ${existing.id}\n${existing.text}`
+                : parsed.reason,
+            interactionKind: "intervention",
+            nativeTool: "escalate",
+            nativeKind: "escalation",
+            tags: ["escalation", ...(parsed.tags ?? [])],
+            domain: parsed.domain ?? existing?.context.domain,
+            urgency: "high",
+            sourceUrl: parsed.sourceUrl,
+            metadata: { ...parsed.metadata, escalatedTaskId: parsed.taskId },
+        }),
+        routing: buildRouting({
+            ...parsed,
+            responderId,
+            responderType: parsed.responderType ?? "human",
+        }),
+        priority: "critical",
+        dependsOn: parsed.taskId ? [{ id: parsed.taskId, blocking: false }] : undefined,
+        projectId: parsed.projectId,
+        repoId: parsed.repoId,
+    });
+    return nativeResult("escalate", breakpoint);
+}
+export async function handleCancelBreakpoint(params, backend) {
+    const parsed = z.object(cancelBreakpointParams).parse(params);
+    await backend.cancelBreakpoint(parsed.breakpointId);
+    return { tool: "cancel_breakpoint", breakpointId: parsed.breakpointId, cancelled: true };
+}
+export async function handleEscalateBreakpoint(params, backend) {
+    const parsed = z.object(escalateBreakpointParams).parse(params);
+    const result = await handleEscalate({
+        ...parsed,
+        taskId: parsed.breakpointId,
+    }, backend);
+    return {
+        ...result,
+        tool: "escalate_breakpoint",
+        metadata: {
+            ...result.metadata,
+            nativeTool: "escalate_breakpoint",
+        },
+    };
+}
+export async function handleAddComment(params, backend) {
+    const parsed = z.object(addCommentParams).parse(params);
+    if (!backend.addBreakpointComment) {
+        throw new Error(`Backend "${backend.name}" does not support task comments`);
+    }
+    const comment = await backend.addBreakpointComment(parsed.taskId, {
+        authorId: parsed.authorId,
+        authorName: parsed.authorName,
+        text: parsed.text,
+        metadata: parsed.metadata,
+    });
+    return { tool: "add_comment", taskId: parsed.taskId, comment };
+}
+export async function handleAddCommentToBreakpoint(params, backend) {
+    const parsed = z.object(addCommentToBreakpointParams).parse(params);
+    const result = await handleAddComment({
+        taskId: parsed.breakpointId,
+        authorId: parsed.authorId,
+        authorName: parsed.authorName,
+        text: parsed.text,
+        metadata: parsed.metadata,
+    }, backend);
+    return { ...result, tool: "add_comment_to_breakpoint", breakpointId: parsed.breakpointId };
+}
+export async function handleBulkUpdateTasks(params, backend) {
+    const parsed = z.object(bulkUpdateTasksParams).parse(params);
+    if (!backend.bulkUpdateBreakpoints) {
+        throw new Error(`Backend "${backend.name}" does not support bulk task operations`);
+    }
+    return {
+        tool: "bulk_update_tasks",
+        ...(await backend.bulkUpdateBreakpoints(parsed)),
+    };
+}
+export async function handleTaskStats(params, backend) {
+    const parsed = z.object(taskStatsParams).parse(params);
+    if (!backend.getBreakpointMetrics) {
+        throw new Error(`Backend "${backend.name}" does not support task stats`);
+    }
+    return {
+        tool: "task_stats",
+        ...(await backend.getBreakpointMetrics({
+            status: normalizeArray(parsed.status),
+            priority: normalizeArray(parsed.priority),
+            assigneeId: parsed.assigneeId,
+            responderId: parsed.responderId,
+            tags: parsed.tags,
+            domain: parsed.domain,
+        })),
+    };
+}
+export async function handleExportTasks(params, backend) {
+    const parsed = z.object(exportTasksParams).parse(params);
+    if (!backend.exportBreakpoints) {
+        throw new Error(`Backend "${backend.name}" does not support task export`);
+    }
+    return {
+        tool: "export_tasks",
+        ...(await backend.exportBreakpoints({
+            status: normalizeArray(parsed.status),
+            priority: normalizeArray(parsed.priority),
+            assigneeId: parsed.assigneeId,
+            responderId: parsed.responderId,
+            tags: parsed.tags,
+            domain: parsed.domain,
+        })),
+    };
+}
+function buildContext(args) {
+    return {
+        title: args.title,
+        description: args.description,
+        codeSnippets: [],
+        fileReferences: [],
+        tags: Array.from(new Set([args.nativeKind, ...(args.tags ?? [])])),
+        domain: args.domain,
+        urgency: args.urgency,
+        interactionKind: args.interactionKind,
+        links: args.sourceUrl ? [{ label: "Source", url: args.sourceUrl, kind: "reference" }] : undefined,
+        metadata: {
+            ...args.metadata,
+            nativeTool: args.nativeTool,
+            nativeKind: args.nativeKind,
+        },
+    };
+}
+function buildRouting(params) {
+    return {
+        strategy: "single",
+        targetResponders: params.responderId ? [params.responderId] : [],
+        timeoutMs: DEFAULT_TIMEOUT_MS,
+        presentToUser: params.responderType !== "agent",
+        responderType: params.responderType,
+        adapter: params.adapter,
+        model: params.model,
+        provider: params.provider,
+        trackerBackend: params.trackerBackend,
+        fallbackType: params.fallbackType,
+    };
+}
+function nativeResult(tool, breakpoint) {
+    return {
+        tool,
+        taskId: breakpoint.id,
+        breakpoint,
+        routing: breakpoint.routing,
+        metadata: {
+            nativeTool: tool,
+            backendStatus: breakpoint.status,
+        },
+    };
+}
+async function getExistingTask(backend, taskId) {
+    try {
+        return await backend.getBreakpoint(taskId);
+    }
+    catch {
+        return undefined;
+    }
+}
+function matchesResponder(task, responderId) {
+    return task.routing.targetResponders.includes(responderId) ||
+        task.claimedByResponderId === responderId ||
+        task.answers.some((answer) => answer.responderId === responderId);
+}
+function searchText(task) {
+    return [
+        task.id,
+        task.text,
+        task.context.title,
+        task.context.summary,
+        task.context.description,
+        task.context.domain,
+        ...task.context.tags,
+    ].filter(Boolean).join("\n").toLowerCase();
+}
+function normalizeArray(value) {
+    if (value === undefined)
+        return undefined;
+    return Array.isArray(value) ? value : [value];
+}

package/dist/mcp/tools/poll-breakpoints.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 pollBreakpointsDescription: string;
+export declare const pollBreakpointsParams: {
+    responderId: z.ZodString;
+    waitSeconds: z.ZodOptional<z.ZodNumber>;
+    backend: z.ZodOptional<z.ZodString>;
+    breakpointsDir: z.ZodOptional<z.ZodString>;
+};
+export interface PollBreakpointsToolParams {
+    responderId: string;
+    waitSeconds?: number;
+    backend?: string;
+    breakpointsDir?: string;
+}
+export declare function handlePollBreakpoints(params: PollBreakpointsToolParams, backend: BreakpointBackend): Promise<Breakpoint[]>;
+//# sourceMappingURL=poll-breakpoints.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"poll-breakpoints.d.ts","sourceRoot":"","sources":["../../../src/mcp/tools/poll-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,QAGsC,CAAC;AAI9E,eAAO,MAAM,qBAAqB;;;;;CAejC,CAAC;AAIF,MAAM,WAAW,yBAAyB;IACxC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,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,EAAE,CAAC,CAiBvB"}

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

@@ -0,0 +1,36 @@
+import { z } from "zod";
+// ── Tool Description ────────────────────────────────────────────────────
+export const pollBreakpointsDescription = "Poll for pending breakpoints routed to a specific responder. " +
+    "Returns all breakpoints currently waiting for this responder to answer. " +
+    "Use waitSeconds to long-poll if no breakpoints are immediately available.";
+// ── Tool Param Schema ───────────────────────────────────────────────────
+export const pollBreakpointsParams = {
+    responderId: z
+        .string()
+        .describe("The responder ID to poll breakpoints for."),
+    waitSeconds: z
+        .number()
+        .min(0)
+        .max(120)
+        .optional()
+        .describe("How long to wait for breakpoints to appear (0 = immediate return, default). " +
+        "If > 0, polls every 2 seconds until breakpoints are found or timeout expires."),
+    backend: z.string().optional(),
+    breakpointsDir: z.string().optional(),
+};
+// ── Handler ─────────────────────────────────────────────────────────────
+export async function handlePollBreakpoints(params, backend) {
+    if (!params.responderId || params.responderId.length === 0) {
+        throw new Error("responderId is required and must be non-empty");
+    }
+    const waitSeconds = params.waitSeconds ?? 0;
+    let breakpoints = await backend.listPendingBreakpoints(params.responderId);
+    if (breakpoints.length === 0 && waitSeconds > 0) {
+        const deadline = Date.now() + waitSeconds * 1000;
+        while (breakpoints.length === 0 && Date.now() < deadline) {
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+            breakpoints = await backend.listPendingBreakpoints(params.responderId);
+        }
+    }
+    return breakpoints;
+}

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

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import type { BreakpointBackend } from "../../backend.js";
+import type { ProvenVerificationResult } from "../../types.js";
+export declare const verifyBreakpointAnswerDescription: string;
+export declare const verifyBreakpointAnswerParams: {
+    breakpointId: z.ZodString;
+    backend: z.ZodOptional<z.ZodString>;
+    breakpointsDir: z.ZodOptional<z.ZodString>;
+};
+export interface VerifyBreakpointAnswerParams {
+    breakpointId: string;
+    backend?: string;
+    breakpointsDir?: string;
+}
+export declare function handleVerifyBreakpointAnswer(params: VerifyBreakpointAnswerParams, backend: BreakpointBackend): Promise<ProvenVerificationResult>;
+//# sourceMappingURL=verify-answer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"verify-answer.d.ts","sourceRoot":"","sources":["../../../src/mcp/tools/verify-answer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE1D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAK/D,eAAO,MAAM,iCAAiC,QAE2B,CAAC;AAI1E,eAAO,MAAM,4BAA4B;;;;CAMxC,CAAC;AAIF,MAAM,WAAW,4BAA4B;IAC3C,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAID,wBAAsB,4BAA4B,CAChD,MAAM,EAAE,4BAA4B,EACpC,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,wBAAwB,CAAC,CA4BnC"}

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

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { selectBreakpointAnswer, supportsProvenAnswers, unsupportedBackendFeatureMessage, } from "../../backend.js";
+import { isProvenBreakpointAnswer } from "../../types.js";
+import { verifyAnswer } from "../../proven/verify.js";
+// ── Tool Description ────────────────────────────────────────────────────
+export const verifyBreakpointAnswerDescription = "Verify the cryptographic signature of a breakpoint answer against " +
+    "trusted public keys. Returns verification status and signer identity.";
+// ── Tool Param Schema ───────────────────────────────────────────────────
+export const verifyBreakpointAnswerParams = {
+    breakpointId: z.string().describe("The ID of the breakpoint whose answer to verify."),
+    backend: z.string().optional(),
+    breakpointsDir: z.string().optional(),
+};
+// ── Handler ─────────────────────────────────────────────────────────────
+export async function handleVerifyBreakpointAnswer(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);
+    if (!breakpoint.answers || breakpoint.answers.length === 0) {
+        throw new Error("No answers found for this breakpoint");
+    }
+    const answer = selectBreakpointAnswer(breakpoint);
+    if (!answer) {
+        if (breakpoint.selectedAnswer) {
+            throw new Error(`Selected answer ${breakpoint.selectedAnswer} was not found on breakpoint ${breakpoint.id}`);
+        }
+        throw new Error("No answers found for this breakpoint");
+    }
+    if (!isProvenBreakpointAnswer(answer)) {
+        if (!supportsProvenAnswers(backend.name)) {
+            throw new Error(unsupportedBackendFeatureMessage(backend.name, "signed answers"));
+        }
+        throw new Error("Answer is not signed/proven -- no cryptographic signature found");
+    }
+    const result = await verifyAnswer(answer, params.breakpointsDir);
+    return result;
+}

package/dist/proven/index.d.ts

@@ -0,0 +1,5 @@
+export { generateKeyPair, saveTrustedPublicKey, savePrivateKey, loadTrustedPublicKeys, loadPrivateKey, rotateKey, } from "./keys.js";
+export type { KeyPairMetadata, PublicKeyRecord, PrivateKeyRecord, } from "./keys.js";
+export { signAnswer, signAnswerWithKeyRecord } from "./sign.js";
+export { verifyAnswer } from "./verify.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/proven/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/proven/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,oBAAoB,EACpB,cAAc,EACd,qBAAqB,EACrB,cAAc,EACd,SAAS,GACV,MAAM,WAAW,CAAC;AAEnB,YAAY,EACV,eAAe,EACf,eAAe,EACf,gBAAgB,GACjB,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,UAAU,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC"}

package/dist/proven/index.js

@@ -0,0 +1,3 @@
+export { generateKeyPair, saveTrustedPublicKey, savePrivateKey, loadTrustedPublicKeys, loadPrivateKey, rotateKey, } from "./keys.js";
+export { signAnswer, signAnswerWithKeyRecord } from "./sign.js";
+export { verifyAnswer } from "./verify.js";

package/dist/proven/keys.d.ts

@@ -0,0 +1,33 @@
+import type { PublicKeyRecord, PrivateKeyRecord } from "./types.js";
+/**
+ * Generate a new Ed25519 key pair for a responder.
+ */
+export declare function generateKeyPair(responderId: string, responderName: string): {
+    publicKeyRecord: PublicKeyRecord;
+    privateKeyRecord: PrivateKeyRecord;
+};
+/**
+ * Save a public key to the trusted keys directory (git-tracked).
+ */
+export declare function saveTrustedPublicKey(publicKeyRecord: PublicKeyRecord, baseDir?: string): Promise<string>;
+/**
+ * Save a private key to the private keys directory (gitignored).
+ */
+export declare function savePrivateKey(privateKeyRecord: PrivateKeyRecord, baseDir?: string): Promise<string>;
+/**
+ * Load all trusted public keys from the trusted directory.
+ */
+export declare function loadTrustedPublicKeys(baseDir?: string): Promise<PublicKeyRecord[]>;
+/**
+ * Load a private key by fingerprint.
+ */
+export declare function loadPrivateKey(fingerprint: string, baseDir?: string): Promise<PrivateKeyRecord | null>;
+/**
+ * Rotate a key: generate new pair, save both, mark old public key as expired.
+ */
+export declare function rotateKey(responderId: string, responderName: string, oldFingerprint: string, baseDir?: string): Promise<{
+    publicKeyRecord: PublicKeyRecord;
+    privateKeyRecord: PrivateKeyRecord;
+}>;
+export type { PublicKeyRecord, PrivateKeyRecord, KeyPairMetadata } from "./types.js";
+//# sourceMappingURL=keys.d.ts.map

package/dist/proven/keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../../src/proven/keys.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEpE;;GAEG;AACH,wBAAgB,eAAe,CAC7B,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,MAAM,GACpB;IAAE,eAAe,EAAE,eAAe,CAAC;IAAC,gBAAgB,EAAE,gBAAgB,CAAA;CAAE,CAyB1E;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,eAAe,EAAE,eAAe,EAChC,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC,CASjB;AAED;;GAEG;AACH,wBAAsB,cAAc,CAClC,gBAAgB,EAAE,gBAAgB,EAClC,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC,CASjB;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,eAAe,EAAE,CAAC,CAmB5B;AAED;;GAEG;AACH,wBAAsB,cAAc,CAClC,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAYlC;AAED;;GAEG;AACH,wBAAsB,SAAS,CAC7B,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,MAAM,EACrB,cAAc,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC;IAAE,eAAe,EAAE,eAAe,CAAC;IAAC,gBAAgB,EAAE,gBAAgB,CAAA;CAAE,CAAC,CAqBnF;AAED,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC"}