neoctl 0.2.26 → 0.2.28

package/dist/web/index.js

@@ -15,7 +15,8 @@ import { CommunicationLogger, LoggingModelGateway } from "../model/communication
 import { createModelGatewayFromConfig, createModelGatewayFromProcessEnv } from "../model/provider-factory.js";
 import { ToolRegistry } from "../tools/registry.js";
 import { editTool, writeTool } from "../tools/builtins/edit-tool.js";
-import { createExecTool } from "../tools/builtins/exec-tool.js";
+import { createExecTool, createWriteStdinTool } from "../tools/builtins/exec-tool.js";
+import { ExecProcessManager } from "../tools/builtins/exec-process-manager.js";
 import { listDirectoryTool, readFileTool } from "../tools/builtins/filesystem-tools.js";
 import { grepTool } from "../tools/builtins/grep-tool.js";
 import { searchTool } from "../tools/builtins/search-tool.js";
@@ -27,9 +28,12 @@ import { createTaskTools } from "../tasks/task-tools.js";
 import { TaskStore } from "../tasks/task-store.js";
 import { parseReplCommand, helpText, replCommandDefinitions } from "../repl/commands.js";
 import { writeSessionMarkdownExport } from "../session/session-export.js";
+import { DefaultContextManager } from "../context/context-manager.js";
 import { WEB_HTML } from "./html.js";
 import { openDirectory } from "../open-directory.js";
 import { resolveImageBlockDataSync } from "../core/image-storage.js";
+import { isWebPlanPayload, serializeWebPlanPayload, webPlanBodyTitle } from "./plan-payload.js";
+import { createWebRuntimeContextPayload } from "./runtime-context-protocol.js";
 const require = createRequire(import.meta.url);
 const markedPackageDir = path.dirname(require.resolve("marked/package.json"));
 const highlightPackageDir = path.dirname(require.resolve("@highlightjs/cdn-assets/package.json"));
@@ -80,6 +84,11 @@ function sumUsageTokens(left, right) {
         return undefined;
     return (left ?? 0) + (right ?? 0);
 }
+// UI actions report structured results to the client. They must not append UiLine
+// entries: the transcript is reserved for conversation, tool, and user-command events.
+function actionFailure(errorCode, error) {
+    return { ok: false, errorCode, error };
+}
 const DEFAULT_WEB_RUNTIME_KEY = "__default__";
 export async function runWebServer(argv = process.argv.slice(2), runtimeOptions = {}) {
     const options = parseWebArgs(argv);
@@ -114,10 +123,15 @@ export async function createWebRuntime(options = {}) {
     const communicationLogger = new CommunicationLogger();
     const modelGateway = new LoggingModelGateway(createModelGatewayFromProcessEnv(process.env), communicationLogger);
     const taskStore = new TaskStore();
+    const pluginCatalog = normalizeWebRuntimePlugins(options.externalPlugins);
+    const pluginOverrides = normalizePluginOverrides(options.sessionPluginOverrides, pluginCatalog);
+    const activePlugins = activeWebRuntimePlugins(pluginCatalog, pluginOverrides);
     const tools = new ToolRegistry();
+    const execProcessManager = new ExecProcessManager();
     tools.register(editTool);
     tools.register(writeTool);
-    tools.register(createExecTool({ taskStore }));
+    tools.register(createExecTool({ processManager: execProcessManager }));
+    tools.register(createWriteStdinTool(execProcessManager));
     tools.register(listDirectoryTool);
     tools.register(readFileTool);
     tools.register(grepTool);
@@ -128,13 +142,16 @@ export async function createWebRuntime(options = {}) {
     tools.register(planTool);
     for (const tool of options.externalTools ?? [])
         tools.register(tool);
+    for (const plugin of activePlugins)
+        for (const tool of plugin.tools)
+            tools.register(tool);
     const agentRuntime = { modelGateway, tools, taskStore };
     tools.register(createAgentTool(agentRuntime));
     const resumeHandler = async (taskId, directive) => {
         const dummyContext = {
             agentId: "main",
             tools,
-            appState: new InMemoryAppState("main"),
+            appState: new InMemoryAppState("main", options.cwd),
             emit: () => undefined,
         };
         return resumeAgentTask(taskId, directive, agentRuntime, taskStore, dummyContext);
@@ -144,15 +161,21 @@ export async function createWebRuntime(options = {}) {
     const appPromptStore = new InMemoryAppPromptStore();
     const engine = new QueryEngine({
         agentId: options.agentId ?? "main",
+        cwd: options.cwd,
         model: modelConfig?.model,
-        fallbackModel: modelConfig?.fallbackModel,
         reasoning: modelConfig?.defaultReasoning,
         queryOrigin: "web",
         modelGateway,
         tools,
+        contextManagerFactory: (cwd) => new DefaultContextManager({ cwd }),
+        additionalPromptSections: [
+            ...(options.externalPromptSections ?? []),
+            ...activePlugins.flatMap((plugin) => plugin.promptSections ?? []),
+        ],
         appPromptStore,
         taskNotificationSource: createTaskNotificationSource(taskStore),
         commands: replCommandDefinitions.map((command) => command.usage),
+        plugins: [...(options.plugins ?? []), ...activePlugins.map((plugin) => plugin.id)],
         session: {
             enabled: process.env.AGENT_SESSION_TRANSCRIPT !== "0",
             sessionId: options.sessionId ?? process.env.AGENT_SESSION_ID,
@@ -171,13 +194,45 @@ export async function createWebRuntime(options = {}) {
         agentRuntime,
         usage: new SessionUsageTracker(),
         taskStore,
+        execProcessManager,
         tools,
         initialMetrics,
         defaultReasoning: modelConfig?.defaultReasoning,
         envPath: process.env.NEO_ENV_FILE?.trim() ? path.resolve(process.env.NEO_ENV_FILE.trim()) : envLoad.userDotEnvPath,
         envNotice: envLoad.createdUserDotEnv ? formatCreatedEnvNotice(envLoad.userDotEnvPath) : undefined,
+        pluginSupport: pluginCatalog.length ? {
+            catalog: pluginCatalog,
+            overrides: pluginOverrides,
+            basePromptSections: [...(options.externalPromptSections ?? [])],
+            basePluginIds: [...(options.plugins ?? [])],
+            persist: options.persistSessionPluginOverrides,
+            resolve: options.resolveSessionPluginOverrides,
+        } : undefined,
     };
 }
+function normalizeWebRuntimePlugins(value) {
+    if (!Array.isArray(value))
+        return [];
+    const plugins = value.map((plugin) => ({
+        ...plugin,
+        id: plugin.id.trim(),
+        name: plugin.name.trim() || plugin.id.trim(),
+        version: plugin.version.trim() || "0.0.0",
+        tools: [...plugin.tools],
+        promptSections: [...(plugin.promptSections ?? [])],
+    })).filter((plugin) => plugin.id);
+    plugins.sort((left, right) => left.id.localeCompare(right.id));
+    if (new Set(plugins.map((plugin) => plugin.id)).size !== plugins.length)
+        throw new Error("duplicate web runtime plugin id");
+    return plugins;
+}
+function normalizePluginOverrides(value, catalog) {
+    const available = new Set(catalog.map((plugin) => plugin.id));
+    return Object.fromEntries(Object.entries(value ?? {}).filter(([id, enabled]) => available.has(id) && typeof enabled === "boolean"));
+}
+function activeWebRuntimePlugins(catalog, overrides) {
+    return catalog.filter((plugin) => plugin.globallyEnabled && overrides[plugin.id] !== false);
+}
 function createTaskNotificationSource(taskStore) {
     return {
         collectUnnotifiedCompletions() {
@@ -200,7 +255,7 @@ function syncImageGenerationTool(runtime, provider) {
         runtime.tools.register(createOpenAIImageGenerationTool());
 }
 function formatCreatedEnvNotice(dotEnvPath) {
-    return `Created default config file: ${dotEnvPath}\nSet MODEL_PROVIDER and the matching provider section (OPENAI_API_KEY or ANTHROPIC_API_KEY), then restart neo.`;
+    return `Created default config file: ${dotEnvPath}\nSet OPENAI_API_KEY, then restart neo.`;
 }
 function parseResumeFlag(value) {
     if (!value)
@@ -268,6 +323,9 @@ export class WebRepl {
     foregroundRun;
     foregroundRunToken = 0;
     pendingUserImageEchoLabels;
+    pendingUserImageEchoMessageId;
+    runtimeContextRevision = 0;
+    runtimeContextPublishQueue = Promise.resolve();
     backgroundSessionRuns = new Map();
     suppressReattachedStreaming = new Set();
     backgroundTaskCount;
@@ -275,15 +333,19 @@ export class WebRepl {
         this.runtime = runtime;
         this.lines = initialLines(runtime, { current: 0 });
         this.status = initialStatus(runtime);
-        this.backgroundTaskCount = runtime.taskStore.activeCount();
+        this.backgroundTaskCount = runtime.taskStore.activeCount() + runtime.execProcessManager.activeCount();
         runtime.taskStore.subscribe(() => {
-            this.backgroundTaskCount = runtime.taskStore.activeCount();
+            this.backgroundTaskCount = runtime.taskStore.activeCount() + runtime.execProcessManager.activeCount();
+            this.broadcastSync();
+        });
+        runtime.execProcessManager.subscribe(() => {
+            this.backgroundTaskCount = runtime.taskStore.activeCount() + runtime.execProcessManager.activeCount();
             this.broadcastSync();
         });
         runtime.engine.onSessionTitleChange(() => this.broadcastSync());
     }
     subscribe(res) {
-        const subscriber = { response: res, blocked: false, needsSync: false };
+        const subscriber = { response: res, blocked: false, needsSync: false, needsRuntimeContext: false };
         this.subscribers.add(subscriber);
         res.writeHead(200, {
             "Content-Type": "text/event-stream; charset=utf-8",
@@ -292,6 +354,7 @@ export class WebRepl {
             "X-Accel-Buffering": "no",
         });
         this.send(subscriber, "sync", this.snapshot(true));
+        this.publishRuntimeContext([subscriber]);
         reqKeepAlive(res);
         res.on("close", () => this.subscribers.delete(subscriber));
     }
@@ -312,6 +375,89 @@ export class WebRepl {
             interactive: includeCatalog ? webInteractiveCatalog(this.runtime) : undefined,
         };
     }
+    async runtimeContext() {
+        return this.buildRuntimeContext(this.runtimeContextRevision);
+    }
+    sessionPlugins() {
+        const support = this.runtime.pluginSupport;
+        const sessionId = this.runtime.engine.snapshot().session?.sessionId;
+        if (!support)
+            return { sessionId, busy: this.busy, items: [] };
+        return {
+            sessionId,
+            busy: this.busy,
+            items: support.catalog.map((plugin) => {
+                const override = support.overrides[plugin.id];
+                return {
+                    id: plugin.id,
+                    name: plugin.name,
+                    version: plugin.version,
+                    globallyEnabled: plugin.globallyEnabled,
+                    mode: override === undefined ? "inherit" : override ? "enabled" : "disabled",
+                    effectiveEnabled: plugin.globallyEnabled && override !== false,
+                    tools: plugin.tools.map((tool) => tool.name),
+                    promptSections: plugin.promptSections?.length ?? 0,
+                };
+            }),
+        };
+    }
+    async setSessionPlugins(value) {
+        if (this.busy)
+            return actionFailure("PLUGIN_UPDATE_BLOCKED", "cannot change session plugins while a response is running");
+        if (!isRecord(value))
+            return actionFailure("INVALID_REQUEST", "plugin overrides must be an object");
+        const support = this.runtime.pluginSupport;
+        if (!support)
+            return actionFailure("PLUGIN_NOT_CONFIGURED", "web plugins are not configured");
+        const available = new Set(support.catalog.map((plugin) => plugin.id));
+        const overrides = {};
+        for (const [id, mode] of Object.entries(value)) {
+            if (!available.has(id))
+                return actionFailure("PLUGIN_INVALID", `unknown web plugin: ${id}`);
+            if (mode === "enabled" || mode === true)
+                overrides[id] = true;
+            else if (mode === "disabled" || mode === false)
+                overrides[id] = false;
+            else if (mode !== "inherit" && mode !== null && mode !== undefined)
+                return actionFailure("PLUGIN_INVALID", `invalid plugin mode: ${id}`);
+        }
+        try {
+            await this.applySessionPluginOverrides(overrides, true);
+            return { ok: true, state: this.sessionPlugins() };
+        }
+        catch (error) {
+            return actionFailure("PLUGIN_UPDATE_FAILED", error instanceof Error ? error.message : String(error));
+        }
+    }
+    async loadSessionPlugins(sessionId) {
+        const support = this.runtime.pluginSupport;
+        if (!support?.resolve || !sessionId)
+            return;
+        await this.applySessionPluginOverrides(await support.resolve(sessionId), false);
+    }
+    async applySessionPluginOverrides(overrides, persist) {
+        const support = this.runtime.pluginSupport;
+        if (!support)
+            return;
+        const normalized = normalizePluginOverrides(overrides, support.catalog);
+        for (const plugin of support.catalog)
+            for (const tool of plugin.tools)
+                this.runtime.tools.unregister(tool.name);
+        const activePlugins = activeWebRuntimePlugins(support.catalog, normalized);
+        for (const plugin of activePlugins)
+            for (const tool of plugin.tools)
+                this.runtime.tools.register(tool);
+        support.overrides = normalized;
+        this.runtime.engine.setRuntimePlugins([...support.basePluginIds, ...activePlugins.map((plugin) => plugin.id)], [...support.basePromptSections, ...activePlugins.flatMap((plugin) => plugin.promptSections ?? [])]);
+        const sessionId = this.runtime.engine.snapshot().session?.sessionId;
+        if (persist && sessionId && support.persist)
+            await support.persist(sessionId, normalized);
+        const metrics = await this.runtime.engine.contextMetrics();
+        this.runtime.initialMetrics = metrics;
+        this.setStatus({ ...this.status, metrics, activityTick: this.status.activityTick + 1 });
+        this.broadcastSync();
+        this.publishRuntimeContext();
+    }
     async submit(text, attachments = []) {
         const trimmed = text.trim();
         if (!trimmed && attachments.length === 0)
@@ -324,14 +470,36 @@ export class WebRepl {
             await this.detachRunningForeground("session browser");
         }
         else if (this.busy) {
-            this.queuedInput = text;
-            this.queuedAttachments = attachments;
+            this.enqueueInput(text, attachments);
             this.broadcastSync();
             return { ok: true };
         }
         this.startRun(text, attachments);
         return { ok: true };
     }
+    submitImmediately(text, attachments = []) {
+        if (!this.busy) {
+            this.startRun(text, attachments);
+            return { ok: true, interrupted: false };
+        }
+        this.enqueueInput(text, attachments);
+        return this.sendQueuedNow();
+    }
+    sendQueuedNow() {
+        const queuedText = this.queuedInput;
+        const queuedAttachments = this.queuedAttachments ?? [];
+        if (queuedText === undefined)
+            return { ok: true, interrupted: false };
+        this.queuedInput = undefined;
+        this.queuedAttachments = undefined;
+        const interrupted = this.stopForegroundRun("Interrupted to send queued web input");
+        this.startRun(queuedText, queuedAttachments);
+        return { ok: true, interrupted };
+    }
+    enqueueInput(text, attachments) {
+        this.queuedInput = mergeWebQueuedInput(this.queuedInput, text);
+        this.queuedAttachments = [...(this.queuedAttachments ?? []), ...attachments].slice(0, 20);
+    }
     startRun(text, attachments = []) {
         const run = this.handleCommandOrPrompt(text, attachments).catch((error) => {
             this.append({ kind: "error", text: error instanceof Error ? error.message : String(error) });
@@ -351,7 +519,7 @@ export class WebRepl {
     }
     async resumeSession(sessionId) {
         if (!sessionId)
-            return { ok: false, error: "sessionId is required" };
+            return actionFailure("INVALID_REQUEST", "sessionId is required");
         try {
             const running = this.backgroundSessionRuns.get(sessionId);
             if (running) {
@@ -364,13 +532,13 @@ export class WebRepl {
             const snapshot = this.runtime.engine.snapshot().session;
             if (!snapshot)
                 throw new Error("session transcripts are disabled");
-            await this.refreshSessionView(systemLine(formatResume(snapshot)));
+            await this.loadSessionPlugins(snapshot.sessionId);
+            await this.refreshSessionView();
             return { ok: true };
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            this.append({ kind: "error", text: message });
-            return { ok: false, error: message };
+            return actionFailure("SESSION_RESUME_FAILED", message);
         }
     }
     async newSession() {
@@ -381,16 +549,16 @@ export class WebRepl {
             const snapshot = this.runtime.engine.snapshot().session;
             if (!snapshot)
                 throw new Error("session transcripts are disabled");
-            await this.refreshSessionView(systemLine(`new session ${snapshot.sessionId}`));
+            await this.loadSessionPlugins(snapshot.sessionId);
+            await this.refreshSessionView();
             return { ok: true };
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            this.append({ kind: "error", text: message });
-            return { ok: false, error: message };
+            return actionFailure("SESSION_CREATE_FAILED", message);
         }
     }
-    async refreshSessionView(line) {
+    async refreshSessionView() {
         const metrics = await this.runtime.engine.contextMetrics();
         this.runtime.usage.reset();
         this.status = initialStatus(this.runtime, metrics);
@@ -401,24 +569,27 @@ export class WebRepl {
         this.thinkingLineId = undefined;
         this.finalizedThinkingLineId = undefined;
         this.liveToolLineIds.clear();
-        if (line)
-            this.append(line);
         this.broadcastSync();
+        this.publishRuntimeContext();
     }
     async deleteSession(sessionId) {
         if (!sessionId)
-            return { ok: false, error: "sessionId is required" };
+            return actionFailure("INVALID_REQUEST", "sessionId is required");
+        if (this.runtime.engine.snapshot().session?.sessionId === sessionId) {
+            return actionFailure("SESSION_ACTIVE", "cannot delete the active session");
+        }
+        if (this.backgroundSessionRuns.has(sessionId)) {
+            return actionFailure("SESSION_RUNNING", "cannot delete a running session");
+        }
         try {
             const deleted = await this.runtime.engine.deleteSession(sessionId);
             if (!deleted)
-                return { ok: false, error: `session not found: ${sessionId}` };
-            this.append(systemLine(`deleted session ${sessionId}`));
+                return actionFailure("SESSION_NOT_FOUND", `session not found: ${sessionId}`);
             return { ok: true };
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            this.append({ kind: "error", text: message });
-            return { ok: false, error: message };
+            return actionFailure("SESSION_DELETE_FAILED", message);
         }
     }
     appPrompt() {
@@ -446,13 +617,34 @@ export class WebRepl {
                 });
             }
             this.broadcastSync();
+            this.publishRuntimeContext();
             return { ok: true, appPrompt };
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            return { ok: false, error: message };
+            return actionFailure("PROMPT_UPDATE_FAILED", message);
         }
     }
+    imagePayload(messageId, blockIndex) {
+        if (!messageId || !Number.isInteger(blockIndex) || blockIndex < 0)
+            return undefined;
+        const message = this.runtime.engine.getHistoryMessages().find((item) => item.id === messageId);
+        const block = message?.blocks[blockIndex];
+        if (!block || block.type !== "image")
+            return undefined;
+        const resolved = resolveImageBlockDataSync(block)?.trim();
+        if (!resolved)
+            return undefined;
+        const dataUrl = /^data:([^;,]+);base64,([\s\S]*)$/iu.exec(resolved);
+        const mimeType = (dataUrl?.[1] ?? block.mimeType).toLowerCase();
+        if (!mimeType.startsWith("image/"))
+            return undefined;
+        const base64 = (dataUrl?.[2] ?? resolved).replace(/\s+/gu, "");
+        if (!base64 || !/^[A-Za-z0-9+/]*={0,2}$/u.test(base64))
+            return undefined;
+        const body = Buffer.from(base64, "base64");
+        return body.length ? { body, mimeType } : undefined;
+    }
     async setFastMode(enabled) {
         try {
             const fastMode = await this.runtime.engine.setFastMode(enabled);
@@ -460,7 +652,7 @@ export class WebRepl {
             return { ok: true, fastMode };
         }
         catch (error) {
-            return { ok: false, error: error instanceof Error ? error.message : String(error) };
+            return actionFailure("FAST_MODE_UPDATE_FAILED", error instanceof Error ? error.message : String(error));
         }
     }
     loginForm(providerValue) {
@@ -470,11 +662,11 @@ export class WebRepl {
     async saveLogin(providerValue, values) {
         const provider = parseLoginProvider(providerValue);
         if (!provider)
-            return { ok: false, error: "provider must be openai or anthropic" };
+            return actionFailure("LOGIN_INVALID", "provider must be openai");
         const payload = { ...createLoginFormPayload(this.runtime.envPath, provider), provider, values };
         const validationError = validateLoginFormPayload(payload);
         if (validationError)
-            return { ok: false, error: validationError };
+            return actionFailure("LOGIN_INVALID", validationError);
         try {
             await saveLoginPayloadToEnv(payload);
             applyLoginPayloadToProcessEnv(payload);
@@ -484,18 +676,17 @@ export class WebRepl {
             const innerGateway = createModelGatewayFromConfig(config);
             this.runtime.modelGateway.setInner(innerGateway);
             this.runtime.agentRuntime.modelGateway = this.runtime.modelGateway;
-            this.runtime.engine.setModelProvider({ modelGateway: this.runtime.modelGateway, model: config.model, fallbackModel: config.fallbackModel, reasoning: config.defaultReasoning });
+            this.runtime.engine.setModelProvider({ modelGateway: this.runtime.modelGateway, model: config.model, reasoning: config.defaultReasoning });
             syncImageGenerationTool(this.runtime, config.provider);
             this.runtime.defaultReasoning = config.defaultReasoning;
             const metrics = await this.runtime.engine.contextMetrics();
             this.setStatus({ ...this.status, metrics, activityTick: this.status.activityTick + 1 });
-            this.append(systemLine(`Saved ${provider} login to ${this.runtime.envPath}\n${formatModelSettings(this.runtime.engine.getModelSettings(), this.runtime.defaultReasoning)}`, EXPANDED_SUMMARY_MAX_LINES));
+            this.publishRuntimeContext();
             return { ok: true };
         }
         catch (error) {
             const message = `Login save failed: ${error instanceof Error ? error.message : String(error)}`;
-            this.append({ kind: "error", text: message });
-            return { ok: false, error: message };
+            return actionFailure("LOGIN_SAVE_FAILED", message);
         }
     }
     interrupt() {
@@ -558,6 +749,8 @@ export class WebRepl {
         this.interruptArmed = false;
         this.queuedInput = undefined;
         this.queuedAttachments = undefined;
+        this.pendingUserImageEchoLabels = undefined;
+        this.pendingUserImageEchoMessageId = undefined;
         this.finalizeForegroundView();
         this.finalizeLiveToolLines();
         this.busy = false;
@@ -604,9 +797,10 @@ export class WebRepl {
         this.interruptArmed = false;
         this.queuedInput = undefined;
         this.queuedAttachments = undefined;
+        this.pendingUserImageEchoLabels = undefined;
+        this.pendingUserImageEchoMessageId = undefined;
         this.busy = false;
         this.status = { ...this.status, phase: "ready", detail: undefined };
-        this.append(systemLine(`Detached running ${sessionId} to background for ${reason}.`));
         return true;
     }
     async reattachRunningSession(run) {
@@ -617,7 +811,7 @@ export class WebRepl {
         this.interruptArmed = false;
         this.foregroundRun = run.promise;
         this.suppressReattachedStreaming.add(run.engine);
-        await this.refreshSessionView(systemLine(`reattached running session ${run.sessionId}`));
+        await this.refreshSessionView();
         this.setBusy(true);
         this.setStatus({ ...this.status, phase: "running", detail: "working" });
     }
@@ -648,7 +842,10 @@ export class WebRepl {
     handleEvent(event) {
         this.reduce(event);
         if (event.type === "message" && this.matchesPendingUserImageEcho(event.message)) {
+            const messageId = this.pendingUserImageEchoMessageId;
             this.pendingUserImageEchoLabels = undefined;
+            this.pendingUserImageEchoMessageId = undefined;
+            renderMessageImages(event.message, (line) => this.append(line), messageId);
             this.broadcastSync();
             return;
         }
@@ -777,6 +974,7 @@ export class WebRepl {
             this.runtime.usage.reset();
             this.status = await resetStatus(this.runtime);
             this.append(systemLine("transcript reset"));
+            this.publishRuntimeContext();
             return;
         }
         if (command.type === "state") {
@@ -831,6 +1029,7 @@ export class WebRepl {
                 this.append(await handleModelCommand(command, this.runtime));
                 const metrics = await this.runtime.engine.contextMetrics();
                 this.setStatus({ ...this.status, phase: "ready", detail: undefined, metrics, activityTick: this.status.activityTick + 1 });
+                this.publishRuntimeContext();
             }
             finally {
                 this.setBusy(false);
@@ -858,13 +1057,13 @@ export class WebRepl {
             return;
         }
         const promptPayload = buildWebPromptPayload(command.text, attachments);
-        this.append({ kind: "user", text: promptPayload.displayText });
-        for (const line of imageLinesForBlocks("user", promptPayload.blocks))
-            this.append(line);
+        const optimisticMessageId = `web-user-${this.lineId + 1}`;
+        this.append({ kind: "user", text: promptPayload.displayText, messageId: optimisticMessageId });
         const optimisticImageLabels = (promptPayload.blocks ?? [])
             .filter((block) => block.type === "image" && typeof block.label === "string")
             .map((block) => block.label);
         this.pendingUserImageEchoLabels = optimisticImageLabels.length ? optimisticImageLabels : undefined;
+        this.pendingUserImageEchoMessageId = optimisticImageLabels.length ? optimisticMessageId : undefined;
         const runToken = ++this.foregroundRunToken;
         const abortController = new AbortController();
         this.activeAbortController = abortController;
@@ -905,6 +1104,7 @@ export class WebRepl {
             this.interruptArmed = false;
             this.finalizeForegroundView();
             this.pendingUserImageEchoLabels = undefined;
+            this.pendingUserImageEchoMessageId = undefined;
             const queuedText = this.queuedInput;
             const queuedAttach = this.queuedAttachments;
             this.queuedInput = undefined;
@@ -955,7 +1155,10 @@ export class WebRepl {
     }
     send(subscriber, event, data) {
         if (subscriber.blocked) {
-            subscriber.needsSync = true;
+            if (event === "runtime.context")
+                subscriber.needsRuntimeContext = true;
+            else
+                subscriber.needsSync = true;
             return;
         }
         const eventId = ++this.eventSequence;
@@ -965,10 +1168,41 @@ export class WebRepl {
         subscriber.blocked = true;
         subscriber.response.once("drain", () => {
             subscriber.blocked = false;
-            if (!subscriber.needsSync || subscriber.response.destroyed)
+            if (subscriber.response.destroyed)
                 return;
-            subscriber.needsSync = false;
-            this.send(subscriber, "sync", this.snapshot(false));
+            if (subscriber.needsSync) {
+                subscriber.needsSync = false;
+                this.send(subscriber, "sync", this.snapshot(false));
+            }
+            if (subscriber.needsRuntimeContext) {
+                subscriber.needsRuntimeContext = false;
+                this.publishRuntimeContext([subscriber]);
+            }
+        });
+    }
+    async buildRuntimeContext(revision) {
+        const snapshot = await this.runtime.engine.promptExportSnapshot();
+        return createWebRuntimeContextPayload(snapshot, {
+            revision,
+            sessionId: this.runtime.engine.snapshot().session?.sessionId,
+        });
+    }
+    publishRuntimeContext(targets) {
+        this.runtimeContextPublishQueue = this.runtimeContextPublishQueue.then(async () => {
+            const revision = ++this.runtimeContextRevision;
+            const payload = await this.buildRuntimeContext(revision);
+            const subscribers = targets ?? [...this.subscribers];
+            for (const subscriber of subscribers) {
+                if (!subscriber.response.destroyed && this.subscribers.has(subscriber))
+                    this.send(subscriber, "runtime.context", payload);
+            }
+        }).catch((error) => {
+            const payload = { protocolVersion: 1, message: error instanceof Error ? error.message : String(error) };
+            const subscribers = targets ?? [...this.subscribers];
+            for (const subscriber of subscribers) {
+                if (!subscriber.response.destroyed && this.subscribers.has(subscriber))
+                    this.send(subscriber, "runtime.context.error", payload);
+            }
         });
     }
     broadcastDelta(operation) {
@@ -1056,6 +1290,19 @@ async function route(req, res, router) {
             return repl.subscribe(res);
         if (req.method === "GET" && url.pathname === "/api/state")
             return sendJson(res, repl.snapshot(true));
+        if (req.method === "GET" && url.pathname === "/api/runtime-context")
+            return sendJson(res, await repl.runtimeContext());
+        if (req.method === "GET" && url.pathname === "/api/session-plugins")
+            return sendJson(res, repl.sessionPlugins());
+        if (req.method === "POST" && url.pathname === "/api/session-plugins") {
+            const body = await readJsonBody(req);
+            return sendJson(res, await repl.setSessionPlugins(body.overrides));
+        }
+        const imageMatch = /^\/api\/images\/([^/]+)\/(\d+)$/u.exec(url.pathname);
+        if (req.method === "GET" && imageMatch) {
+            const payload = repl.imagePayload(decodeURIComponent(imageMatch[1]), Number(imageMatch[2]));
+            return payload ? sendImage(res, payload) : sendJson(res, { error: "image not found" }, 404);
+        }
         if (req.method === "GET" && url.pathname === "/api/app-prompt")
             return sendJson(res, repl.appPrompt());
         if (req.method === "POST" && url.pathname === "/api/app-prompt") {
@@ -1070,10 +1317,16 @@ async function route(req, res, router) {
             const body = await readJsonBody(req);
             return sendJson(res, await repl.submit(String(body.text ?? ""), sanitizeWebAttachments(body.attachments)));
         }
+        if (req.method === "POST" && url.pathname === "/api/submit-now") {
+            const body = await readJsonBody(req);
+            return sendJson(res, repl.submitImmediately(String(body.text ?? ""), sanitizeWebAttachments(body.attachments)));
+        }
         if (req.method === "POST" && url.pathname === "/api/interrupt")
             return sendJson(res, repl.interrupt());
         if (req.method === "POST" && url.pathname === "/api/queue/cancel")
             return sendJson(res, repl.cancelQueue());
+        if (req.method === "POST" && url.pathname === "/api/queue/send-now")
+            return sendJson(res, repl.sendQueuedNow());
         if (req.method === "GET" && url.pathname === "/api/sessions")
             return sendJson(res, await repl.listSessions());
         if (req.method === "POST" && url.pathname === "/api/sessions/resume") {
@@ -1095,7 +1348,7 @@ async function route(req, res, router) {
         sendJson(res, { error: "not found" }, 404);
     }
     catch (error) {
-        sendJson(res, { error: error instanceof Error ? error.message : String(error) }, 500);
+        sendJson(res, { errorCode: "WEB_REQUEST_FAILED", error: error instanceof Error ? error.message : String(error) }, 500);
     }
 }
 function webRuntimeScopeFromUrl(url) {
@@ -1121,6 +1374,14 @@ function sendJson(res, value, status = 200) {
     res.writeHead(status, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" });
     res.end(JSON.stringify(value));
 }
+function sendImage(res, payload) {
+    res.writeHead(200, {
+        "Content-Type": payload.mimeType,
+        "Content-Length": String(payload.body.length),
+        "Cache-Control": "private, max-age=31536000, immutable",
+    });
+    res.end(payload.body);
+}
 async function readJsonBody(req) {
     const chunks = [];
     for await (const chunk of req)
@@ -1132,10 +1393,22 @@ async function readJsonBody(req) {
 function sanitizeWebAttachments(value) {
     if (!Array.isArray(value))
         return [];
-    return value.filter((item) => {
+    return value.slice(0, 20).flatMap((item) => {
         if (!isRecord(item))
-            return false;
-        return item.kind === "image" && typeof item.label === "string" && /^\[img#\d+\]$/.test(item.label) && typeof item.mimeType === "string" && item.mimeType.startsWith("image/") && typeof item.data === "string";
+            return [];
+        if (item.kind === "image" && typeof item.label === "string" && /^\[img#\d+\]$/.test(item.label) && typeof item.mimeType === "string" && item.mimeType.startsWith("image/") && typeof item.data === "string") {
+            return [{ kind: "image", label: item.label, mimeType: item.mimeType, data: item.data }];
+        }
+        if (item.kind === "file" && typeof item.name === "string" && typeof item.mimeType === "string" && typeof item.size === "number" && Number.isFinite(item.size) && typeof item.absolutePath === "string" && path.isAbsolute(item.absolutePath)) {
+            return [{
+                    kind: "file",
+                    name: path.basename(item.name).slice(0, 180),
+                    mimeType: item.mimeType.slice(0, 160),
+                    size: Math.max(0, Math.round(item.size)),
+                    absolutePath: path.resolve(item.absolutePath),
+                }];
+        }
+        return [];
     });
 }
 function webCatalog(runtime) {
@@ -1169,7 +1442,7 @@ function restoredHistoryLines(runtime) {
         return lines.length;
     };
     for (const message of runtime.engine.getHistoryMessages())
-        renderMessage(message, append, undefined, { includeToolUseBlocks: true, includeThinkingBlocks: false });
+        renderMessage(message, append, undefined, { includeToolUseBlocks: true, includeThinkingBlocks: true });
     return lines;
 }
 function initialStatus(runtime, metrics = runtime.initialMetrics) {
@@ -1179,9 +1452,12 @@ async function resetStatus(runtime) {
     return initialStatus(runtime, await runtime.engine.contextMetrics());
 }
 function buildWebPromptPayload(displayText, attachments) {
-    const activeAttachments = attachments.filter((attachment) => displayText.includes(attachment.label));
-    if (activeAttachments.length === 0)
-        return { text: displayText, displayText };
+    const activeAttachments = attachments.filter((attachment) => attachment.kind === "image" && displayText.includes(attachment.label));
+    const fileManifest = buildWebFileAttachmentManifest(attachments.filter((attachment) => attachment.kind === "file"));
+    if (activeAttachments.length === 0) {
+        const text = [displayText.trim(), fileManifest].filter(Boolean).join("\n\n");
+        return { text, displayText };
+    }
     const blocks = [];
     let cursor = 0;
     while (cursor < displayText.length) {
@@ -1194,8 +1470,27 @@ function buildWebPromptPayload(displayText, attachments) {
         blocks.push({ type: "image", mimeType: next.attachment.mimeType, data: next.attachment.data, label: next.attachment.label });
         cursor = next.index + next.attachment.label.length;
     }
+    pushTextBlock(blocks, fileManifest ? `\n\n${fileManifest}` : "");
     const text = blocks.map((block) => block.type === "text" ? block.text : block.type === "image" ? block.label ?? "[image]" : "").join("");
-    return { text, displayText: text, blocks };
+    return { text, displayText, blocks };
+}
+function buildWebFileAttachmentManifest(attachments) {
+    if (attachments.length === 0)
+        return "";
+    return [
+        "<<ATTACHMENT_MANIFEST>>",
+        "Files attached by the user for this turn:",
+        ...attachments.map((attachment, index) => [
+            `- file${index + 1}: ${attachment.name || `attachment-${index + 1}`}`,
+            `  path: ${attachment.absolutePath}`,
+            `  mimeType: ${attachment.mimeType || "application/octet-stream"}`,
+            `  size: ${attachment.size} bytes`,
+        ].join("\n")),
+        "<</ATTACHMENT_MANIFEST>>",
+    ].join("\n");
+}
+export function mergeWebQueuedInput(current, next) {
+    return [current?.trimEnd(), next.trim()].filter(Boolean).join("\n");
 }
 function nextWebAttachmentOccurrence(text, attachments, start) {
     let best;
@@ -1288,7 +1583,7 @@ async function handleModelCommand(command, runtime) {
                     const innerGateway = createModelGatewayFromConfig(config);
                     runtime.modelGateway.setInner(innerGateway);
                     runtime.agentRuntime.modelGateway = runtime.modelGateway;
-                    runtime.engine.setModelProvider({ modelGateway: runtime.modelGateway, model: config.model, fallbackModel: config.fallbackModel, reasoning: config.defaultReasoning });
+                    runtime.engine.setModelProvider({ modelGateway: runtime.modelGateway, model: config.model, reasoning: config.defaultReasoning });
                     syncImageGenerationTool(runtime, config.provider);
                     runtime.defaultReasoning = config.defaultReasoning;
                 }
@@ -1340,18 +1635,18 @@ async function persistModelCommandSettings(runtime, command, reasoningUpdate) {
     return { providerChanged: targetProvider !== currentProvider };
 }
 function currentModelProvider() {
-    return parseLoginProvider(process.env.MODEL_PROVIDER) ?? (process.env.ANTHROPIC_API_KEY ? "anthropic" : "openai");
+    return "openai";
 }
 function parseLoginProvider(value) {
-    if (value === "openai" || value === "anthropic")
+    if (value === "openai")
         return value;
     return undefined;
 }
-const LOGIN_PROVIDERS = ["openai", "anthropic"];
+const LOGIN_PROVIDERS = ["openai"];
 const SHARED_LOGIN_FIELDS = [
     { key: "reasoningEffort", label: "Reasoning effort", envKey: "MODEL_REASONING_EFFORT", scope: "shared", options: ["", "off", "none", "minimal", "low", "medium", "high", "xhigh", "max"] },
     { key: "reasoningSummary", label: "Reasoning summary", envKey: "MODEL_REASONING_SUMMARY", scope: "shared", options: ["", "auto", "concise", "detailed"] },
-    { key: "maxOutputTokens", label: "Max output tokens", envKey: "MODEL_MAX_OUTPUT_TOKENS", scope: "shared", placeholder: "800" },
+    { key: "maxOutputTokens", label: "Max output tokens", envKey: "MODEL_MAX_OUTPUT_TOKENS", scope: "shared" },
     { key: "timeoutMs", label: "Timeout ms", envKey: "MODEL_TIMEOUT_MS", scope: "shared", placeholder: "120000" },
     { key: "streamIdleTimeoutMs", label: "Stream idle timeout ms", envKey: "MODEL_STREAM_IDLE_TIMEOUT_MS", scope: "shared", placeholder: "120000" },
     { key: "maxRetries", label: "Max retries", envKey: "MODEL_MAX_RETRIES", scope: "shared", placeholder: "2" },
@@ -1361,23 +1656,13 @@ const LOGIN_FIELD_DEFINITIONS = {
         { key: "apiKey", label: "API key", envKey: "OPENAI_API_KEY", scope: "provider", required: true, secret: true, placeholder: "sk-..." },
         { key: "baseUrl", label: "Base URL", envKey: "OPENAI_BASE_URL", scope: "provider", placeholder: "https://api.openai.com" },
         { key: "model", label: "Model", envKey: "OPENAI_MODEL", scope: "provider", required: true, placeholder: "gpt-5.6" },
-        { key: "fallbackModel", label: "Fallback model", envKey: "OPENAI_FALLBACK_MODEL", scope: "provider" },
         { key: "endpoint", label: "Endpoint", envKey: "OPENAI_ENDPOINT", scope: "provider", placeholder: "auto", options: ["auto", "responses", "chat"] },
         ...SHARED_LOGIN_FIELDS,
     ],
-    anthropic: [
-        { key: "apiKey", label: "API key", envKey: "ANTHROPIC_API_KEY", scope: "provider", required: true, secret: true, placeholder: "sk-ant-..." },
-        { key: "baseUrl", label: "Base URL", envKey: "ANTHROPIC_BASE_URL", scope: "provider", placeholder: "https://api.anthropic.com" },
-        { key: "model", label: "Model", envKey: "ANTHROPIC_MODEL", scope: "provider", required: true, placeholder: "claude-sonnet-4-6" },
-        { key: "fallbackModel", label: "Fallback model", envKey: "ANTHROPIC_FALLBACK_MODEL", scope: "provider" },
-        { key: "version", label: "Anthropic version", envKey: "ANTHROPIC_VERSION", scope: "provider", placeholder: "2023-06-01" },
-        ...SHARED_LOGIN_FIELDS,
-    ],
 };
 const DEPRECATED_MODEL_ENV_KEYS = [
     "MODEL_API_KEY", "MODEL_BASE_URL", "MODEL_ID", "MODEL_FALLBACK_ID", "MODEL_ENDPOINT", "OPENAI_PROVIDER",
     "OPENAI_REASONING_EFFORT", "OPENAI_REASONING_SUMMARY", "OPENAI_MAX_OUTPUT_TOKENS", "OPENAI_TIMEOUT_MS", "OPENAI_STREAM_IDLE_TIMEOUT_MS", "OPENAI_MAX_RETRIES",
-    "ANTHROPIC_REASONING_EFFORT", "ANTHROPIC_REASONING_SUMMARY", "ANTHROPIC_MAX_OUTPUT_TOKENS", "ANTHROPIC_TIMEOUT_MS", "ANTHROPIC_STREAM_IDLE_TIMEOUT_MS", "ANTHROPIC_MAX_RETRIES",
 ];
 function createLoginFormPayload(envPath, provider) {
     const env = parseEnvFileSafe(envPath);
@@ -1402,19 +1687,13 @@ function loginValuesForProvider(provider, env) {
         values.endpoint = "auto";
     return values;
 }
-function guessLoginProvider(env) {
-    if (env.ANTHROPIC_API_KEY ?? process.env.ANTHROPIC_API_KEY)
-        return "anthropic";
+function guessLoginProvider(_env) {
     return currentModelProvider();
 }
-function defaultBaseUrlForLoginProvider(provider) {
-    if (provider === "anthropic")
-        return "https://api.anthropic.com";
+function defaultBaseUrlForLoginProvider(_provider) {
     return "https://api.openai.com";
 }
-function defaultModelForLoginProvider(provider) {
-    if (provider === "anthropic")
-        return "claude-sonnet-4-6";
+function defaultModelForLoginProvider(_provider) {
     return "gpt-5.6";
 }
 function validateLoginFormPayload(payload) {
@@ -1430,6 +1709,9 @@ function validateLoginFormPayload(payload) {
         if (value && !Number.isFinite(Number(value)))
             return `${fieldKey} must be a number.`;
     }
+    if (payload.provider === "openai" && payload.values.endpoint === "chat" && payload.values.reasoningSummary?.trim()) {
+        return "Reasoning summary requires the Responses API endpoint.";
+    }
     return undefined;
 }
 async function saveLoginPayloadToEnv(payload) {
@@ -1464,9 +1746,7 @@ function stripEnvQuotes(value) {
         return value.slice(1, -1);
     return value;
 }
-function modelEnvKeyForProvider(provider) {
-    if (provider === "anthropic")
-        return "ANTHROPIC_MODEL";
+function modelEnvKeyForProvider(_provider) {
     return "OPENAI_MODEL";
 }
 function envValueForReasoning(reasoning) {
@@ -1515,9 +1795,6 @@ function formatEnvValue(value) {
         return value;
     return JSON.stringify(value);
 }
-function formatResume(snapshot) {
-    return `resumed session ${snapshot.sessionId}: ${snapshot.resumedMessages} messages from ${snapshot.transcriptPath}`;
-}
 function applyEnvUpdatesToProcess(updates) {
     for (const [key, value] of Object.entries(updates)) {
         if (value === undefined)
@@ -1541,8 +1818,6 @@ function validateModelReasoningArgument(modelId, reasoning) {
 function formatModelSettings(settings, defaultReasoning) {
     const window = resolveContextWindowTokens(settings.model);
     const lines = ["Model settings:", `  Model: ${settings.model ?? "<provider default>"}`];
-    if (settings.fallbackModel)
-        lines.push(`  Fallback: ${settings.fallbackModel}`);
     lines.push(`  Reasoning effort: ${formatReasoningSetting(settings.reasoning)}`);
     if (defaultReasoning?.effort)
         lines.push(`  Env default reasoning: ${defaultReasoning.effort}`);
@@ -1569,36 +1844,36 @@ function renderMessage(message, append, activeAssistantId, options = {}) {
         return true;
     const parentToolName = typeof message.metadata?.tool === "string" ? message.metadata.tool : undefined;
     let rendered = false;
-    for (const block of message.blocks) {
+    for (const [blockIndex, block] of message.blocks.entries()) {
         if (block.type === "text") {
             const kind = kindForRole(message.role);
             if (kind === "meta")
                 continue;
             if (kind === "system")
-                append({ kind, title: titleForRole(message.role), text: block.text, previewStyle: "summary" });
+                append({ kind, title: titleForRole(message.role), text: block.text, messageId: message.id, previewStyle: "summary" });
             else
-                append({ kind, text: block.text });
+                append({ kind, text: block.text, messageId: message.id });
             rendered = true;
         }
         else if (block.type === "image") {
-            const line = imageLineForBlock(message.role, block);
+            const line = imageLineForBlock(message.role, block, message.id, blockIndex);
             if (!line)
                 continue;
-            append({ ...line, parentToolName });
+            append({ ...line, messageId: message.id, parentToolName });
             rendered = true;
         }
         else if (block.type === "thinking") {
             if (options.includeThinkingBlocks === false)
                 continue;
-            append(thinkingLine(block.text));
+            append({ ...thinkingLine(block.text), messageId: message.id });
             rendered = true;
         }
         else if (block.type === "tool_use" && options.includeToolUseBlocks) {
-            append({ ...formatToolUse(block), live: false });
+            append({ ...formatToolUse(block), messageId: message.id, live: false });
             rendered = true;
         }
         else if (block.type === "tool_result") {
-            append(formatToolResultLine(block.name, block.output, block.ok));
+            append({ ...formatToolResultLine(block.name, block.output, block.ok), messageId: message.id });
             rendered = true;
         }
     }
@@ -1609,35 +1884,27 @@ function renderToolResultMessage(message, append) {
     for (const block of message.blocks) {
         if (block.type !== "tool_result")
             continue;
-        append({ ...formatToolResultLine(block.name, block.output, block.ok), toolUseId: block.toolUseId }, block.toolUseId);
+        append({ ...formatToolResultLine(block.name, block.output, block.ok), messageId: message.id, toolUseId: block.toolUseId }, block.toolUseId);
         rendered = true;
     }
     return rendered;
 }
-function renderMessageImages(message, append) {
+function renderMessageImages(message, append, messageId = message.id) {
     let rendered = false;
     const parentToolName = typeof message.metadata?.tool === "string" ? message.metadata.tool : undefined;
     const parentToolUseId = message.blocks.find((block) => block.type === "tool_result")?.toolUseId;
-    for (const block of message.blocks) {
+    for (const [blockIndex, block] of message.blocks.entries()) {
         if (block.type !== "image")
             continue;
-        const line = imageLineForBlock(message.role, block);
+        const line = imageLineForBlock(message.role, block, message.id, blockIndex);
         if (!line)
             continue;
-        append({ ...line, parentToolName, parentToolUseId });
+        append({ ...line, messageId, parentToolName, parentToolUseId });
         rendered = true;
     }
     return rendered;
 }
-function imageLinesForBlocks(role, blocks) {
-    if (!blocks?.length)
-        return [];
-    return blocks
-        .filter((block) => block.type === "image")
-        .map((block) => imageLineForBlock(role, block))
-        .filter((line) => Boolean(line));
-}
-function imageLineForBlock(role, block) {
+function imageLineForBlock(role, block, messageId, blockIndex) {
     const kind = kindForRole(role);
     if (kind === "meta")
         return undefined;
@@ -1645,20 +1912,12 @@ function imageLineForBlock(role, block) {
         kind,
         text: block.label ?? `[image ${block.mimeType}]`,
         image: {
-            src: imageBlockToDataUrl(block),
+            src: `/api/images/${encodeURIComponent(messageId)}/${blockIndex}`,
             label: block.label,
             mimeType: block.mimeType,
         },
     };
 }
-function imageBlockToDataUrl(block) {
-    const data = resolveImageBlockDataSync(block);
-    if (!data)
-        return "";
-    if (data.startsWith("data:"))
-        return data;
-    return `data:${block.mimeType};base64,${data}`;
-}
 function assistantText(message) {
     const text = message.blocks.filter((block) => block.type === "text").map((block) => block.text).join("");
     return text.length > 0 ? text : undefined;
@@ -1711,8 +1970,8 @@ function thinkingLine(text, live = false) {
     return { kind: "thinking", title: titleForKind("thinking"), text, previewStyle: "summary", summaryMaxLines: THINKING_SUMMARY_MAX_LINES, live };
 }
 function formatToolUse(toolUse) {
-    if (toolUse.name === "plan" && isPlanToolPayload(toolUse.input))
-        return { kind: "tool", toolName: toolUse.name, title: toolTitle(toolUse.name, "running"), bodyTitle: planToolBodyTitle(toolUse.input), text: formatPlanToolPayload(toolUse.input), collapsible: true };
+    if (toolUse.name === "plan" && isWebPlanPayload(toolUse.input))
+        return { kind: "tool", toolName: toolUse.name, title: toolTitle(toolUse.name, "running"), bodyTitle: webPlanBodyTitle(toolUse.input), text: serializeWebPlanPayload(toolUse.input), collapsible: true };
     if (toolUse.name === "image2")
         return { kind: "tool", toolName: toolUse.name, toolUseId: toolUse.id, title: toolTitle(toolUse.name, "running"), bodyTitle: "图片模型处理中", text: JSON.stringify(toolUse.input ?? {}, null, 2), format: "plain", previewStyle: "summary", collapsible: true };
     const summary = summarizeToolUse(toolUse.name, toolUse.input);
@@ -1726,7 +1985,8 @@ function toolTitle(toolName, _phase) {
     const labels = {
         agent: "子任务",
         edit: "编辑文件",
-        exec: "执行命令",
+        exec_command: "执行命令",
+        write_stdin: "终端交互",
         expose_downloads: "文件下载",
         grep: "搜索文本",
         image2: "图片生成",
@@ -1767,24 +2027,6 @@ function toolUsePurpose(toolName, input) {
         return `修改 ${path.basename(input.path)}`;
     return undefined;
 }
-function isPlanToolPayload(value) {
-    if (!isRecord(value) || !Array.isArray(value.items))
-        return false;
-    return value.items.every((item) => isRecord(item) && typeof item.description === "string" && (item.status === "pending" || item.status === "in_progress" || item.status === "completed"));
-}
-function planToolBodyTitle(payload) {
-    const title = payload.title?.trim();
-    return title ? title : undefined;
-}
-function formatPlanToolPayload(payload) {
-    const sections = [];
-    if (payload.summary?.trim())
-        sections.push(payload.summary.trim());
-    if (payload.note?.trim())
-        sections.push(payload.note.trim());
-    sections.push(payload.items.map((item) => item.status === "completed" ? `- ~~${item.description.trim()}~~` : item.status === "in_progress" ? `- ▶ ${item.description.trim()}` : `- ${item.description.trim()}`).join("\n"));
-    return sections.filter(Boolean).join("\n");
-}
 function formatToolResult(toolName, output, ok) {
     if ((toolName === "edit" || toolName === "write") && isRecord(output) && isEditToolOutput(output))
         return { text: formatEditToolDiff(output, ok), format: "diff", summaryMaxLines: EDIT_TOOL_SUMMARY_MAX_LINES };
@@ -1802,8 +2044,8 @@ function formatToolResult(toolName, output, ok) {
         return { text: formatImageGenerationToolResult(output, ok), format: "plain", summaryMaxLines: 4 };
     if (toolName === "expose_downloads")
         return { text: formatExposeDownloadsToolResult(output, ok), full: true, bodyTitle: ok ? "请点击下载" : "下载准备失败" };
-    if (toolName === "plan" && isPlanToolPayload(output))
-        return { text: formatPlanToolPayload(output), full: true, bodyTitle: planToolBodyTitle(output) };
+    if (toolName === "plan" && isWebPlanPayload(output))
+        return { text: serializeWebPlanPayload(output), full: true, bodyTitle: webPlanBodyTitle(output) };
     if (typeof output === "string")
         return { text: output, format: hasAnsi(output) ? "ansi" : undefined, summaryMaxLines: EXPANDED_SUMMARY_MAX_LINES };
     return { text: `${ok ? "ok" : "failed"}\n${formatReplData(output, 6000)}`, summaryMaxLines: EXPANDED_SUMMARY_MAX_LINES };
@@ -1879,12 +2121,14 @@ function diffLineMarker(line) {
     return marker === "+" || marker === "-" || marker === " " ? marker : undefined;
 }
 function isExecOutput(value) {
-    return isRecord(value) && typeof value.command === "string" && typeof value.durationMs === "number";
+    return isRecord(value) && typeof value.command === "string" && typeof value.duration_ms === "number";
 }
 function formatExecToolResult(output, ok) {
-    const status = output.timedOut ? "已超时" : ok ? "已完成" : "执行失败";
+    const status = output.status === "running" ? "运行中" : output.timed_out ? "已超时" : ok ? "已完成" : "执行失败";
     const description = typeof output.description === "string" ? output.description.trim() : "";
-    const lines = [description ? `目的：${description}` : "执行命令", `状态：${status}`, `耗时：${output.durationMs}ms`];
+    const lines = [description ? `目的：${description}` : "执行命令", `状态：${status}`, `耗时：${output.duration_ms}ms`];
+    if (output.status === "running" && typeof output.session_id === "string")
+        lines.push(`会话：${output.session_id}`);
     const stdout = typeof output.stdout === "string" ? output.stdout.replace(/\s+$/u, "") : "";
     const stderr = typeof output.stderr === "string" ? output.stderr.replace(/\s+$/u, "") : "";
     if (stdout)