@bragi-gmbh/codebus 1.2.0

package/dist/mcp-registry.js

@@ -0,0 +1,859 @@
+/**
+ * MCP tool registry — pure data + handler logic for every CodeBus MCP tool.
+ * Deliberately side-effect-free at import time: no stdio, no transport, no
+ * network call fires just by loading this module. mcp.ts (the executable)
+ * imports TOOL_REGISTRY from here to actually serve it over stdio;
+ * install.ts imports it too, purely to derive a tool count for its
+ * messaging (F5) — that import must never risk booting a server (F1: this
+ * split is what makes that guarantee hold regardless of how mcp.ts's own
+ * entry-point guard is invoked, symlinked bin included).
+ */
+import { askGraph } from "./commands/ask.js";
+import { makeCtx, workspaceId, projectId } from "./client.js";
+import { resolveConfig } from "./config.js";
+import { resolveRemoteRepoSlug, graphSearchRpc, graphGapsRpc, resolveBlastRadius, } from "./graph-remote.js";
+import { fetchAndCacheDigest, nextActionableItem } from "./commands/digest.js";
+import { fetchInbox } from "./commands/inbox.js";
+import { computeNext } from "./commands/next.js";
+import { createQuestionCore, answerQuestionCore } from "./commands/question.js";
+import { createTaskCore, claimTaskCore, completeTaskCore } from "./commands/task.js";
+import { createDecisionCore, acceptDecisionCore } from "./commands/decision.js";
+import { sendMessageCore } from "./commands/send.js";
+import { planRollupCore, planDeliveryCore } from "./commands/plan.js";
+import { endSessionCore } from "./commands/session.js";
+import { compilePackCore } from "./commands/pack.js";
+import { resolveRefsCore } from "./commands/refs.js";
+import { CodebusError } from "./errors.js";
+// This module builds the tool registry only — it never touches stdio or a
+// transport, so importing it has zero side effects on the process (no server
+// boot). That is what lets install.ts import TOOL_REGISTRY to DERIVE the
+// tool count it reports to Codex/Claude users (F5, instead of hardcoding a
+// number that rots every time a tool is added or removed) without also
+// risking starting an MCP stdio server as a side effect of running
+// `codebus install mcp`. mcp.ts — the actual executable — imports this same
+// TOOL_REGISTRY to serve it over stdio; the server-boot guard lives there,
+// not here, because booting is the one thing this module must never do.
+export const TOOL_REGISTRY = [];
+// ── ask_graph (existing tool) ──────────────────────────────────────────────
+export async function askGraphHandler(args) {
+    const question = args?.question || "";
+    const budget = args?.budget || 500;
+    if (!question) {
+        throw new Error("'question' parameter is required");
+    }
+    // A6: optional repo routes through resolveGraphSource's remote leg; with no
+    // repo and a local snapshot present this is unchanged (zero-credential,
+    // zero-network) — ask_graph stays the only zero-credential MCP tool.
+    const result = await askGraph(question, { budget, repo: args?.repo });
+    if (result.error) {
+        throw new Error(result.error);
+    }
+    let answer = result.answer;
+    if (result.stalenessNote) {
+        answer += `\n\n[${result.stalenessNote}]`;
+    }
+    return { answer };
+}
+TOOL_REGISTRY.push({
+    name: "ask_graph",
+    description: "Query the CodeBus graph snapshot with a natural language question. " +
+        "Returns a compact cited answer from graphify-out/, budgeted to ~500 output tokens by default. " +
+        "Automatically detects and reports staleness vs HEAD. Optional 'repo' queries a connected " +
+        "repo's remote graph instead of (or in addition to) the local checkout; citations are marked " +
+        "[remote@sha7] when the answer came from there.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            question: {
+                type: "string",
+                description: "The question to ask about the codebase graph (e.g., 'CLI commands for identity')",
+            },
+            budget: {
+                type: "number",
+                description: "Max output tokens (optional, default 500)",
+            },
+            repo: {
+                type: "string",
+                description: "Connected repo slug to query remotely (optional; local checkout wins when present and this is omitted or matches it)",
+            },
+        },
+        required: ["question"],
+    },
+    handler: askGraphHandler,
+});
+// ── graph_search (new, remote-only) ────────────────────────────────────────
+async function graphSearchHandler(args) {
+    const q = args?.q || "";
+    if (!q)
+        throw new CodebusError("'q' parameter is required");
+    const ctx = await makeCtx(resolveConfig({}));
+    const repoSlug = await resolveRemoteRepoSlug(ctx, process.cwd(), args?.repo);
+    const results = await graphSearchRpc(ctx, repoSlug, q, args?.limit ?? 20);
+    return { repo: repoSlug, results };
+}
+TOOL_REGISTRY.push({
+    name: "graph_search",
+    description: "Trigram-ranked node search over a CONNECTED repo's knowledge graph (remote; no local fallback). " +
+        "Optional 'repo' slug; auto-detected from this directory's git remote when omitted.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            q: { type: "string", description: "Search text" },
+            repo: { type: "string", description: "Repo slug (optional; auto-detected from git remote if omitted)" },
+            limit: { type: "integer", description: "Max rows (optional, default 20, hard-capped at 100)" },
+        },
+        required: ["q"],
+    },
+    handler: graphSearchHandler,
+});
+// ── blast_radius (new, local-traversal-or-RPC) ─────────────────────────────
+async function blastRadiusHandler(args) {
+    const seed = args?.seed || "";
+    if (!seed)
+        throw new CodebusError("'seed' parameter is required");
+    const result = await resolveBlastRadius(seed, {
+        repo: args?.repo,
+        direction: args?.direction,
+        depth: args?.depth,
+        relations: Array.isArray(args?.relations) ? args.relations : undefined,
+    });
+    return {
+        source: result.source,
+        repo: result.repoSlug,
+        seed,
+        direction: args?.direction ?? "in",
+        results: result.rows,
+        truncated: result.truncated ?? false,
+    };
+}
+TOOL_REGISTRY.push({
+    name: "blast_radius",
+    description: "What breaks if I change this: BFS from one seed (node id, source file path, or label) over a " +
+        "knowledge graph. direction='in' (default) finds what DEPENDS ON the seed; 'out' finds what the " +
+        "seed depends on; 'both' is the union. Uses the local graphify-out/ snapshot when present " +
+        "(no credentials needed); otherwise queries a connected repo remotely (optional 'repo', " +
+        "auto-detected from git remote).",
+    inputSchema: {
+        type: "object",
+        properties: {
+            seed: { type: "string", description: "Seed node id, source file path, or label to resolve" },
+            repo: { type: "string", description: "Repo slug for the remote leg (optional; auto-detected from git remote if omitted)" },
+            direction: { type: "string", enum: ["in", "out", "both"], description: "Traversal direction (optional, default 'in')" },
+            depth: { type: "integer", description: "Max hops (optional, default 3, capped at 6)" },
+            relations: { type: "array", items: { type: "string" }, description: "Edge relation types to follow (optional; default set applies when omitted)" },
+        },
+        required: ["seed"],
+    },
+    handler: blastRadiusHandler,
+});
+// ── graph_gaps (new, remote-only) ───────────────────────────────────────────
+async function graphGapsHandler(args) {
+    const ctx = await makeCtx(resolveConfig({}));
+    const repoSlug = await resolveRemoteRepoSlug(ctx, process.cwd(), args?.repo);
+    const gaps = await graphGapsRpc(ctx, repoSlug);
+    return { repo: repoSlug, gaps, truncated: gaps.length >= 200 };
+}
+TOOL_REGISTRY.push({
+    name: "graph_gaps",
+    description: "Lists knowledge gaps in a CONNECTED repo's graph (remote; no local fallback): isolated nodes, " +
+        "low-confidence edges, undocumented symbols. Truncated to ~200 rows. Optional 'repo' slug; " +
+        "auto-detected from this directory's git remote when omitted.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            repo: { type: "string", description: "Repo slug (optional; auto-detected from git remote if omitted)" },
+        },
+        required: [],
+    },
+    handler: graphGapsHandler,
+});
+// ── ticket_suspect_code (new, remote-only) — repo-intelligence Track D3 ────
+async function ticketSuspectCodeHandler(args) {
+    const key = args?.ticket_key || "";
+    if (!key)
+        throw new CodebusError("'ticket_key' parameter is required");
+    const ctx = await makeCtx(resolveConfig({}));
+    // p_workspace_slug is ALWAYS passed (ctx.workspaceSlug), same convention
+    // graph-remote.ts uses for every graph query RPC — removes even the
+    // theoretical ambiguity window 0068's own header describes (a ticket key
+    // shared across >1 of the caller's own workspaces) rather than relying on
+    // that RPC's strict-fallback path ever being reached from this tool.
+    const { data, error } = await ctx.supabase.rpc("ticket_suspect_code", {
+        p_ticket_key: key,
+        p_repo_slug: args?.repo ?? null,
+        p_workspace_slug: ctx.workspaceSlug,
+        p_limit: args?.limit ?? undefined,
+        p_recent_days: args?.recent_days ?? undefined,
+    });
+    if (error)
+        throw new Error(error.message);
+    return data;
+}
+TOOL_REGISTRY.push({
+    name: "ticket_suspect_code",
+    description: "Ranked, LABELED evidence for which code most probably relates to a Jira ticket — never a claim of " +
+        "causation (every response carries a fixed disclaimer and per-item provenance). Combines the ticket's " +
+        "own linked-PR touched files, a blast-radius expansion from those files, a text-match against the " +
+        "ticket's summary, and a recency overlay. Optional 'repo' scopes every leg to one repo (required only " +
+        "when the ticket has no linked PRs and the workspace graphs more than one repo).",
+    inputSchema: {
+        type: "object",
+        properties: {
+            ticket_key: { type: "string", description: "Ticket key, e.g. PROJ-123" },
+            repo: { type: "string", description: "Repo slug to scope every evidence leg to (optional; required in some zero-linked-PR cases)" },
+            limit: { type: "integer", description: "Max ranked rows (optional, default 30, hard-clamped to [1,50])" },
+            recent_days: { type: "integer", description: "Recency-leg lookback window in days (optional, default 14, hard-clamped to [1,90])" },
+        },
+        required: ["ticket_key"],
+    },
+    handler: ticketSuspectCodeHandler,
+});
+// ── codebus_state (new read-only tool) ────────────────────────────────────
+// Extracted from session start: returns the digest without session_log writes or welcome flow
+async function getStateDigest(ctx) {
+    const snapshot = await fetchAndCacheDigest(ctx);
+    // review finding (0061): same rule as computeNext (next.ts) — a class-8 FYI
+    // message must never be reported as "the" next item; see nextActionableItem
+    // in digest.ts for why.
+    const top = nextActionableItem(snapshot.items);
+    // Get person for this agent
+    const { data } = await ctx.supabase
+        .from("agents")
+        .select("people!person_id(slug)")
+        .eq("slug", ctx.agentSlug)
+        .single();
+    const person = data?.people?.slug ?? null;
+    return {
+        agent: ctx.agentSlug,
+        person,
+        workspace: ctx.workspaceSlug,
+        counts: snapshot.counts,
+        next: top,
+    };
+}
+async function codebus_stateHandler(args) {
+    const ctx = await makeCtx(resolveConfig({}));
+    return await getStateDigest(ctx);
+}
+TOOL_REGISTRY.push({
+    name: "codebus_state",
+    description: "Get the current session-start digest: counts by priority class (ASK, BLOCKER, REVIEW, STALE, DECISION, UNCLAIMED), " +
+        "top NEXT item, workspace, agent, and person. Read-only (no side effects).",
+    inputSchema: {
+        type: "object",
+        properties: {},
+        required: [],
+    },
+    handler: codebus_stateHandler,
+});
+// ── codebus_next (new read-only tool) ──────────────────────────────────────
+async function codebus_nextHandler(args) {
+    const ctx = await makeCtx(resolveConfig({}));
+    return await computeNext(ctx);
+}
+TOOL_REGISTRY.push({
+    name: "codebus_next",
+    description: "Get the ranked NEXT item: the highest-priority work item with its reason, score, and suggested follow-up commands. " +
+        "Returns null if the bus is clear. Read-only.",
+    inputSchema: {
+        type: "object",
+        properties: {},
+        required: [],
+    },
+    handler: codebus_nextHandler,
+});
+// ── codebus_inbox (new read-only tool) ────────────────────────────────────
+async function codebus_inboxHandler(args) {
+    const ctx = await makeCtx(resolveConfig({}));
+    const ws = await workspaceId(ctx);
+    const projId = args?.project ? await projectId(ctx, ws, args.project) : null;
+    return await fetchInbox(ctx, {
+        unread: args?.unread,
+        type: args?.type,
+        projId,
+        ws,
+    });
+}
+TOOL_REGISTRY.push({
+    name: "codebus_inbox",
+    description: "Get inbox items (messages) with optional filters. By default returns all unarchived items. " +
+        "Supports unread-only filter and type filter (e.g., 'feedback', 'task_update'). Read-only.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            unread: {
+                type: "boolean",
+                description: "Filter to unread messages only (optional, default false)",
+            },
+            type: {
+                type: "string",
+                description: "Filter by message type (optional, e.g., 'feedback', 'task_update')",
+            },
+            project: {
+                type: "string",
+                description: "Filter by project slug (optional)",
+            },
+        },
+        required: [],
+    },
+    handler: codebus_inboxHandler,
+});
+// ── question (act tool) ────────────────────────────────────────────────────
+async function questionCreateHandler(args) {
+    const title = args?.title || "";
+    const body = args?.body || "";
+    if (!title || !body) {
+        throw new CodebusError("'title' and 'body' parameters are required");
+    }
+    const ctx = await makeCtx(resolveConfig({}));
+    const result = await createQuestionCore(ctx, {
+        title,
+        body,
+        to: args?.to,
+        toMentor: args?.to_mentor,
+        repo: args?.repo,
+        blocking: args?.blocking,
+        blocksTask: args?.blocks_task,
+        required: args?.required,
+    });
+    return { display_id: result.display_id, status: result.status, to: result.to };
+}
+async function questionAnswerHandler(args) {
+    const id = args?.id || "";
+    const body = args?.body || "";
+    if (!id || !body) {
+        throw new CodebusError("'id' and 'body' parameters are required");
+    }
+    const ctx = await makeCtx(resolveConfig({}));
+    const result = await answerQuestionCore(ctx, id, body);
+    return { display_id: result.display_id, status: result.status, answered_at: result.answered_at };
+}
+TOOL_REGISTRY.push({
+    name: "question_create",
+    description: "Create a new question. Questions route to specific agents or broadcast to the workspace. " +
+        "Returns the question display_id, status, and recipient.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            title: {
+                type: "string",
+                description: "Question title (required)",
+            },
+            body: {
+                type: "string",
+                description: "Question body (required)",
+            },
+            to: {
+                type: "string",
+                description: "Recipient agent slug (optional; omit for broadcast)",
+            },
+            to_mentor: {
+                type: "boolean",
+                description: "Route to your first-week mentor instead (optional)",
+            },
+            repo: {
+                type: "string",
+                description: "Associated repo slug (optional)",
+            },
+            blocking: {
+                type: "boolean",
+                description: "Mark as blocking work (optional)",
+            },
+            blocks_task: {
+                type: "string",
+                description: "CB-TASK-… id this question blocks (optional)",
+            },
+            required: {
+                type: "string",
+                description: "What a valid answer must contain (optional)",
+            },
+        },
+        required: ["title", "body"],
+    },
+    handler: questionCreateHandler,
+});
+TOOL_REGISTRY.push({
+    name: "question_answer",
+    description: "Answer an open question. The question must have status='open'. " +
+        "Returns the question display_id, updated status, and answered_at timestamp.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            id: {
+                type: "string",
+                description: "Question ID (CB-Q-… or uuid)",
+            },
+            body: {
+                type: "string",
+                description: "Answer text (required)",
+            },
+        },
+        required: ["id", "body"],
+    },
+    handler: questionAnswerHandler,
+});
+// ── task (act tool) ────────────────────────────────────────────────────────
+async function taskCreateHandler(args) {
+    const title = args?.title || "";
+    if (!title) {
+        throw new CodebusError("'title' parameter is required");
+    }
+    const ctx = await makeCtx(resolveConfig({}));
+    const rawRefs = Array.isArray(args?.refs) ? args.refs : undefined;
+    const result = await createTaskCore(ctx, {
+        title,
+        body: args?.body,
+        owner: args?.owner,
+        project: args?.project,
+        refs: rawRefs,
+    });
+    return { display_id: result.display_id, title: result.title, status: result.status };
+}
+async function taskClaimHandler(args) {
+    const id = args?.id || "";
+    if (!id) {
+        throw new CodebusError("'id' parameter is required");
+    }
+    const ctx = await makeCtx(resolveConfig({}));
+    const result = await claimTaskCore(ctx, id);
+    return { display_id: result.display_id, status: result.status, done: result.done };
+}
+async function taskDoneHandler(args) {
+    const id = args?.id || "";
+    if (!id) {
+        throw new CodebusError("'id' parameter is required");
+    }
+    const ctx = await makeCtx(resolveConfig({}));
+    const result = await completeTaskCore(ctx, id, {
+        evidence: args?.evidence,
+        note: args?.note,
+        noEvidenceReason: args?.no_evidence_reason,
+    });
+    return { display_id: result.display_id, status: result.status, done: result.done };
+}
+TOOL_REGISTRY.push({
+    name: "task_create",
+    description: "Create a new task. Returns the task display_id, title, and initial status.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            title: {
+                type: "string",
+                description: "Task title (required)",
+            },
+            body: {
+                type: "string",
+                description: "Task description (optional)",
+            },
+            owner: {
+                type: "string",
+                description: "Owner agent slug (optional)",
+            },
+            project: {
+                type: "string",
+                description: "Project slug (optional)",
+            },
+            refs: {
+                type: "array",
+                items: { type: "string" },
+                description: "Knowledge refs to attach (optional, e.g. ['CB-DEC-000001', 'commit:abc1234'])",
+            },
+        },
+        required: ["title"],
+    },
+    handler: taskCreateHandler,
+});
+TOOL_REGISTRY.push({
+    name: "task_claim",
+    description: "Claim an open task. The task must have status!='claimed'. " +
+        "Returns the task display_id, updated status, and done flag.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            id: {
+                type: "string",
+                description: "Task ID (CB-TASK-… or uuid)",
+            },
+        },
+        required: ["id"],
+    },
+    handler: taskClaimHandler,
+});
+TOOL_REGISTRY.push({
+    name: "task_done",
+    description: "Mark a claimed task as done. Requires EITHER evidence OR an explicit " +
+        "no_evidence_reason — bare completion with neither is refused by the " +
+        "server (reliability plan §4 item 2: evidence-required done). " +
+        "Returns the task display_id, updated status, and done flag.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            id: {
+                type: "string",
+                description: "Task ID (CB-TASK-… or uuid)",
+            },
+            evidence: {
+                type: "string",
+                description: "Evidence reference (e.g., commit sha or PR url). Required unless no_evidence_reason is given.",
+            },
+            note: {
+                type: "string",
+                description: "Completion note (optional)",
+            },
+            no_evidence_reason: {
+                type: "string",
+                description: "Explicit reason there is no evidence to attach — recorded, not silent. Required if evidence is omitted.",
+            },
+        },
+        required: ["id"],
+    },
+    handler: taskDoneHandler,
+});
+// ── decision (act tool) ────────────────────────────────────────────────────
+async function decisionRecordHandler(args) {
+    const title = args?.title || "";
+    if (!title) {
+        throw new CodebusError("'title' parameter is required");
+    }
+    const ctx = await makeCtx(resolveConfig({}));
+    const result = await createDecisionCore(ctx, {
+        title,
+        slug: args?.slug,
+        body: args?.body,
+    });
+    return { display_id: result.display_id, slug: result.slug, status: result.status };
+}
+async function decisionAcceptHandler(args) {
+    const id = args?.id || "";
+    if (!id) {
+        throw new CodebusError("'id' parameter is required");
+    }
+    const ctx = await makeCtx(resolveConfig({}));
+    const result = await acceptDecisionCore(ctx, id);
+    return { display_id: result.display_id, status: result.status };
+}
+TOOL_REGISTRY.push({
+    name: "decision_record",
+    description: "Record a new decision. Decisions encode team consensus and architectural choices. " +
+        "Returns the decision display_id (e.g., CB-DEC-001), slug, and initial status.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            title: {
+                type: "string",
+                description: "Decision title (required)",
+            },
+            slug: {
+                type: "string",
+                description: "Optional slug (auto-generated from title if omitted)",
+            },
+            body: {
+                type: "string",
+                description: "Decision rationale and details (optional)",
+            },
+        },
+        required: ["title"],
+    },
+    handler: decisionRecordHandler,
+});
+TOOL_REGISTRY.push({
+    name: "decision_accept",
+    description: "Accept a decision (owner-only). Marks it as accepted. " +
+        "Returns the decision display_id and updated status.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            id: {
+                type: "string",
+                description: "Decision ID (CB-DEC-… or uuid)",
+            },
+        },
+        required: ["id"],
+    },
+    handler: decisionAcceptHandler,
+});
+// ── send (act tool) ────────────────────────────────────────────────────────
+async function sendHandler(args) {
+    const to = args?.to || "";
+    const body = args?.body || "";
+    const type = args?.type || "";
+    if (!to || !body || !type) {
+        throw new CodebusError("'to', 'body', and 'type' parameters are required");
+    }
+    const ctx = await makeCtx(resolveConfig({}));
+    const rawRefs = Array.isArray(args?.refs) ? args.refs : undefined;
+    const result = await sendMessageCore(ctx, {
+        to,
+        body,
+        type,
+        subject: args?.subject,
+        project: args?.project,
+        replyTo: args?.reply_to,
+        refs: rawRefs,
+        urgency: args?.urgency,
+        // MINOR fix (review finding #8): the MCP send tool silently dropped
+        // headline/required_action — sendMessageCore/send_message support the
+        // structured-handover fields (0036/0048), but nothing on this path ever
+        // forwarded them, so an MCP-originated send could never carry one.
+        headline: args?.headline,
+        requiredAction: args?.required_action,
+    });
+    return {
+        display_id: result.display_id, type: result.type, to: result.to, urgency: result.urgency,
+        headline: result.headline, required_action: result.required_action,
+        // RC2 sender-side nudge: present (non-null) when a `note` with no
+        // required_action reads like a request — advisory only, never blocks the
+        // send. The MCP path has no stderr the calling agent would see, so this
+        // travels in the tool result itself instead (see send.ts sendMessageCore).
+        warning: result.warning,
+    };
+}
+TOOL_REGISTRY.push({
+    name: "send",
+    description: "Send a message to one or more agents. Recipients are comma-separated agent slugs. " +
+        "Valid message types: ask, handoff, note, plan. Optionally attach a structured handover " +
+        "(headline + required_action). " +
+        "Returns the message display_id, type, recipient list, urgency, headline, and required_action. " +
+        "A non-null `warning` in the result means this note reads like a work order — " +
+        "consider resending with type=ask/handoff or required_action so it surfaces as unhandled work.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            to: {
+                type: "string",
+                description: "Recipient agent slugs, comma-separated (required)",
+            },
+            body: {
+                type: "string",
+                description: "Message body (required)",
+            },
+            type: {
+                type: "string",
+                description: "Message type: ask|handoff|note|plan (required)",
+                enum: ["ask", "handoff", "note", "plan"],
+            },
+            subject: {
+                type: "string",
+                description: "Message subject line (optional)",
+            },
+            project: {
+                type: "string",
+                description: "Project slug (optional)",
+            },
+            reply_to: {
+                type: "string",
+                description: "Message ID to reply to (optional)",
+            },
+            headline: {
+                type: "string",
+                description: "One-line summary of the handover, surfaced ahead of the body by read/inbox (optional)",
+            },
+            required_action: {
+                type: "string",
+                description: "The concrete action the recipient owes in response (optional)",
+            },
+            refs: {
+                type: "array",
+                items: { type: "string" },
+                description: "Knowledge refs to attach (optional, e.g. ['CB-DEC-000001', 'commit:abc1234'])",
+            },
+            urgency: {
+                type: "string",
+                description: "Urgency tier: digest (default) | speak_now (S5)",
+                enum: ["digest", "speak_now"],
+            },
+        },
+        required: ["to", "body", "type"],
+    },
+    handler: sendHandler,
+});
+// ── session_end (act tool) ─────────────────────────────────────────────────
+async function sessionEndHandler(args) {
+    const ctx = await makeCtx(resolveConfig({}));
+    // Validate optional type parameter early
+    const type = args?.type;
+    if (type && !["handoff", "note"].includes(type)) {
+        throw new CodebusError(`type must be 'handoff' or 'note', got: ${type}`);
+    }
+    const result = await endSessionCore(ctx, {
+        summary: args?.summary,
+        to: args?.to,
+        type: args?.type,
+        task: args?.task,
+        pr: args?.pr,
+        question: args?.question,
+        openQuestion: args?.open_question,
+        caveat: args?.caveat,
+        next: args?.next,
+    });
+    return { display_id: result.display_id, type: result.type, linked: result.linked };
+}
+TOOL_REGISTRY.push({
+    name: "session_end",
+    description: "End a session with an optional handoff/note. Posts a structured message with git context, " +
+        "linked entities (tasks, PRs, questions), and next steps. " +
+        "Returns the message display_id, type, and linked entities.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            summary: {
+                type: "string",
+                description: "Session summary (optional)",
+            },
+            to: {
+                type: "string",
+                description: "Recipients (comma-separated agent slugs, optional)",
+            },
+            type: {
+                type: "string",
+                description: "Message type: handoff|note (optional, default 'handoff')",
+                enum: ["handoff", "note"],
+            },
+            task: {
+                type: "string",
+                description: "Linked task IDs (CB-TASK-…, comma-separated, optional)",
+            },
+            pr: {
+                type: "string",
+                description: "Linked PR IDs (CB-PR-…, comma-separated, optional)",
+            },
+            question: {
+                type: "string",
+                description: "Linked question IDs (CB-Q-…, comma-separated, optional)",
+            },
+            open_question: {
+                type: "string",
+                description: "Open questions text (optional)",
+            },
+            caveat: {
+                type: "string",
+                description: "Caveats and warnings (optional)",
+            },
+            next: {
+                type: "string",
+                description: "What to do next (optional)",
+            },
+        },
+        required: [],
+    },
+    handler: sessionEndHandler,
+});
+// ── compile_pack (read tool) ───────────────────────────────────────────────
+async function compilePackHandler(args) {
+    const ctx = await makeCtx(resolveConfig({}));
+    const budget = args?.budget ?? 800;
+    const result = await compilePackCore(ctx, {
+        query: args?.query,
+        taskId: args?.task,
+        budget,
+    });
+    return result;
+}
+TOOL_REGISTRY.push({
+    name: "compile_pack",
+    description: "Compile a cited, budget-trimmed context pack of accepted decisions + open questions + locked constraints " +
+        "relevant to a query or task. Computed live from the CodeBus database. No LLM required. " +
+        "Every item is cited with its display_id (CB-DEC-…, CB-Q-…, CB-TASK-…). " +
+        "Superseded decisions surface only when adjacent, prefixed 're-litigation'.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            query: {
+                type: "string",
+                description: "Natural language query to focus the pack (optional)",
+            },
+            task: {
+                type: "string",
+                description: "CB-TASK-… id; uses graph adjacency to focus items (optional)",
+            },
+            budget: {
+                type: "number",
+                description: "Max output tokens (optional, default 800)",
+            },
+        },
+        required: [],
+    },
+    handler: compilePackHandler,
+});
+// ── plan_status / delivery_status (read tools, Repo Intelligence B5+D4) ────
+// plan_status is a BRAND NEW MCP tool with no prior callers — unlike the
+// CLI's `plan status` verb (restored to its pre-0069 alias behavior per
+// the F3 compatibility ruling), this tool calls the NEW bus_plan_status
+// rollup (planRollupCore) directly; there is no compatibility surface to
+// protect on a tool that never existed before this migration.
+async function planStatusHandler(args) {
+    const ctx = await makeCtx(resolveConfig({}));
+    return await planRollupCore(ctx, args?.plan || undefined);
+}
+TOOL_REGISTRY.push({
+    name: "plan_status",
+    description: "Per-plan task/ticket/PR pipeline + Jira coverage + delivery/environment + derived-health rollup " +
+        "(bus_plan_status). Omit 'plan' to list every plan visible to the caller in this workspace. Read-only.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            plan: {
+                type: "string",
+                description: "Plan uuid to scope to a single plan (optional; omit to list every visible plan)",
+            },
+        },
+        required: [],
+    },
+    handler: planStatusHandler,
+});
+async function deliveryStatusHandler(args) {
+    const ctx = await makeCtx(resolveConfig({}));
+    return await planDeliveryCore(ctx, {
+        cursor: args?.cursor,
+        limit: args?.limit,
+    });
+}
+TOOL_REGISTRY.push({
+    name: "delivery_status",
+    description: "Keyset-paginated per-plan delivery rollup (bus_delivery_status): three_greens, environment " +
+        "containment, and the graph_status quality leg forwarded verbatim. Hard-capped at 100 rows per page; " +
+        "pass the previous call's next_cursor to continue. Read-only.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            cursor: {
+                type: "string",
+                description: "Pagination cursor from a previous call's next_cursor (optional)",
+            },
+            limit: {
+                type: "integer",
+                description: "Page size (optional, default 50, hard-capped at 100)",
+            },
+        },
+        required: [],
+    },
+    handler: deliveryStatusHandler,
+});
+// ── resolve_refs (read tool, S4) ───────────────────────────────────────────
+async function resolveRefsHandler(args) {
+    const id = args?.id || "";
+    if (!id)
+        throw new CodebusError("'id' parameter is required");
+    const ctx = await makeCtx(resolveConfig({}));
+    const refs = await resolveRefsCore(ctx, id);
+    return { refs };
+}
+TOOL_REGISTRY.push({
+    name: "resolve_refs",
+    description: "List the typed SHA-pinned knowledge refs attached to a task or message (CB-TASK-… or CB-MSG-…). " +
+        "Each ref includes target_display_id, pinned_sha, head_sha, and state (fresh|drifted|unknown|unresolvable). " +
+        "A drifted ref means the pinned sha differs from HEAD. An unresolvable ref means the target " +
+        "is in another workspace or was deleted. Read-only.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            id: {
+                type: "string",
+                description: "Task or message display_id (CB-TASK-… or CB-MSG-…) or uuid",
+            },
+        },
+        required: ["id"],
+    },
+    handler: resolveRefsHandler,
+});
+//# sourceMappingURL=mcp-registry.js.map