@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/mcp/tools.js

@@ -0,0 +1,252 @@
+/**
+ * Adapts MCP tools to pi tool definitions.
+ *
+ * Results map onto pi's model-facing content (text and images). Text over 20KB keeps its start and
+ * end with the middle cut out, like Codex does, and the full text is saved to a temp file the model
+ * can read. Binary resources other than images are saved to temp files too, and resource links name
+ * the `read_mcp_resource` tool. Codemode scripts receive the whole `CallToolResult` without `_meta`
+ * (`content` blocks as sent by the server, `structuredContent`, `isError`), never truncated: it is
+ * the tool's `structuredContent`, and every MCP tool declares a `CallToolResult` output schema. MCP
+ * errors (`isError`) are error results for the model, but scripts still resolve to the result.
+ */
+import { createHash } from "node:crypto";
+import { toLlmContent, } from "@earendil-works/pi-mcp";
+import { Container, Spacer, Text } from "@earendil-works/pi-tui";
+import { READ_MCP_RESOURCE_TOOL } from "../../core/mcp-servers.js";
+import { formatToolCallWithArgs, getTextOutput, replaceTabs } from "../../core/tools/render-utils.js";
+import { formatSize, truncateMiddle } from "../../core/tools/truncate.js";
+import { keyHint } from "../../modes/interactive/components/keybinding-hints.js";
+import { VisualLinePreview } from "../../modes/interactive/components/visual-truncate.js";
+import { writeOutputFile } from "../../utils/output-files.js";
+/**
+ * Tool exposure of an MCP exposure. `codemode` and `deferred` both leave tools out of the codemode
+ * description; they differ only in which tool the MCP extension activates to reach them.
+ */
+export function toToolExposure(exposure) {
+    return exposure === "codemode" ? "deferred" : exposure;
+}
+/** Provider tool names are limited to 64 characters of `[A-Za-z0-9_-]`. */
+const MAX_TOOL_NAME_LENGTH = 64;
+/** Model-facing text of an MCP result beyond this is cut in the middle. */
+export const MCP_OUTPUT_MAX_BYTES = 20 * 1024;
+/** Visual (wrapped) result lines shown before the output is expanded. */
+const OUTPUT_PREVIEW_LINES = 5;
+/** Tool that reads the resources named by resource links. */
+export { READ_MCP_RESOURCE_TOOL };
+export function saveToTempFile(data, extension) {
+    return writeOutputFile("pi-mcp", extension, data);
+}
+/**
+ * `mcp__<server>__<tool>`, sanitized and shortened with a hash suffix when too long. Like Codex,
+ * everything but `[A-Za-z0-9_]` becomes `_`, so the name is also the identifier codemode scripts
+ * call it by. `isTaken` reports names used by a different MCP tool: sanitizing can map two tools to
+ * one name (`a-b` and `a_b`), which then get the hash suffix.
+ */
+export function createMcpToolName(server, tool, isTaken = () => false) {
+    const name = `mcp__${server}__${tool}`.replace(/[^A-Za-z0-9_]/g, "_");
+    if (name.length <= MAX_TOOL_NAME_LENGTH && !isTaken(name))
+        return name;
+    const hash = createHash("sha256").update(`${server}\0${tool}`).digest("hex").slice(0, 8);
+    return `${name.slice(0, MAX_TOOL_NAME_LENGTH - hash.length - 1)}_${hash}`;
+}
+function textOf(content) {
+    return content
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join("\n");
+}
+/**
+ * Output schema of every MCP tool: the `CallToolResult` scripts receive, with the tool's own output
+ * schema as `structuredContent`. Codemode detects this shape to render `CallToolResult<T>`
+ * declarations.
+ */
+export function createMcpResultSchema(structuredContentSchema) {
+    return {
+        type: "object",
+        properties: {
+            content: { type: "array", items: { type: "object" } },
+            ...(structuredContentSchema ? { structuredContent: structuredContentSchema } : {}),
+            isError: { type: "boolean" },
+            _meta: { type: "object" },
+        },
+        required: ["content"],
+    };
+}
+/**
+ * Keep model-facing text within {@link MCP_OUTPUT_MAX_BYTES}. Longer text becomes one text block in
+ * Codex's truncation format, followed by the path of the file with the full text; images follow it.
+ */
+export async function limitMcpContent(content, saveOutput = saveToTempFile) {
+    const combined = textOf(content);
+    const truncation = truncateMiddle(combined, MCP_OUTPUT_MAX_BYTES);
+    if (!truncation.truncated)
+        return { content };
+    let fullOutputPath;
+    let where;
+    try {
+        fullOutputPath = await saveOutput(combined, ".txt");
+        where = `[Full output: ${fullOutputPath} (read it with offset/limit)]`;
+    }
+    catch (error) {
+        where = `[Could not save the full output: ${error instanceof Error ? error.message : String(error)}]`;
+    }
+    const tokens = Math.ceil(truncation.totalBytes / 4);
+    const text = `Warning: truncated output (original token count: ${tokens})\nTotal output lines: ${truncation.totalLines}\n\n${truncation.content}\n\n${where}`;
+    return {
+        content: [{ type: "text", text }, ...content.filter((block) => block.type === "image")],
+        ...(fullOutputPath ? { fullOutputPath } : {}),
+    };
+}
+/** File extension for a saved binary resource: the one its URI ends in, else `.bin`. */
+function extensionOf(uri) {
+    const path = URL.canParse(uri) ? new URL(uri).pathname : uri;
+    return /\.[A-Za-z0-9]{1,8}$/.exec(path)?.[0] ?? ".bin";
+}
+/** Blobs of these types are shown as text. */
+function isTextMimeType(mimeType) {
+    if (!mimeType)
+        return false;
+    const type = mimeType.split(";", 1)[0].trim().toLowerCase();
+    return type.startsWith("text/") || type === "application/json" || type.endsWith("+json") || type.endsWith("+xml");
+}
+/** Model-facing content of one block of `server`'s result. */
+async function blockToContent(server, block, options) {
+    if (block.type === "resource_link") {
+        const details = [block.mimeType, block.size === undefined ? undefined : formatSize(block.size)].filter(Boolean);
+        const read = options.readableResources ? `. Read it with ${READ_MCP_RESOURCE_TOOL} (server "${server}")` : "";
+        const description = block.description ? `: ${block.description}` : "";
+        return [
+            {
+                type: "text",
+                text: `[Resource ${block.uri} "${block.title ?? block.name}"${details.length > 0 ? ` (${details.join(", ")})` : ""}${description}${read}]`,
+            },
+        ];
+    }
+    if (block.type === "resource" && "blob" in block.resource && !block.resource.mimeType?.startsWith("image/")) {
+        const { uri, mimeType, blob } = block.resource;
+        const data = Buffer.from(blob, "base64");
+        if (isTextMimeType(mimeType))
+            return [{ type: "text", text: data.toString("utf8") }];
+        const kind = `${mimeType ?? "unknown type"}, ${formatSize(data.length)}`;
+        try {
+            const path = await (options.saveOutput ?? saveToTempFile)(data, extensionOf(uri));
+            return [{ type: "text", text: `[Binary resource ${uri} (${kind}) saved to ${path}]` }];
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            return [{ type: "text", text: `[Binary resource ${uri} (${kind}) could not be saved: ${reason}]` }];
+        }
+    }
+    return toLlmContent({ content: [block] });
+}
+/** Model-facing content of `server`'s content blocks, before the output limit. */
+export async function toModelContent(server, blocks, options = {}) {
+    return (await Promise.all(blocks.map((block) => blockToContent(server, block, options)))).flat();
+}
+/** Convert an MCP result. `isError` results become error results that keep the structured result. */
+export async function convertMcpResult(server, tool, result, options = {}) {
+    // Without content blocks, toLlmContent falls back to the structured content as JSON.
+    const converted = result.content.length > 0 ? await toModelContent(server, result.content, options) : toLlmContent(result);
+    if (result.isError && textOf(converted) === "") {
+        converted.push({ type: "text", text: `MCP tool ${server}/${tool} returned an error` });
+    }
+    const { content, fullOutputPath } = await limitMcpContent(converted, options.saveOutput);
+    const { _meta: _ignored, ...scriptResult } = result;
+    return {
+        content,
+        details: { server, tool, ...(fullOutputPath ? { fullOutputPath } : {}) },
+        structuredContent: scriptResult,
+        ...(result.isError ? { isError: true } : {}),
+    };
+}
+/**
+ * Tool input schemas must be objects. MCP servers may omit `type`, and some providers reject object
+ * schemas without `properties`.
+ */
+function toParameters(schema) {
+    return {
+        ...schema,
+        type: schema.type ?? "object",
+        ...(schema.properties === undefined ? { properties: {} } : {}),
+    };
+}
+const ANNOTATION_HINTS = ["readOnlyHint", "destructiveHint", "idempotentHint", "openWorldHint"];
+/** The boolean hints of an MCP tool's annotations, or undefined when it has none. */
+function toToolAnnotations(tool) {
+    const annotations = {};
+    for (const hint of ANNOTATION_HINTS) {
+        const value = tool.annotations?.[hint];
+        if (typeof value === "boolean")
+            annotations[hint] = value;
+    }
+    return Object.keys(annotations).length > 0 ? annotations : undefined;
+}
+export function createMcpToolDefinition(options) {
+    const { server, tool } = options;
+    const title = tool.title ?? tool.annotations?.title;
+    const annotations = toToolAnnotations(tool);
+    const label = `${server}/${tool.name}`;
+    return {
+        name: options.name,
+        label,
+        description: tool.description?.trim() || title || `MCP tool ${tool.name} from server ${server}`,
+        parameters: toParameters(tool.inputSchema),
+        outputSchema: createMcpResultSchema(tool.outputSchema),
+        exposure: toToolExposure(options.exposure),
+        namespace: options.namespace,
+        ...(annotations ? { annotations } : {}),
+        ...createMcpToolRenderers(label),
+        async execute(_toolCallId, params, signal, onUpdate) {
+            const client = await options.getClient();
+            const result = await client.callTool(tool.name, (params ?? {}), {
+                signal,
+                timeoutMs: options.timeoutMs,
+                onProgress: (progress) => {
+                    const total = progress.total === undefined ? "" : `/${progress.total}`;
+                    const text = progress.message ?? `Progress ${progress.progress}${total}`;
+                    onUpdate?.({ content: [{ type: "text", text }], details: { server, tool: tool.name } });
+                },
+            });
+            return convertMcpResult(server, tool.name, result, { readableResources: options.readableResources?.() });
+        },
+    };
+}
+/** Renderers of calls to an MCP tool, labeled `server/tool`, also used before the tool is registered. */
+export function createMcpToolRenderers(label) {
+    return {
+        renderCall(args, theme, context) {
+            const component = context.lastComponent ?? new Text("", 0, 0);
+            component.setText(formatToolCallWithArgs(label, args, theme, context.expanded));
+            return component;
+        },
+        renderResult(result, options, theme, context) {
+            const component = context.lastComponent ?? new Container();
+            component.clear();
+            const output = getTextOutput(result, context.showImages).trim();
+            if (!output)
+                return component;
+            const color = context.isError ? "error" : "toolOutput";
+            const styled = replaceTabs(output)
+                .split("\n")
+                .map((line) => theme.fg(color, line))
+                .join("\n");
+            component.addChild(new Spacer(1));
+            if (options.expanded) {
+                component.addChild(new Text(styled, 0, 0));
+            }
+            else {
+                // Limit wrapped lines, not logical ones: MCP results are often one long JSON line.
+                component.addChild(new VisualLinePreview({
+                    text: styled,
+                    maxVisualLines: OUTPUT_PREVIEW_LINES,
+                    keep: "start",
+                    formatHint: (hidden) => `${theme.fg("muted", `... (${hidden} more lines,`)} ${keyHint("app.tools.expand", "to expand")}${theme.fg("muted", ")")}`,
+                }));
+                const fullOutputPath = result.details?.fullOutputPath;
+                if (fullOutputPath)
+                    component.addChild(new Text(theme.fg("muted", `Full output: ${fullOutputPath}`), 0, 0));
+            }
+            return component;
+        },
+    };
+}

package/dist/extensions/mcp/ui.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The `/mcp` manager view: menus that rebuild while servers connect, a read-only status screen, and
+ * the sign-in screen that accepts a pasted redirect URL.
+ */
+import { type Component, type Focusable, type SelectItem, type TUI } from "@earendil-works/pi-tui";
+import type { ExtensionCommandContext } from "../../core/extensions/types.ts";
+import type { KeybindingsManager } from "../../core/keybindings.ts";
+import { type Theme } from "../../modes/interactive/theme/theme.ts";
+export interface McpMenu {
+    title: string;
+    /** Shown below the title. */
+    details?: string;
+    /** Shown below the details in the error color. */
+    error?: string;
+    items: SelectItem[];
+    /** Shown when there are no items. */
+    empty?: string;
+    /** Value of the item selected when the menu opens. */
+    selected?: string;
+    /** What the confirm key does, for the key hint. */
+    confirmLabel: string;
+    /** What the cancel key does, for the key hint. */
+    cancelLabel: string;
+}
+export interface McpUi {
+    /**
+     * Show a menu and resolve to the chosen item's value, or undefined when cancelled. `subscribe`
+     * rebuilds the menu on every change, keeping the selected item.
+     */
+    menu(build: () => McpMenu, subscribe?: (listener: () => void) => () => void): Promise<string | undefined>;
+    /** Show a message while an operation runs. With `onCancel`, the cancel key calls it. */
+    status(title: string, message: string, onCancel?: () => void): void;
+    /**
+     * Show the authorization URL and wait for a pasted redirect URL. Resolves to undefined when
+     * cancelled or when `signal` aborts (the browser reached the callback).
+     */
+    redirectUrl(title: string, authorizationUrl: string, signal: AbortSignal): Promise<string | undefined>;
+}
+export declare class McpManagerView implements McpUi, Component, Focusable {
+    private readonly tui;
+    private readonly theme;
+    private readonly keybindings;
+    private content;
+    private inputHandler;
+    private inputTarget;
+    private _focused;
+    constructor(tui: TUI, theme: Theme, keybindings: KeybindingsManager);
+    get focused(): boolean;
+    set focused(value: boolean);
+    private setContent;
+    menu(build: () => McpMenu, subscribe?: (listener: () => void) => () => void): Promise<string | undefined>;
+    status(title: string, message: string, onCancel?: () => void): void;
+    redirectUrl(title: string, authorizationUrl: string, signal: AbortSignal): Promise<string | undefined>;
+    handleInput(data: string): void;
+    render(width: number): string[];
+    invalidate(): void;
+}
+/** Run `manage` in the manager view until it returns. */
+export declare function showMcpManager(ctx: ExtensionCommandContext, manage: (ui: McpUi) => Promise<void>): Promise<void>;

package/dist/extensions/mcp/ui.js

@@ -0,0 +1,185 @@
+/**
+ * The `/mcp` manager view: menus that rebuild while servers connect, a read-only status screen, and
+ * the sign-in screen that accepts a pasted redirect URL.
+ */
+import { Container, Input, SelectList, Spacer, Text, truncateToWidth, visibleWidth, } from "@earendil-works/pi-tui";
+import { AuthUrlComponent } from "../../modes/interactive/components/auth-url.js";
+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";
+function frame(theme, title, body, footer) {
+    const container = new Container();
+    container.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+    container.addChild(new Text(theme.fg("accent", theme.bold(title)), 1, 0));
+    for (const child of body)
+        container.addChild(child);
+    if (footer) {
+        container.addChild(new Spacer(1));
+        container.addChild(new Text(theme.fg("dim", footer), 1, 0));
+    }
+    container.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+    return container;
+}
+const MAX_VISIBLE_ITEMS = 12;
+export class McpManagerView {
+    tui;
+    theme;
+    keybindings;
+    content;
+    inputHandler;
+    inputTarget;
+    _focused = false;
+    constructor(tui, theme, keybindings) {
+        this.tui = tui;
+        this.theme = theme;
+        this.keybindings = keybindings;
+        this.content = frame(theme, "MCP servers", [new Text(theme.fg("muted", "Loading…"), 1, 1)]);
+    }
+    get focused() {
+        return this._focused;
+    }
+    set focused(value) {
+        this._focused = value;
+        if (this.inputTarget)
+            this.inputTarget.focused = value;
+    }
+    setContent(content, inputHandler, inputTarget) {
+        if (this.inputTarget)
+            this.inputTarget.focused = false;
+        this.content = content;
+        this.inputHandler = inputHandler;
+        this.inputTarget = inputTarget;
+        if (this.inputTarget)
+            this.inputTarget.focused = this._focused;
+        this.tui.requestRender();
+    }
+    menu(build, subscribe) {
+        return new Promise((resolve) => {
+            let unsubscribe;
+            let settled = false;
+            const finish = (value) => {
+                if (settled)
+                    return;
+                settled = true;
+                unsubscribe?.();
+                resolve(value);
+            };
+            let selected;
+            const render = () => {
+                const menu = build();
+                const wanted = selected ?? menu.selected;
+                const body = [];
+                if (menu.details)
+                    body.push(new Text(this.theme.fg("muted", menu.details), 1, 0));
+                if (menu.error)
+                    body.push(new Text(this.theme.fg("error", menu.error), 1, 0));
+                body.push(new Spacer(1));
+                const footer = `${keyHint("tui.select.confirm", menu.confirmLabel)} • ${keyHint("tui.select.cancel", menu.cancelLabel)}`;
+                if (menu.items.length === 0) {
+                    body.push(new Text(this.theme.fg("muted", menu.empty ?? "Nothing to show."), 1, 0));
+                    this.setContent(frame(this.theme, menu.title, body, keyHint("tui.select.cancel", menu.cancelLabel)), (data) => {
+                        if (this.keybindings.matches(data, "tui.select.cancel"))
+                            finish(undefined);
+                    });
+                    return;
+                }
+                const list = new SelectList(menu.items, Math.min(menu.items.length, MAX_VISIBLE_ITEMS), getSelectListTheme());
+                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);
+                body.push(list);
+                this.setContent(frame(this.theme, menu.title, body, footer), (data) => list.handleInput(data));
+            };
+            render();
+            unsubscribe = subscribe?.(() => {
+                if (!settled)
+                    render();
+            });
+        });
+    }
+    status(title, message, onCancel) {
+        const body = [new Spacer(1), new Text(this.theme.fg("muted", message), 1, 0)];
+        if (!onCancel) {
+            this.setContent(frame(this.theme, title, body));
+            return;
+        }
+        this.setContent(frame(this.theme, title, body, keyHint("tui.select.cancel", "cancel")), (data) => {
+            if (this.keybindings.matches(data, "tui.select.cancel"))
+                onCancel();
+        });
+    }
+    redirectUrl(title, authorizationUrl, signal) {
+        return new Promise((resolve) => {
+            let settled = false;
+            const finish = (value) => {
+                if (settled)
+                    return;
+                settled = true;
+                signal.removeEventListener("abort", onAbort);
+                resolve(value);
+            };
+            const onAbort = () => finish(undefined);
+            if (signal.aborted) {
+                finish(undefined);
+                return;
+            }
+            signal.addEventListener("abort", onAbort, { once: true });
+            const input = new Input();
+            const link = new AuthUrlComponent(this.tui, authorizationUrl);
+            const body = [
+                new Spacer(1),
+                new Text(this.theme.fg("muted", "Approve access in your browser. If it did not open, visit:"), 1, 0),
+                link,
+                new Spacer(1),
+                new Text(this.theme.fg("muted", "If the browser runs on another machine, paste the URL it was redirected to:"), 1, 0),
+                input,
+            ];
+            this.setContent(frame(this.theme, title, body, `${keyHint("tui.select.confirm", "submit")} • ${keyHint("tui.select.cancel", "cancel")}`), (data) => {
+                if (this.keybindings.matches(data, "tui.select.confirm")) {
+                    const value = input.getValue().trim();
+                    if (value)
+                        finish(value);
+                    return;
+                }
+                if (this.keybindings.matches(data, "tui.select.cancel")) {
+                    finish(undefined);
+                    return;
+                }
+                if (this.keybindings.matches(data, "app.message.copy")) {
+                    void link.copy();
+                    return;
+                }
+                input.handleInput(data);
+            }, input);
+        });
+    }
+    handleInput(data) {
+        this.inputHandler?.(data);
+        this.tui.requestRender();
+    }
+    render(width) {
+        return this.content
+            .render(width)
+            .map((line) => (visibleWidth(line) > width ? truncateToWidth(line, width, "") : line));
+    }
+    invalidate() {
+        this.content.invalidate();
+    }
+}
+/** Run `manage` in the manager view until it returns. */
+export async function showMcpManager(ctx, manage) {
+    await ctx.ui.custom((tui, theme, keybindings, done) => {
+        const view = new McpManagerView(tui, theme, keybindings);
+        void manage(view).then(() => done(), (error) => {
+            ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+            done();
+        });
+        return view;
+    });
+}

package/dist/extensions/package.json

@@ -20,6 +20,7 @@
 			"./inline-skills.ts",
 			"./jev-advisory-routing.ts",
 			"./jev-ask-tool.ts",
+			"./jev-tool-ranker.ts",
 			"./rtk.ts",
 			"./tokenin-onboarding.ts",
 			"./pi-graft",
@@ -29,7 +30,7 @@
 			"./pi-tool-display",
 			"./pi-hermes-memory",
 			"./tps.ts",
-			"./capability-gateway",
+			"./skills-index",
 			"./pi-zentui/extensions/zentui/index.ts"
 		]
 	}

package/dist/extensions/pi-graft/index.ts

@@ -64,8 +64,6 @@ import {
 	recoveryFor,
 	reduceGraftState,
 	type RetrievalMode,
-	STATUS_KEY,
-	statusText,
 } from "./state.ts";
 import { GRAFT_TOOL_NAMES, registerGraftTools } from "./tools.ts";
 
@@ -280,14 +278,12 @@ export default function graftExtension(pi: ExtensionAPI): void {
 	let structuralBuildSession: GraftSession | undefined;
 	const guard = createInjectionGuard();
 
-	const applyEvent = (ctx: ExtensionContext | undefined, event: GraftEvent): void => {
+	const applyEvent = (_ctx: ExtensionContext | undefined, event: GraftEvent): void => {
 		session.state = reduceGraftState(session.state, event);
-		if (ctx?.hasUI) ctx.ui.setStatus(STATUS_KEY, statusText(session.state));
 	};
 
-	const setMode = (mode: RetrievalMode, ctx?: ExtensionContext): void => {
+	const setMode = (mode: RetrievalMode, _ctx?: ExtensionContext): void => {
 		session.mode = mode;
-		if (ctx?.hasUI) ctx.ui.setStatus(`${STATUS_KEY}-mode`, `graft mode: ${mode}`);
 	};
 
 	/** Share one global npm install between startup and a concurrent `/graft` command. */
@@ -506,10 +502,7 @@ export default function graftExtension(pi: ExtensionAPI): void {
 		session.disposed = false;
 		session.settings = readGraftSettings({ cwd: ctx.cwd, trusted: ctx.isProjectTrusted() });
 		session.enabled = session.settings.enabled !== false;
-		if (!session.enabled) {
-			if (ctx.hasUI) ctx.ui.setStatus(STATUS_KEY, undefined);
-			return;
-		}
+		if (!session.enabled) return;
 		if (session.settings.telemetry !== "inherit") session.telemetry = applyTelemetryDefault();
 		setMode(readBranchMode(ctx.sessionManager.getBranch()) ?? session.settings.mode ?? DEFAULT_RETRIEVAL_MODE, ctx);
 
@@ -518,13 +511,9 @@ export default function graftExtension(pi: ExtensionAPI): void {
 		else autoBuild(ctx, session);
 	});
 
-	pi.on("session_shutdown", (_event: SessionShutdownEvent, ctx: ExtensionContext) => {
+	pi.on("session_shutdown", (_event: SessionShutdownEvent) => {
 		session.disposed = true;
 		session.telemetry?.restore();
-		if (ctx.hasUI) {
-			ctx.ui.setStatus(STATUS_KEY, undefined);
-			ctx.ui.setStatus(`${STATUS_KEY}-mode`, undefined);
-		}
 		guard.beginTurn();
 		session = freshSession();
 	});
@@ -638,10 +627,6 @@ export default function graftExtension(pi: ExtensionAPI): void {
 		const debounceMs = (session.settings.refreshDebounceSeconds ?? DEFAULT_REFRESH_DEBOUNCE_SECONDS) * 1000;
 		if (Date.now() - session.lastRefreshAt < debounceMs) return;
 		session.lastRefreshAt = Date.now();
-		if (ctx.hasUI) {
-			ctx.ui.setStatus(STATUS_KEY, statusText(reduceGraftState(session.state, { type: "refresh-started" })));
-		}
-
 		void (async () => {
 			try {
 				const run = await buildGraph(ctx, session, "refresh");