muonroi-cli 1.3.4 → 1.4.1

package/dist/src/mcp/cap-tool-result.js

@@ -0,0 +1,35 @@
+import { MAX_TOOL_OUTPUT_CHARS, truncateOutput } from "../tools/registry.js";
+function isContentResult(value) {
+    return (!!value &&
+        typeof value === "object" &&
+        value.type === "content" &&
+        Array.isArray(value.value));
+}
+function isTextPart(part) {
+    return (!!part &&
+        typeof part === "object" &&
+        part.type === "text" &&
+        typeof part.text === "string");
+}
+export function capMcpToolResult(result, maxChars = MAX_TOOL_OUTPUT_CHARS) {
+    if (typeof result === "string") {
+        return truncateOutput(result, maxChars);
+    }
+    if (isContentResult(result)) {
+        let remaining = maxChars;
+        const value = result.value.map((part) => {
+            if (!isTextPart(part))
+                return part;
+            const { text } = part;
+            if (remaining <= 0) {
+                return { ...part, text: `... [${text.length} chars omitted; full MCP output in transcript] ...` };
+            }
+            const capped = truncateOutput(text, remaining);
+            remaining -= Math.min(text.length, remaining);
+            return { ...part, text: capped };
+        });
+        return { ...result, value };
+    }
+    return result;
+}
+//# sourceMappingURL=cap-tool-result.js.map

package/dist/src/mcp/ee-tools.d.ts

@@ -0,0 +1,36 @@
+/**
+ * src/mcp/ee-tools.ts
+ *
+ * EE (Experience Engine) MCP tools: ee_query (semantic recall) + ee_health +
+ * ee_feedback (rate a recalled entry). Read-mostly; ee_feedback POSTs a verdict.
+ *
+ * Anti-mù: ee_query supports explicit "recent task checkpoint" / "Progress DONE" queries
+ * so the agent (or sub-agent) can deliberately confirm finished subtasks after compactions.
+ * collections: prefer "experience-behavioral" for compaction checkpoints (see layer3).
+ *
+ * Feedback gate: ee_query stamps every returned `[id col]` into a session-scoped
+ * pending ledger (recall-ledger.ts). Subsequent ee_query calls surface (soft) or
+ * refuse on (hard) accumulated unrated debt, so useful recalls actually get a
+ * verdict via ee_feedback — the signal the brain needs to keep the good entries
+ * and prune the rest. Mode via EXPERIENCE_RECALL_FEEDBACK_GATE = off|soft|hard
+ * (default soft); hard-mode threshold via EXPERIENCE_RECALL_FEEDBACK_THRESHOLD.
+ *
+ * Dependencies are injected (deps) so unit tests never touch the network/singleton.
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type RecallLedger } from "../ee/recall-ledger.js";
+import { type FeedbackResult, type FeedbackVerdict, type NoiseReason } from "../ee/search.js";
+import type { EERecallResponse } from "../ee/types.js";
+export interface EEToolDeps {
+    recall?: (query: string, opts: {
+        project?: string;
+    }) => Promise<EERecallResponse | null>;
+    health?: () => Promise<{
+        ok: boolean;
+        status: number;
+    }>;
+    feedback?: (pointId: string, collection: string, verdict: FeedbackVerdict, reason?: NoiseReason) => Promise<FeedbackResult>;
+    /** Session pending-recall ledger. Defaults to the process singleton. */
+    ledger?: RecallLedger;
+}
+export declare function registerEETools(server: McpServer, deps?: EEToolDeps): void;

package/dist/src/mcp/ee-tools.js

@@ -0,0 +1,159 @@
+/**
+ * src/mcp/ee-tools.ts
+ *
+ * EE (Experience Engine) MCP tools: ee_query (semantic recall) + ee_health +
+ * ee_feedback (rate a recalled entry). Read-mostly; ee_feedback POSTs a verdict.
+ *
+ * Anti-mù: ee_query supports explicit "recent task checkpoint" / "Progress DONE" queries
+ * so the agent (or sub-agent) can deliberately confirm finished subtasks after compactions.
+ * collections: prefer "experience-behavioral" for compaction checkpoints (see layer3).
+ *
+ * Feedback gate: ee_query stamps every returned `[id col]` into a session-scoped
+ * pending ledger (recall-ledger.ts). Subsequent ee_query calls surface (soft) or
+ * refuse on (hard) accumulated unrated debt, so useful recalls actually get a
+ * verdict via ee_feedback — the signal the brain needs to keep the good entries
+ * and prune the rest. Mode via EXPERIENCE_RECALL_FEEDBACK_GATE = off|soft|hard
+ * (default soft); hard-mode threshold via EXPERIENCE_RECALL_FEEDBACK_THRESHOLD.
+ *
+ * Dependencies are injected (deps) so unit tests never touch the network/singleton.
+ */
+import { z } from "zod";
+import { sessionRecallLedger } from "../ee/recall-ledger.js";
+import { formatRecallForAgent, healthEE, recallEE, } from "../ee/search.js";
+function ok(data) {
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+}
+function okText(text) {
+    return { content: [{ type: "text", text }] };
+}
+function fail(error, message) {
+    return {
+        content: [{ type: "text", text: JSON.stringify({ error, message }) }],
+        isError: true,
+    };
+}
+/** Resolve the feedback-gate policy from env at call time (so tests can vary it). */
+function resolveGate() {
+    const raw = String(process.env.EXPERIENCE_RECALL_FEEDBACK_GATE ?? "soft")
+        .trim()
+        .toLowerCase();
+    const mode = raw === "off" || raw === "hard" ? raw : "soft";
+    const parsed = Number.parseInt(process.env.EXPERIENCE_RECALL_FEEDBACK_THRESHOLD ?? "", 10);
+    const threshold = Number.isFinite(parsed) && parsed > 0 ? parsed : 3;
+    return { mode, threshold };
+}
+/** One readable block naming the still-unrated recalls + how to clear them. */
+function formatPendingBlock(pending, hard, max = 8) {
+    const shown = pending.slice(0, max);
+    const lines = shown.map((p) => `  - [${p.id} ${p.collection ?? "?"}]  (from recall: "${p.query}")`);
+    const more = pending.length > max ? `\n  …and ${pending.length - max} more` : "";
+    const head = hard
+        ? `⚠️ FEEDBACK GATE — ${pending.length} earlier recall(s) are still unrated. Rate them with ` +
+            `ee_feedback(id, collection, verdict) before pulling new recalls:`
+        : `⚠️ ${pending.length} earlier recall(s) still unrated — call ` +
+            `ee_feedback(id, collection, verdict=followed|ignored|noise) so the brain keeps what helped and prunes the rest:`;
+    return `${head}\n${lines.join("\n")}${more}`;
+}
+export function registerEETools(server, deps = {}) {
+    // Default to the shared EE recall/health/feedback helpers (src/ee/search.ts) so
+    // the MCP tools and the in-CLI builtin tools resolve auth/baseUrl the same way.
+    // Tests inject `deps` to avoid the network and a fresh `ledger` to stay isolated.
+    const recall = deps.recall ?? ((q, o) => recallEE(q, o));
+    const health = deps.health ?? (() => healthEE());
+    const ledger = deps.ledger ?? sessionRecallLedger;
+    server.registerTool("ee_query", {
+        description: "Active recall over the Experience Engine brain — prior decisions, gotchas, learned warnings/recipes, and " +
+            "task checkpoints for this codebase — via the recallMode pipeline (same path as exp-recall.js). " +
+            "CALL THIS PROACTIVELY, before acting: when starting work in an unfamiliar area, when unsure how something " +
+            "is done in this stack, before a risky or hard-to-reverse step, or to recall finished work after a " +
+            "compaction (e.g. query='recent compaction checkpoint Progress DONE for <subtask>'). A deliberate query " +
+            "here is cheaper than re-deriving or repeating a past mistake. Returns a formatted index whose entries " +
+            "carry `[id col]` handles — after you act on a recall, rate each entry you used or judged with the " +
+            "ee_feedback tool (followed/ignored/noise) so the brain keeps what helped and prunes the rest; unrated " +
+            "recalls are surfaced back to you on the next ee_query. Optional project scopes the recall. Returns a " +
+            "compact ranked index (cosine-ranked, strongest first), capped at maxChars (default 6000, range " +
+            "500-20000) and truncated from the tail; raise maxChars to see more. Returns ee_unavailable if EE is " +
+            "down (then proceed without it).",
+        inputSchema: {
+            query: z.string().min(1).max(1000),
+            project: z.string().max(200).optional(),
+            maxChars: z.number().int().min(500).max(20_000).optional(),
+        },
+    }, async ({ query, project, maxChars }) => {
+        const gate = resolveGate();
+        const pendingBefore = gate.mode === "off" ? [] : ledger.pending();
+        // Hard gate: refuse a NEW recall while unrated debt is at/over threshold —
+        // do not even spend the brain call. Below threshold, fall through to soft.
+        if (gate.mode === "hard" && pendingBefore.length >= gate.threshold) {
+            return fail("feedback_required", formatPendingBlock(pendingBefore, true));
+        }
+        try {
+            const resp = await recall(query, { project });
+            if (resp === null) {
+                return fail("ee_unavailable", "EE recall returned no response (server down, timeout, or circuit open)");
+            }
+            // Stamp the new entries as pending debt (unless the gate is off).
+            if (gate.mode !== "off")
+                ledger.record(resp.entries, query);
+            // Return the compact `[id col]` index (capped) rather than JSON.stringify
+            // of the whole response — the wide-net recall text (~30k) otherwise blows
+            // the MCP per-result token cap and spills to a file. See formatRecallForAgent.
+            const index = formatRecallForAgent(resp, { query, maxChars });
+            if (gate.mode !== "off" && pendingBefore.length > 0) {
+                return okText(`${formatPendingBlock(pendingBefore, false)}\n\n${index}`);
+            }
+            return okText(index);
+        }
+        catch (e) {
+            return fail("ee_unavailable", e instanceof Error ? e.message : String(e));
+        }
+    });
+    server.registerTool("ee_feedback", {
+        description: "Rate an Experience Engine recall entry so the brain keeps what helped and prunes the rest. Call after " +
+            "acting on an ee_query result — once per `[id col]` you used or judged. verdict: 'followed' (you changed " +
+            "your approach because of it), 'ignored' (topical but did not apply this time), 'noise' (wrong by category — " +
+            "REQUIRES reason: wrong_repo | wrong_language | wrong_task | stale_rule). id may be a short prefix; the " +
+            "server resolves it. Clears the entry from this session's pending-feedback gate.",
+        inputSchema: {
+            id: z.string().min(1).max(200),
+            collection: z.string().min(1).max(200),
+            verdict: z.enum(["followed", "ignored", "noise"]),
+            reason: z.enum(["wrong_repo", "wrong_language", "wrong_task", "stale_rule"]).optional(),
+        },
+    }, async ({ id, collection, verdict, reason }) => {
+        if (verdict === "noise" && !reason) {
+            return fail("reason_required", "verdict 'noise' requires reason: wrong_repo | wrong_language | wrong_task | stale_rule");
+        }
+        const feedback = deps.feedback ?? ((pid, col, v, r) => import("../ee/search.js").then((m) => m.feedbackEE(pid, col, v, r)));
+        try {
+            const result = await feedback(id, collection, verdict, reason);
+            if (!result.ok) {
+                return fail("feedback_failed", result.error ?? "feedback POST failed");
+            }
+            // Clear by the server-resolved full id AND the (possibly short) id the
+            // agent passed, so a prefix-based call still settles the ledger debt.
+            const clearedId = result.resolvedId ?? id;
+            ledger.clear(clearedId);
+            ledger.clear(id);
+            return ok({
+                ok: true,
+                id: clearedId,
+                verdict: result.verdict,
+                ...(result.reason ? { reason: result.reason } : {}),
+                pendingRemaining: ledger.pendingCount(),
+            });
+        }
+        catch (e) {
+            return fail("feedback_failed", e instanceof Error ? e.message : String(e));
+        }
+    });
+    server.registerTool("ee_health", { description: "Check Experience Engine server reachability.", inputSchema: {} }, async () => {
+        try {
+            return ok(await health());
+        }
+        catch (e) {
+            return fail("ee_unavailable", e instanceof Error ? e.message : String(e));
+        }
+    });
+}
+//# sourceMappingURL=ee-tools.js.map

package/dist/src/mcp/forensics-tools.d.ts

@@ -0,0 +1,13 @@
+/**
+ * src/mcp/forensics-tools.ts
+ *
+ * usage.forensics MCP tool: per-session token-cost forensics by id prefix.
+ * Read-only (local SQLite). Dependencies injected for unit testability.
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CostForensicsSummary } from "../cli/cost-forensics.js";
+export interface ForensicsToolDeps {
+    resolve?: (prefix: string) => string[] | Promise<string[]>;
+    collect?: (sessionId: string) => CostForensicsSummary | Promise<CostForensicsSummary>;
+}
+export declare function registerForensicsTools(server: McpServer, deps?: ForensicsToolDeps): void;

package/dist/src/mcp/forensics-tools.js

@@ -0,0 +1,52 @@
+/**
+ * src/mcp/forensics-tools.ts
+ *
+ * usage.forensics MCP tool: per-session token-cost forensics by id prefix.
+ * Read-only (local SQLite). Dependencies injected for unit testability.
+ */
+import { z } from "zod";
+function ok(data) {
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+}
+function fail(error, message, extra) {
+    return {
+        content: [{ type: "text", text: JSON.stringify({ error, message, ...extra }) }],
+        isError: true,
+    };
+}
+async function defaultResolve(prefix) {
+    const { resolveSessionIds } = await import("../cli/cost-forensics.js");
+    return resolveSessionIds(prefix);
+}
+async function defaultCollect(sessionId) {
+    const { collectCostForensics } = await import("../cli/cost-forensics.js");
+    return collectCostForensics(sessionId);
+}
+export function registerForensicsTools(server, deps = {}) {
+    const resolve = deps.resolve ?? defaultResolve;
+    const collect = deps.collect ?? defaultCollect;
+    server.registerTool("usage_forensics", {
+        description: "Per-session token-cost forensics by session-id prefix: peak input, cache-hit ratio, per-event breakdown.",
+        inputSchema: { prefix: z.string().min(1).max(100) },
+    }, async ({ prefix }) => {
+        let ids;
+        try {
+            ids = await resolve(prefix);
+        }
+        catch (e) {
+            return fail("db_error", e instanceof Error ? e.message : String(e));
+        }
+        if (ids.length === 0)
+            return fail("not_found", `no session matches prefix '${prefix}'`);
+        if (ids.length > 1)
+            return fail("ambiguous", `prefix '${prefix}' matched ${ids.length} sessions`, { matches: ids });
+        try {
+            const summary = await collect(ids[0]);
+            return ok(summary);
+        }
+        catch (e) {
+            return fail("db_error", e instanceof Error ? e.message : String(e));
+        }
+    });
+}
+//# sourceMappingURL=forensics-tools.js.map

package/dist/src/mcp/lsp-tools.d.ts

@@ -0,0 +1,16 @@
+/**
+ * src/mcp/lsp-tools.ts
+ *
+ * LSP code-intelligence MCP tool: a single lsp.query that mirrors the native
+ * lsp tool surface (9 operations multiplexed through one query). Read-only.
+ * Wraps queryLsp() (which caches one language-server manager per cwd).
+ *
+ * deps are injected so unit tests never spawn a real language server.
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type LspQueryInput, type LspToolResponse } from "../lsp/types.js";
+export interface LspToolDeps {
+    query?: (cwd: string, input: LspQueryInput) => Promise<LspToolResponse>;
+    enabled?: (cwd: string) => boolean | Promise<boolean>;
+}
+export declare function registerLspTools(server: McpServer, deps?: LspToolDeps): void;

package/dist/src/mcp/lsp-tools.js

@@ -0,0 +1,65 @@
+/**
+ * src/mcp/lsp-tools.ts
+ *
+ * LSP code-intelligence MCP tool: a single lsp.query that mirrors the native
+ * lsp tool surface (9 operations multiplexed through one query). Read-only.
+ * Wraps queryLsp() (which caches one language-server manager per cwd).
+ *
+ * deps are injected so unit tests never spawn a real language server.
+ */
+import { z } from "zod";
+import { LSP_TOOL_OPERATIONS } from "../lsp/types.js";
+function ok(data) {
+    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+}
+function fail(error, message) {
+    return {
+        content: [{ type: "text", text: JSON.stringify({ error, message }) }],
+        isError: true,
+    };
+}
+async function defaultQuery(cwd, input) {
+    const { queryLsp } = await import("../lsp/runtime.js");
+    return queryLsp(cwd, input);
+}
+async function defaultEnabled(cwd) {
+    const { isLspToolEnabled } = await import("../lsp/runtime.js");
+    return isLspToolEnabled(cwd);
+}
+export function registerLspTools(server, deps = {}) {
+    const query = deps.query ?? defaultQuery;
+    const enabled = deps.enabled ?? defaultEnabled;
+    server.registerTool("lsp_query", {
+        description: "Semantic code intelligence via language servers. operation is one of: goToDefinition, findReferences, hover, documentSymbol, workspaceSymbol, goToImplementation, prepareCallHierarchy, incomingCalls, outgoingCalls. " +
+            "filePath: absolute, or relative to the workspace root (cwd). line/character: 1-based (line 1 = first line, like an editor or file:line reference) — required for position-based ops; omit for documentSymbol; use query (not position) for workspaceSymbol. " +
+            'Returns {success, output}: output is a pretty-printed JSON array of LSP results (each {uri, range} with LSP-native 0-based range positions), or "No results found." when empty. ' +
+            "A slow server that has not finished loading its workspace returns no results for that call (no hang) — retry once it has warmed up. Note: csharp-ls answers position ops (goToDefinition/hover/references) almost immediately but only returns documentSymbol after the project/solution has been restored and loaded.",
+        inputSchema: {
+            operation: z.enum(LSP_TOOL_OPERATIONS),
+            filePath: z.string().min(1).max(1000),
+            line: z.number().int().min(0).optional(),
+            character: z.number().int().min(0).optional(),
+            query: z.string().max(1000).optional(),
+        },
+    }, async (args) => {
+        const cwd = process.cwd();
+        let isEnabled;
+        try {
+            isEnabled = await enabled(cwd);
+        }
+        catch (e) {
+            return fail("lsp_error", e instanceof Error ? e.message : String(e));
+        }
+        if (!isEnabled) {
+            return fail("lsp_disabled", "LSP tool is disabled in settings (lsp.enabled / lsp.tool)");
+        }
+        try {
+            const resp = await query(cwd, args);
+            return ok(resp);
+        }
+        catch (e) {
+            return fail("lsp_error", e instanceof Error ? e.message : String(e));
+        }
+    });
+}
+//# sourceMappingURL=lsp-tools.js.map

package/dist/src/mcp/mcp-keychain.js

@@ -32,8 +32,17 @@ export async function setMcpKey(id, key) {
     if (!kt?.setPassword)
         return false;
     redactor.enrollSecret(key);
-    await kt.setPassword(KEYCHAIN_SERVICE, ACCOUNT_BY_MCP[id], key);
-    return true;
+    try {
+        await kt.setPassword(KEYCHAIN_SERVICE, ACCOUNT_BY_MCP[id], key);
+        return true;
+    }
+    catch (err) {
+        // Runtime backend failure (e.g. Linux without libsecret or no active secret service).
+        if (process.env.DEBUG || process.env.MUONROI_DEBUG_KEYCHAIN) {
+            console.error(`[mcp-keychain] setPassword backend error for ${id}:`, err?.message || err);
+        }
+        return false;
+    }
 }
 export async function getMcpKey(id) {
     const kt = await loadKeytar();

package/dist/src/mcp/oauth-callback.js

@@ -1,7 +1,7 @@
 import http from "node:http";
 import { URL } from "node:url";
-const SUCCESS_HTML = `<!DOCTYPE html><html><body style="font-family:system-ui;text-align:center;padding:60px">
-<h2>Authorization successful</h2><p>You can close this tab and return to the terminal.</p>
+const SUCCESS_HTML = `<!DOCTYPE html><html><body style="font-family:system-ui;text-align:center;padding:60px">
+<h2>Authorization successful</h2><p>You can close this tab and return to the terminal.</p>
 </body></html>`;
 export function startOAuthCallbackServer(opts) {
     const callbackPath = opts.path ?? "/callback";

package/dist/src/mcp/opentui-spawn.js

@@ -45,7 +45,7 @@ export const opentuiSpawn = async (req) => {
         proc,
         sendLine: (line) => {
             // Ensure the line is newline-terminated when written to the child.
-            const payload = line.endsWith("\n") ? line : line + "\n";
+            const payload = line.endsWith("\n") ? line : `${line}\n`;
             inWrite.write(payload);
         },
         onLine: (cb) => {

package/dist/src/mcp/parse-headers.test.js

@@ -2,19 +2,19 @@ import { describe, expect, it } from "vitest";
 import { parseEnvLines, parseHeaderLines } from "./parse-headers.js";
 describe("parseHeaderLines", () => {
     it("parses colon-separated headers and trims whitespace", () => {
-        expect(parseHeaderLines(`
-        Authorization: Bearer token
-        X-Trace-Id:  abc123
+        expect(parseHeaderLines(`
+        Authorization: Bearer token
+        X-Trace-Id:  abc123
       `)).toEqual({
             Authorization: "Bearer token",
             "X-Trace-Id": "abc123",
         });
     });
     it("ignores blank and malformed lines while preserving later colons in values", () => {
-        expect(parseHeaderLines(`
-        invalid
-        : missing-name
-        Host: example.com:443
+        expect(parseHeaderLines(`
+        invalid
+        : missing-name
+        Host: example.com:443
       `)).toEqual({
             Host: "example.com:443",
         });
@@ -22,19 +22,19 @@ describe("parseHeaderLines", () => {
 });
 describe("parseEnvLines", () => {
     it("parses equals-separated env assignments and trims whitespace", () => {
-        expect(parseEnvLines(`
-        API_KEY = secret
-        MODE= production
+        expect(parseEnvLines(`
+        API_KEY = secret
+        MODE= production
       `)).toEqual({
             API_KEY: "secret",
             MODE: "production",
         });
     });
     it("ignores blank and malformed lines while preserving later equals in values", () => {
-        expect(parseEnvLines(`
-        missing
-        = no-name
-        URL=https://example.com?a=b
+        expect(parseEnvLines(`
+        missing
+        = no-name
+        URL=https://example.com?a=b
       `)).toEqual({
             URL: "https://example.com?a=b",
         });

package/dist/src/mcp/runtime.js

@@ -1,6 +1,7 @@
 import { createMCPClient } from "@ai-sdk/mcp";
 import { jsonSchema } from "@ai-sdk/provider-utils";
 import { getDefaultEnvironment, StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { capMcpToolResult } from "./cap-tool-result.js";
 import { getMcpKey } from "./mcp-keychain.js";
 import { createOAuthProviderWithCallback } from "./oauth-provider.js";
 import { validateMcpServerConfig } from "./validate.js";
@@ -124,9 +125,19 @@ export async function buildMcpToolSet(servers, opts) {
                 const safeName = name.replace(/[^a-zA-Z0-9_-]/g, "_");
                 const prefixedName = `${prefix}__${safeName}`;
                 const stripped = stripMcpInputSchema(tool);
+                // Cap MCP tool output the same way built-in tools are capped
+                // (`truncateOutput` / MAX_TOOL_OUTPUT_CHARS). Without this wrap the raw
+                // server payload streams into the model context uncapped — a cost leak
+                // that hits cheap models hardest. See cap-tool-result.ts.
+                const baseExecute = stripped.execute;
                 tools[prefixedName] = {
                     ...stripped,
                     description: `[MCP ${server.label}] ${tool.description ?? name}`,
+                    ...(typeof baseExecute === "function"
+                        ? {
+                            execute: async (args, options) => capMcpToolResult(await baseExecute(args, options)),
+                        }
+                        : {}),
                 };
             }
         }

package/dist/src/mcp/self-verify-jobs.d.ts

@@ -0,0 +1,55 @@
+/**
+ * src/mcp/self-verify-jobs.ts
+ *
+ * In-process job tracker for self-verify runs exposed over MCP.
+ * Pure module: the actual self-verify execution is injected via the Runner
+ * interface so unit tests never spawn a real TUI.
+ */
+import type { AgenticReport } from "../self-qa/agentic-loop.js";
+import type { SelfVerifyReport } from "../self-qa/index.js";
+export type JobKind = "tier1" | "agentic";
+export type JobStatus = "running" | "done" | "error" | "cancelled";
+export interface StartTier1Opts {
+    kind: "tier1";
+    since?: string;
+    max?: number;
+    emit?: boolean;
+    out?: string;
+}
+export interface StartAgenticOpts {
+    kind: "agentic";
+    goal: string;
+    llm: string;
+    turns?: number;
+}
+export type StartOpts = StartTier1Opts | StartAgenticOpts;
+export interface Job {
+    runId: string;
+    kind: JobKind;
+    status: JobStatus;
+    startedAt: number;
+    finishedAt?: number;
+    logBuffer: string[];
+    report?: SelfVerifyReport | AgenticReport;
+    error?: string;
+}
+/**
+ * Execution backend. The default implementation (in tools-server.ts) calls
+ * runSelfVerify / runAgenticLoop. `signal` is best-effort — the underlying
+ * self-verify functions may ignore it; cancellation discards any late result.
+ */
+export interface Runner {
+    tier1(opts: StartTier1Opts, log: (m: string) => void, signal: AbortSignal): Promise<SelfVerifyReport>;
+    agentic(opts: StartAgenticOpts, log: (m: string) => void, signal: AbortSignal): Promise<AgenticReport>;
+}
+export declare class JobManager {
+    private readonly runner;
+    private jobs;
+    private controllers;
+    constructor(runner: Runner);
+    start(opts: StartOpts): string;
+    status(runId: string): Job | undefined;
+    list(): Job[];
+    cancel(runId: string): boolean;
+    private evict;
+}

package/dist/src/mcp/self-verify-jobs.js

@@ -0,0 +1,86 @@
+/**
+ * src/mcp/self-verify-jobs.ts
+ *
+ * In-process job tracker for self-verify runs exposed over MCP.
+ * Pure module: the actual self-verify execution is injected via the Runner
+ * interface so unit tests never spawn a real TUI.
+ */
+import { randomUUID } from "node:crypto";
+const LOG_CAP = 2000;
+const JOB_CAP = 20;
+export class JobManager {
+    runner;
+    jobs = new Map();
+    controllers = new Map();
+    constructor(runner) {
+        this.runner = runner;
+    }
+    start(opts) {
+        const runId = randomUUID();
+        const ctrl = new AbortController();
+        const job = {
+            runId,
+            kind: opts.kind,
+            status: "running",
+            startedAt: Date.now(),
+            logBuffer: [],
+        };
+        this.jobs.set(runId, job);
+        this.controllers.set(runId, ctrl);
+        this.evict();
+        const log = (m) => {
+            job.logBuffer.push(m);
+            if (job.logBuffer.length > LOG_CAP) {
+                job.logBuffer.splice(0, job.logBuffer.length - LOG_CAP);
+            }
+        };
+        const run = opts.kind === "tier1"
+            ? this.runner.tier1(opts, log, ctrl.signal)
+            : this.runner.agentic(opts, log, ctrl.signal);
+        run.then((report) => {
+            this.controllers.delete(runId); // I2: keep maps symmetric after natural completion
+            if (job.status === "cancelled")
+                return;
+            job.report = report;
+            job.status = "done";
+            job.finishedAt = Date.now();
+        }, (err) => {
+            this.controllers.delete(runId); // I2: keep maps symmetric after natural completion
+            if (job.status === "cancelled")
+                return;
+            job.error = err instanceof Error ? err.message : String(err);
+            job.status = "error";
+            job.finishedAt = Date.now();
+        });
+        return runId;
+    }
+    status(runId) {
+        return this.jobs.get(runId);
+    }
+    list() {
+        return [...this.jobs.values()];
+    }
+    cancel(runId) {
+        const job = this.jobs.get(runId);
+        if (!job || job.status !== "running")
+            return false;
+        this.controllers.get(runId)?.abort();
+        job.status = "cancelled";
+        job.finishedAt = Date.now();
+        return true;
+    }
+    evict() {
+        if (this.jobs.size <= JOB_CAP)
+            return;
+        const sorted = [...this.jobs.values()].sort((a, b) => a.startedAt - b.startedAt);
+        while (this.jobs.size > JOB_CAP) {
+            const oldest = sorted.shift();
+            if (!oldest)
+                break;
+            this.controllers.get(oldest.runId)?.abort(); // I1: abort still-running evicted jobs
+            this.jobs.delete(oldest.runId);
+            this.controllers.delete(oldest.runId);
+        }
+    }
+}
+//# sourceMappingURL=self-verify-jobs.js.map