@code-yeongyu/senpi 2026.10.8 → 2026.10.10-2

package/dist/core/extensions/builtin/compaction/lane-policy.js

@@ -66,6 +66,23 @@ export function createCompactionLanePolicy(options = {}) {
     const load = options.loadProviderSettings ?? loadAnthropicSubscriptionProviderSettingsFromDisk;
     let cachedCwd;
     let cachedResumeMode;
+    // Per-cwd cache is the intended contract (pinned by lane-policy.test.ts):
+    // resumeMode is read once per cwd. A mid-session switch takes effect on
+    // the next cwd or session. Returns false when the settings cannot be read,
+    // so callers fail closed to senpi's full behavior.
+    const resolveResumeMode = (cwd) => {
+        if (cachedCwd === cwd)
+            return true;
+        try {
+            cachedResumeMode = load(cwd).resumeMode;
+        }
+        catch {
+            cachedCwd = undefined;
+            return false;
+        }
+        cachedCwd = cwd;
+        return true;
+    };
     // Declared as a local so `ownsCompaction` never depends on `this`: the policy object
     // is routinely destructured at call sites, which would otherwise unbind the receiver.
     const disablesSenpiCompaction = (context) => {
@@ -76,25 +93,21 @@ export function createCompactionLanePolicy(options = {}) {
         // the escape hatch for lanes whose SDK never fires native compaction.
         if (context.getCompactionSettings?.().model)
             return false;
-        // Per-cwd cache is the intended contract (pinned by lane-policy.test.ts):
-        // resumeMode is read once per cwd. A mid-session switch takes effect on
-        // the next cwd or session.
-        if (cachedCwd !== context.cwd) {
-            try {
-                cachedResumeMode = load(context.cwd).resumeMode;
-            }
-            catch {
-                // A settings read failure must never silently disable senpi compaction:
-                // fail closed by keeping senpi's own compaction fully active.
-                cachedCwd = undefined;
-                return false;
-            }
-            cachedCwd = context.cwd;
-        }
+        // A settings read failure must never silently disable senpi compaction:
+        // fail closed by keeping senpi's own compaction fully active.
+        if (!resolveResumeMode(context.cwd))
+            return false;
         return isSdkNativeCompactionLane({ model: context.model, resumeMode: cachedResumeMode });
     };
     return {
         disablesSenpiCompaction,
+        hasAppendOnlyTranscript(context) {
+            if (context.model?.provider !== ANTHROPIC_SUBSCRIPTION_PROVIDER_ID)
+                return false;
+            if (!resolveResumeMode(context.cwd))
+                return false;
+            return cachedResumeMode !== "off";
+        },
         ownsCompaction(context, reason) {
             // Manual is senpi-owned everywhere: it is the user's explicit recovery path,
             // including on an SDK-native lane whose automatic routes stay SDK-owned.

package/dist/core/extensions/builtin/compaction/log.d.ts

@@ -6,6 +6,7 @@ export interface CompactionLoggerData {
     variant?: string;
     generation?: number;
     requestId?: string;
+    sessionId?: string;
     tokens?: number;
     tokensBefore?: number;
     savedTokens?: number;
@@ -21,6 +22,7 @@ export interface CompactionLogger {
     info(event: CompactionLoggerEvent, data?: CompactionLoggerData): void;
 }
 export interface CompactionLoggerOptions {
+    getSessionId?: () => string;
     sink?: (line: string) => void;
     mirrorToStderr?: boolean;
     maxBytes?: number;

package/dist/core/extensions/builtin/compaction/log.js

@@ -10,6 +10,7 @@ const ALLOWED_KEYS = new Set([
     "variant",
     "generation",
     "requestId",
+    "sessionId",
     "tokens",
     "tokensBefore",
     "savedTokens",
@@ -55,7 +56,7 @@ export function createCompactionLogger(agentDir, options = {}) {
         try {
             if (!EVENTS.has(event))
                 return;
-            const line = formatLine(level, event, data);
+            const line = formatLine(level, event, { ...data, sessionId: options.getSessionId?.() ?? data?.sessionId });
             writeLine(filePath, line, maxBytes, options.sink);
             if (options.mirrorToStderr ?? envValue("COMPACTION_DEBUG") === "1") {
                 console.error(DEBUG_PREFIX, line);

package/dist/core/extensions/builtin/goal/cache-warm-renderer.js

@@ -28,7 +28,7 @@ function titleLine(data) {
         case "scheduled":
             return `⚡ Cache-warm wait${iterationText} · ${wakeSources}`;
         case "resumed":
-            return `⚡ Cache-warm wake${iterationText} · ${formatExpectedWake(data.dueAtMs, data.waitedMs ?? data.delayMs)} · ${wakeSources}`;
+            return `⚡ Cache-warm wake${iterationText} · waited ${formatWakeDuration(data.waitedMs ?? data.delayMs)} · ${wakeSources}`;
     }
 }
 function validIteration(value) {
@@ -48,7 +48,14 @@ function whyLine(data) {
                 : `${backstop} - the goal resumes as soon as a wake source delivers; the ${formatCacheTtl(data.cache.ttlSeconds)} prompt-cache TTL may elapse first.`;
         }
         case "resumed":
-            return "Woke on schedule to keep pursuing the goal.";
+            switch (data.wakeCause) {
+                case "timer":
+                    return "The stall backstop fired; queued the goal continuation.";
+                case "sources-drained":
+                    return "Wake sources finished; queued the goal continuation.";
+                case undefined:
+                    return "Queued the goal continuation; the wake trigger was not recorded.";
+            }
     }
 }
 function formatExpectedWake(dueAtMs, elapsedMs) {
@@ -66,18 +73,17 @@ function warmLine(data) {
     const cache = data.cache;
     if (cache === undefined || cache.cachedTokens <= 0)
         return undefined;
-    const tokens = `~${formatWarmTokenCount(cache.cachedTokens)} tokens`;
+    const body = `Prior turn: ~${formatWarmTokenCount(cache.cachedTokens)} cache-read/write tokens (cumulative)`;
     if (cache.cacheLifetime === "best-effort") {
-        return `${tokens} were cached after the prior turn · provider caching is best-effort, with no expiry to beat`;
+        return `${body} · provider caching is best-effort; next cache hit unverified`;
     }
     const ttlMayHaveElapsed = cache.ttlSeconds !== undefined && (data.waitedMs ?? data.delayMs) >= cache.ttlSeconds * 1000;
     if (ttlMayHaveElapsed) {
-        return `${tokens} were cached after the prior turn · prompt-cache TTL may have elapsed before this wake`;
+        return `${body} · prompt-cache TTL may have elapsed; next cache hit unverified`;
     }
-    const body = data.phase === "scheduled" ? `${tokens} kept warm` : `${tokens} stayed warm in the prompt cache`;
     const saved = cache.estimatedSavedUsd !== undefined && cache.estimatedSavedUsd > 0
-        ? ` · est. ${formatSavedUsd(cache.estimatedSavedUsd)} saved vs a cold re-read`
+        ? ` · est. ${formatSavedUsd(cache.estimatedSavedUsd)} discount if reused`
         : "";
-    return `${body}${saved}`;
+    return `${body}${saved} · next cache hit unverified`;
 }
 //# sourceMappingURL=cache-warm-renderer.js.map

package/dist/core/extensions/builtin/goal/cache-warm.d.ts

@@ -49,9 +49,9 @@ export interface GoalCacheWarmMetrics {
     readonly ttlSeconds?: number;
     /** Set when the provider caches automatically with no expiry contract; no TTL or savings are claimed. */
     readonly cacheLifetime?: "best-effort";
-    /** Tokens sitting warm in the provider prompt cache after the last turn. */
+    /** Cumulative cache-read/write tokens reported across the prior agent run's requests, not unique context size. */
     readonly cachedTokens: number;
-    /** Estimated USD saved by re-reading those tokens from cache instead of paying a cold input read. */
+    /** Hypothetical read discount at current model prices if the same token volume is reused from cache. */
     readonly estimatedSavedUsd?: number;
 }
 export type GoalCacheWarmupPhase = "scheduled" | "resumed";
@@ -71,6 +71,8 @@ export interface GoalCacheWarmupEntryData {
     readonly dueAtMs?: number;
     /** Actual wait in milliseconds; present on the `resumed` phase only. */
     readonly waitedMs?: number;
+    /** Actual resumption trigger; absent on legacy entries whose cause was not recorded. */
+    readonly wakeCause?: "timer" | "sources-drained";
     /** Backward-compatible field containing the total active wake-source count. */
     readonly activeMonitorCount: number;
     /** Full source-keyed snapshot; absent on entries written before wake sources were generalized. */

package/dist/core/extensions/builtin/goal/monitor-continuation.js

@@ -394,6 +394,8 @@ export class MonitorAwareGoalContinuation {
         const delayMs = this.#scheduledDelayMs ??
             (kind === "monitor" ? GOAL_MONITOR_CONTINUATION_FALLBACK_DELAY_MS : GOAL_USER_GRACE_DELAY_MS);
         const waitedMs = this.#scheduledAtMs === undefined ? delayMs : Math.max(0, Date.now() - this.#scheduledAtMs);
+        const dueAtMs = this.#scheduledAtMs === undefined ? undefined : this.#scheduledAtMs + delayMs;
+        const wakeCause = drainFire ? "sources-drained" : "timer";
         const cache = this.#scheduledCache;
         const iteration = this.#scheduledCacheWarmIteration;
         this.#scheduledAtMs = undefined;
@@ -413,7 +415,9 @@ export class MonitorAwareGoalContinuation {
         this.#pi.events?.emit(GOAL_CONTINUATION_RESUMED_EVENT, {
             goalId: goal.id,
             delayMs,
+            dueAtMs,
             waitedMs,
+            wakeCause,
             iteration,
             activeMonitorCount: this.#activeWakeSourceCount(),
             wakeSources,
@@ -423,7 +427,9 @@ export class MonitorAwareGoalContinuation {
             phase: "resumed",
             goalId: goal.id,
             delayMs,
+            dueAtMs,
             waitedMs,
+            wakeCause,
             iteration,
             activeMonitorCount: this.#activeWakeSourceCount(),
             wakeSources,

package/dist/core/extensions/builtin/mcp/commands.js

@@ -1,6 +1,7 @@
 import { noticeEntryRenderer } from "../../notice/index.js";
 import { handleMcpAuthCommand } from "./auth/commands-auth-dispatch.js";
 import { addGlobalMcpServer, setGlobalMcpServerEnabled } from "./config-edit.js";
+import { showMcpManager } from "./manager.js";
 import { getMcpService } from "./service.js";
 import { MCP_STARTUP_RACE_MS } from "./startup-race.js";
 import { buildMcpStatusRows, formatMcpStatus } from "./status.js";
@@ -29,7 +30,7 @@ export function registerMcpCommands(pi, service = getMcpService(), pendingAttach
                 // in flight. Every subcommand reports or mutates attached state, so wait for the single
                 // in-flight attach rather than rendering a half-connected snapshot.
                 await pendingAttach();
-                await handleMcpCommand(rawArgs, ctx, pi, service);
+                await handleMcpCommand(splitCommandArgs(rawArgs), ctx, pi, service);
             }
             catch (error) {
                 ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
@@ -37,11 +38,15 @@ export function registerMcpCommands(pi, service = getMcpService(), pendingAttach
         },
     });
 }
-async function handleMcpCommand(rawArgs, ctx, pi, service) {
-    const args = splitCommandArgs(rawArgs);
+async function handleMcpCommand(args, ctx, pi, service, notify) {
     const subcommand = args[0] ?? "";
     if (subcommand === "") {
-        await showPanel(ctx, service);
+        if (!ctx.hasUI || ctx.mode !== "tui") {
+            ctx.ui.notify(await renderStatus("MCP servers", service));
+        }
+        else {
+            await showMcpManager(ctx, pi, service, (command, name, commandCtx, commandNotify) => handleMcpCommand([command, name], commandCtx, pi, service, commandNotify));
+        }
         return;
     }
     if (AUTH_SUBCOMMANDS.has(subcommand)) {
@@ -61,7 +66,7 @@ async function handleMcpCommand(rawArgs, ctx, pi, service) {
         return;
     }
     if (subcommand === "test") {
-        await testServer(args[1] ?? "", ctx, service);
+        await testServer(args[1] ?? "", ctx, service, notify);
         return;
     }
     if (subcommand === "logs") {
@@ -69,21 +74,11 @@ async function handleMcpCommand(rawArgs, ctx, pi, service) {
         return;
     }
     if (subcommand === "reconnect") {
-        await reconnectServer(args[1] ?? "", ctx, pi, service);
+        await reconnectServer(args[1] ?? "", ctx, pi, service, notify);
         return;
     }
     ctx.ui.notify(`Unknown /mcp subcommand: ${subcommand}`, "error");
 }
-async function showPanel(ctx, service) {
-    const text = await renderStatus("MCP servers", service);
-    if (!ctx.hasUI) {
-        ctx.ui.notify(text);
-        return;
-    }
-    const choice = await ctx.ui.select(text, ["status", "logs <server>", "test <server>"]);
-    if (choice === undefined)
-        ctx.ui.notify(text);
-}
 async function notifyStatus(ctx, service) {
     ctx.ui.notify(await renderStatus("MCP status", service));
 }
@@ -122,8 +117,8 @@ async function setServerEnabled(ctx, pi, service, name, enabled) {
     await service.attachSession({ type: "session_start", reason: "reload" }, ctx, pi);
     ctx.ui.notify(`${enabled ? "Enabled" : "Disabled"} MCP server ${name}`);
 }
-async function testServer(name, ctx, service) {
-    if (!ensureKnown(name, ctx, service))
+async function testServer(name, ctx, service, notify = (text, type) => ctx.ui.notify(text, type)) {
+    if (!ensureKnown(name, ctx, service, notify))
         return;
     const connection = service.getConnection(name);
     if (connection === undefined)
@@ -134,13 +129,13 @@ async function testServer(name, ctx, service) {
         const result = await connection.client.listTools({}, { timeout: 2000 });
         const elapsedMs = Date.now() - started;
         service.recordCall(name, elapsedMs, false);
-        ctx.ui.notify(`MCP test ${name} ok (${elapsedMs}ms): ${result.tools.length} tools`);
+        notify(`MCP test ${name} ok (${elapsedMs}ms): ${result.tools.length} tools`);
     }
     catch (error) {
         const elapsedMs = Date.now() - started;
         service.recordCall(name, elapsedMs, true);
         const message = error instanceof Error ? error.message : String(error);
-        ctx.ui.notify(`MCP test ${name} failed (${elapsedMs}ms): ${message}`, "error");
+        notify(`MCP test ${name} failed (${elapsedMs}ms): ${message}`, "error");
     }
 }
 function showLogs(name, ctx, service) {
@@ -149,27 +144,27 @@ function showLogs(name, ctx, service) {
     const lines = service.getLogLines(name, 20);
     ctx.ui.notify(lines.length === 0 ? `MCP logs for ${name}: (empty)` : lines.join("\n"));
 }
-async function reconnectServer(name, ctx, pi, service) {
-    if (!ensureKnown(name, ctx, service))
+async function reconnectServer(name, ctx, pi, service, notify = (text, type) => ctx.ui.notify(text, type)) {
+    if (!ensureKnown(name, ctx, service, notify))
         return;
     try {
         await service.reconnectServer(name);
         await service.attachSession({ type: "session_start", reason: "reload" }, ctx, pi);
-        ctx.ui.notify(`MCP reconnect ${name} connected`);
+        notify(`MCP reconnect ${name} connected`);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        ctx.ui.notify(`MCP reconnect ${name} failed: ${message}`, "error");
+        notify(`MCP reconnect ${name} failed: ${message}`, "error");
     }
 }
-function ensureKnown(name, ctx, service) {
+function ensureKnown(name, ctx, service, notify = (text, type) => ctx.ui.notify(text, type)) {
     if (name.length > 0 && service.getServerSnapshots().some((snapshot) => snapshot.name === name))
         return true;
     const known = service
         .getServerSnapshots()
         .map((snapshot) => snapshot.name)
         .join(", ");
-    ctx.ui.notify(`Unknown MCP server: ${name || "<missing>"}\nKnown MCP servers: ${known || "(none)"}`, "error");
+    notify(`Unknown MCP server: ${name || "<missing>"}\nKnown MCP servers: ${known || "(none)"}`, "error");
     return false;
 }
 function parseServerConfig(endpoint) {

package/dist/core/extensions/builtin/mcp/config-edit.d.ts

@@ -2,4 +2,6 @@ import { type McpServerConfig } from "./config-schema.ts";
 export declare function getGlobalMcpConfigPath(agentDir?: string): string;
 export declare function addGlobalMcpServer(name: string, server: McpServerConfig): string;
 export declare function setGlobalMcpServerEnabled(name: string, enabled: boolean): boolean;
+/** Update only a resolved global/project source, retaining placeholders and unrelated fields. */
+export declare function updateMcpServerConfig(path: string, name: string, patch: Readonly<Pick<Partial<McpServerConfig>, "enabled" | "exposure">>): boolean;
 //# sourceMappingURL=config-edit.d.ts.map

package/dist/core/extensions/builtin/mcp/config-edit.js

@@ -14,14 +14,17 @@ export function addGlobalMcpServer(name, server) {
     return path;
 }
 export function setGlobalMcpServerEnabled(name, enabled) {
-    const path = getGlobalMcpConfigPath();
+    return updateMcpServerConfig(getGlobalMcpConfigPath(), name, { enabled });
+}
+/** Update only a resolved global/project source, retaining placeholders and unrelated fields. */
+export function updateMcpServerConfig(path, name, patch) {
     const config = readGlobalMcpConfig(path);
     const existing = config.mcpServers?.[name];
     if (existing === undefined)
         return false;
     const next = {
         ...config,
-        mcpServers: { ...(config.mcpServers ?? {}), [name]: { ...existing, enabled } },
+        mcpServers: { ...(config.mcpServers ?? {}), [name]: { ...existing, ...patch } },
     };
     writeValidatedConfig(path, next);
     return true;

package/dist/core/extensions/builtin/mcp/manager-view.d.ts

@@ -0,0 +1,34 @@
+import { type Component, type KeybindingsManager, type SelectItem, type TUI } from "@earendil-works/pi-tui";
+import { type Theme } from "../../../../modes/interactive/theme/theme.ts";
+export interface McpManagerMenu {
+    readonly title: string;
+    readonly items: SelectItem[];
+    readonly details?: string;
+    readonly empty?: string;
+    readonly confirmLabel: string;
+    readonly cancelLabel: string;
+    readonly selected?: string;
+}
+/** A focused menu that rebuilds on MCP events, never on a polling timer. */
+export declare class McpManagerView implements Component {
+    private content;
+    private inputHandler;
+    private cancelMenu;
+    private rebuild;
+    private width;
+    private rows;
+    private disposed;
+    private readonly tui;
+    private readonly theme;
+    private readonly keybindings;
+    constructor(tui: TUI, theme: Theme, keybindings: KeybindingsManager);
+    menu(build: () => McpManagerMenu | Promise<McpManagerMenu>, subscribe?: (listener: () => void) => () => void): Promise<string | undefined>;
+    status(title: string, message: string): void;
+    get columns(): number;
+    private setContent;
+    handleInput(data: string): void;
+    render(width: number): string[];
+    invalidate(): void;
+    dispose(): void;
+}
+//# sourceMappingURL=manager-view.d.ts.map

package/dist/core/extensions/builtin/mcp/manager-view.js

@@ -0,0 +1,136 @@
+import { Container, SelectList, Spacer, sanitizeTerminalLabel, Text, truncateToWidth, } from "@earendil-works/pi-tui";
+import { DynamicBorder } from "../../../../modes/interactive/components/dynamic-border.js";
+import { keyHint } from "../../../../modes/interactive/components/keybinding-hints.js";
+import { getSelectListTheme } from "../../../../modes/interactive/theme/theme.js";
+/** A focused menu that rebuilds on MCP events, never on a polling timer. */
+export class McpManagerView {
+    constructor(tui, theme, keybindings) {
+        this.content = new Container();
+        this.disposed = false;
+        this.tui = tui;
+        this.theme = theme;
+        this.keybindings = keybindings;
+        this.status("MCP servers", "Loading...");
+    }
+    menu(build, subscribe) {
+        if (this.disposed)
+            return Promise.resolve(undefined);
+        return new Promise((resolve, reject) => {
+            let generation = 0;
+            let settled = false;
+            let selected;
+            let unsubscribe;
+            const finish = (value, error) => {
+                if (settled)
+                    return;
+                settled = true;
+                generation++;
+                unsubscribe?.();
+                this.cancelMenu = undefined;
+                this.rebuild = undefined;
+                this.inputHandler = undefined;
+                if (error !== undefined)
+                    reject(error);
+                else
+                    resolve(value);
+            };
+            const render = async () => {
+                const current = ++generation;
+                try {
+                    const menu = await build();
+                    if (settled || current !== generation)
+                        return;
+                    const list = new SelectList(menu.items.map((item) => ({
+                        ...item,
+                        label: sanitizeTerminalLabel(item.label || item.value) || "(empty)",
+                        description: item.description === undefined ? undefined : sanitizeTerminalLabel(item.description),
+                    })), Math.max(1, Math.min(12, this.tui.terminal.rows - 10)), getSelectListTheme());
+                    const wanted = selected ?? menu.selected;
+                    const index = menu.items.findIndex((item) => item.value === wanted);
+                    if (index !== -1)
+                        list.setSelectedIndex(index);
+                    selected = list.getSelectedItem()?.value;
+                    list.onSelectionChange = (item) => {
+                        selected = item.value;
+                    };
+                    list.onSelect = (item) => finish(item.value);
+                    list.onCancel = () => finish(undefined);
+                    const body = [];
+                    if (menu.details)
+                        body.push(new Text(this.theme.fg("muted", menu.details.split("\n").map(sanitizeTerminalLabel).join("\n")), 1, 0));
+                    body.push(new Spacer(1));
+                    body.push(menu.items.length > 0
+                        ? list
+                        : new Text(sanitizeTerminalLabel(menu.empty ?? "Nothing to show."), 1, 0));
+                    const footer = menu.items.length > 0
+                        ? `${keyHint("tui.select.confirm", menu.confirmLabel)} | ${keyHint("tui.select.cancel", menu.cancelLabel)}`
+                        : keyHint("tui.select.cancel", menu.cancelLabel);
+                    this.setContent(menu.title, body, footer);
+                    this.inputHandler = (data) => {
+                        if (menu.items.length > 0)
+                            list.handleInput(data);
+                        else if (this.keybindings.matches(data, "tui.select.cancel"))
+                            finish(undefined);
+                    };
+                }
+                catch (error) {
+                    if (!settled && current === generation)
+                        finish(undefined, error);
+                }
+            };
+            this.cancelMenu = () => finish(undefined);
+            this.rebuild = () => void render();
+            this.inputHandler = (data) => {
+                if (this.keybindings.matches(data, "tui.select.cancel"))
+                    finish(undefined);
+            };
+            unsubscribe = subscribe?.(() => void render());
+            void render();
+        });
+    }
+    status(title, message) {
+        this.setContent(title, [
+            new Spacer(1),
+            new Text(this.theme.fg("muted", message.split("\n").map(sanitizeTerminalLabel).join("\n")), 1, 0),
+        ]);
+    }
+    get columns() {
+        return this.tui.terminal.columns;
+    }
+    setContent(title, body, footer) {
+        if (this.disposed)
+            return;
+        this.content = new Container();
+        this.content.addChild(new DynamicBorder((text) => this.theme.fg("accent", text)));
+        this.content.addChild(new Text(this.theme.fg("accent", this.theme.bold(sanitizeTerminalLabel(title))), 1, 0));
+        for (const child of body)
+            this.content.addChild(child);
+        if (footer) {
+            this.content.addChild(new Spacer(1));
+            this.content.addChild(new Text(footer, 1, 0));
+        }
+        this.content.addChild(new DynamicBorder((text) => this.theme.fg("accent", text)));
+        this.tui.requestRender();
+    }
+    handleInput(data) {
+        this.inputHandler?.(data);
+        this.tui.requestRender();
+    }
+    render(width) {
+        if (this.width !== width || this.rows !== this.tui.terminal.rows) {
+            this.width = width;
+            this.rows = this.tui.terminal.rows;
+            this.rebuild?.();
+        }
+        return this.content.render(width).map((line) => truncateToWidth(line, width, ""));
+    }
+    invalidate() {
+        this.content.invalidate();
+        this.rebuild?.();
+    }
+    dispose() {
+        this.disposed = true;
+        this.cancelMenu?.();
+    }
+}
+//# sourceMappingURL=manager-view.js.map

package/dist/core/extensions/builtin/mcp/manager.d.ts

@@ -0,0 +1,8 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "../../types.ts";
+import type { McpService } from "./service.ts";
+type McpManagerCommand = "test" | "reconnect" | "auth" | "logout";
+type Notify = ExtensionCommandContext["ui"]["notify"];
+type RunCommand = (command: McpManagerCommand, name: string, ctx: ExtensionCommandContext, notify?: Notify) => Promise<void>;
+export declare function showMcpManager(ctx: ExtensionCommandContext, pi: ExtensionAPI, service: McpService, run: RunCommand): Promise<void>;
+export {};
+//# sourceMappingURL=manager.d.ts.map