neoctl 0.2.30 → 0.2.32

package/dist/web/index.js

@@ -14,6 +14,7 @@ import { findModelMetadata, loadModelCatalog, reasoningEffortsForModel, resolveC
 import { CommunicationLogger, LoggingModelGateway } from "../model/communication-logger.js";
 import { createModelGatewayFromConfig, createModelGatewayFromProcessEnv } from "../model/provider-factory.js";
 import { ToolRegistry } from "../tools/registry.js";
+import { builtinToolPresentation, toolPresentationForSource } from "../tools/tool-catalog.js";
 import { editTool, writeTool } from "../tools/builtins/edit-tool.js";
 import { createExecTool, createWriteStdinTool } from "../tools/builtins/exec-tool.js";
 import { ExecProcessManager } from "../tools/builtins/exec-process-manager.js";
@@ -24,17 +25,20 @@ import { planTool } from "../tools/builtins/plan-tool.js";
 import { createOpenAIImageGenerationTool } from "../tools/builtins/image-generation-tool.js";
 import { createLoadImageTool } from "../tools/builtins/image-loader-tool.js";
 import { createAgentTool, resumeAgentTask } from "../agents/agent-tool.js";
-import { createTaskTools } from "../tasks/task-tools.js";
+import { createSubagentTools } from "../tasks/subagent-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 { createImageId } from "../types/messages.js";
 import { WEB_HTML } from "./html.js";
 import { openDirectory } from "../open-directory.js";
-import { resolveImageBlockDataSync } from "../core/image-storage.js";
+import { resolveImageBlockDataResultSync, 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 corePackage = require("../../package.json");
+const CORE_VERSION = String(corePackage.version || "unknown");
 const markedPackageDir = path.dirname(require.resolve("marked/package.json"));
 const highlightPackageDir = path.dirname(require.resolve("@highlightjs/cdn-assets/package.json"));
 const markedAssetPath = path.join(markedPackageDir, "lib", "marked.esm.js");
@@ -127,26 +131,42 @@ export async function createWebRuntime(options = {}) {
     const pluginOverrides = normalizePluginOverrides(options.sessionPluginOverrides, pluginCatalog);
     const activePlugins = activeWebRuntimePlugins(pluginCatalog, pluginOverrides);
     const tools = new ToolRegistry();
+    const toolCatalog = [];
+    const catalogedToolNames = new Set();
+    const catalogTool = (tool, item) => {
+        if (catalogedToolNames.has(tool.name))
+            return;
+        catalogedToolNames.add(tool.name);
+        toolCatalog.push({ name: tool.name, presentation: toolPresentationForSource(tool.name, item.source), ...item });
+    };
+    const registerTool = (tool, item) => {
+        tools.register(tool);
+        catalogTool(tool, item);
+    };
     const execProcessManager = new ExecProcessManager();
-    tools.register(editTool);
-    tools.register(writeTool);
-    tools.register(createExecTool({ processManager: execProcessManager }));
-    tools.register(createWriteStdinTool(execProcessManager));
-    tools.register(listDirectoryTool);
-    tools.register(readFileTool);
-    tools.register(grepTool);
-    tools.register(searchTool);
-    tools.register(createLoadImageTool());
+    registerTool(editTool, { source: "builtin" });
+    registerTool(writeTool, { source: "builtin" });
+    registerTool(createExecTool({ processManager: execProcessManager }), { source: "builtin" });
+    registerTool(createWriteStdinTool(execProcessManager), { source: "builtin" });
+    registerTool(listDirectoryTool, { source: "builtin" });
+    registerTool(readFileTool, { source: "builtin" });
+    registerTool(grepTool, { source: "builtin" });
+    registerTool(searchTool, { source: "builtin" });
+    registerTool(createLoadImageTool(), { source: "builtin" });
     if (modelConfig?.provider === "openai")
-        tools.register(createOpenAIImageGenerationTool());
-    tools.register(planTool);
+        registerTool(createOpenAIImageGenerationTool(), { source: "builtin" });
+    registerTool(planTool, { source: "builtin" });
     for (const tool of options.externalTools ?? [])
-        tools.register(tool);
+        registerTool(tool, { source: "external" });
+    for (const plugin of pluginCatalog) {
+        for (const tool of plugin.tools)
+            catalogTool(tool, { source: "plugin", pluginId: plugin.id, pluginName: plugin.name });
+    }
     for (const plugin of activePlugins)
         for (const tool of plugin.tools)
             tools.register(tool);
     const agentRuntime = { modelGateway, tools, taskStore };
-    tools.register(createAgentTool(agentRuntime));
+    registerTool(createAgentTool(agentRuntime), { source: "builtin" });
     const resumeHandler = async (taskId, directive) => {
         const dummyContext = {
             agentId: "main",
@@ -156,8 +176,11 @@ export async function createWebRuntime(options = {}) {
         };
         return resumeAgentTask(taskId, directive, agentRuntime, taskStore, dummyContext);
     };
-    for (const tool of createTaskTools(taskStore, resumeHandler))
-        tools.register(tool);
+    for (const tool of createSubagentTools(taskStore, resumeHandler))
+        registerTool(tool, { source: "builtin" });
+    const globalToolOverrides = normalizeToolOverrides(options.globalToolOverrides, toolCatalog);
+    const sessionToolOverrides = normalizeToolOverrides(options.sessionToolOverrides, toolCatalog);
+    applyToolOverrides(tools, toolCatalog, globalToolOverrides, sessionToolOverrides);
     const appPromptStore = new InMemoryAppPromptStore();
     const engine = new QueryEngine({
         agentId: options.agentId ?? "main",
@@ -176,6 +199,8 @@ export async function createWebRuntime(options = {}) {
         taskNotificationSource: createTaskNotificationSource(taskStore),
         commands: replCommandDefinitions.map((command) => command.usage),
         plugins: [...(options.plugins ?? []), ...activePlugins.map((plugin) => plugin.id)],
+        cwdTransitionPaths: options.cwdTransitionPaths,
+        onCwdTransitionConsumed: options.onCwdTransitionConsumed,
         session: {
             enabled: process.env.AGENT_SESSION_TRANSCRIPT !== "0",
             sessionId: options.sessionId ?? process.env.AGENT_SESSION_ID,
@@ -208,6 +233,14 @@ export async function createWebRuntime(options = {}) {
             persist: options.persistSessionPluginOverrides,
             resolve: options.resolveSessionPluginOverrides,
         } : undefined,
+        toolSupport: {
+            catalog: toolCatalog,
+            globalOverrides: globalToolOverrides,
+            sessionOverrides: sessionToolOverrides,
+            persistGlobal: options.persistGlobalToolOverrides,
+            persistSession: options.persistSessionToolOverrides,
+            resolveSession: options.resolveSessionToolOverrides,
+        },
     };
 }
 function normalizeWebRuntimePlugins(value) {
@@ -233,6 +266,14 @@ function normalizePluginOverrides(value, catalog) {
 function activeWebRuntimePlugins(catalog, overrides) {
     return catalog.filter((plugin) => plugin.globallyEnabled && overrides[plugin.id] !== false);
 }
+function normalizeToolOverrides(value, catalog) {
+    const available = new Set(catalog.map((tool) => tool.name));
+    return Object.fromEntries(Object.entries(value ?? {}).filter(([name, enabled]) => available.has(name) && typeof enabled === "boolean"));
+}
+function applyToolOverrides(registry, catalog, globalOverrides, sessionOverrides) {
+    for (const tool of catalog)
+        registry.setEnabled(tool.name, sessionOverrides[tool.name] ?? globalOverrides[tool.name] ?? true);
+}
 function createTaskNotificationSource(taskStore) {
     return {
         collectUnnotifiedCompletions() {
@@ -250,7 +291,7 @@ function createTaskNotificationSource(taskStore) {
     };
 }
 function syncImageGenerationTool(runtime, provider) {
-    runtime.tools.unregister("image2");
+    runtime.tools.unregister("image_create");
     if (provider === "openai")
         runtime.tools.register(createOpenAIImageGenerationTool());
 }
@@ -266,6 +307,8 @@ export class WebRuntimeRouter {
     repls = new Map();
     createRuntime;
     createRepl;
+    clientRevision = process.env.NEO_CLIENT_REVISION?.trim() || `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+    coreVersion = process.env.NEO_CORE_VERSION?.trim() || CORE_VERSION;
     constructor(options = {}) {
         this.createRuntime = options.createRuntime ?? createWebRuntime;
         this.createRepl = options.createRepl ?? ((runtime) => new WebRepl(runtime));
@@ -286,6 +329,24 @@ export class WebRuntimeRouter {
     activeScopes() {
         return [...this.repls.keys()];
     }
+    clientInfo() {
+        return {
+            protocolVersion: 1,
+            revision: this.clientRevision,
+            coreVersion: this.coreVersion,
+        };
+    }
+    async requestClientReload(options = {}) {
+        const payload = {
+            ...this.clientInfo(),
+            requestId: `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`,
+            clearCache: options.clearCache !== false,
+            reason: options.reason?.trim() || "deployment",
+        };
+        const repls = await Promise.all([...this.repls.values()]);
+        const clients = repls.reduce((total, repl) => total + repl.requestClientReload(payload), 0);
+        return { ...payload, clients };
+    }
 }
 export async function createWebRuntimeRouter(options = {}) {
     const router = new WebRuntimeRouter(options);
@@ -308,6 +369,8 @@ export class WebRepl {
     pendingDeltaOperations = [];
     pendingDeltaStatus = false;
     pendingDeltaTimer;
+    pendingTerminalOutput = new Map();
+    terminalOutputTimer;
     lineId = 0;
     assistantLineId;
     thinkingLineId;
@@ -322,29 +385,29 @@ export class WebRepl {
     queuedAttachments;
     foregroundRun;
     foregroundRunToken = 0;
-    pendingUserImageEchoLabels;
+    pendingUserImageEchoIds;
     pendingUserImageEchoMessageId;
     runtimeContextRevision = 0;
     runtimeContextPublishQueue = Promise.resolve();
     backgroundSessionRuns = new Map();
     suppressReattachedStreaming = new Set();
-    backgroundTaskCount;
     constructor(runtime) {
         this.runtime = runtime;
-        this.lines = initialLines(runtime, { current: 0 });
+        const lineId = { current: 0 };
+        this.lines = initialLines(runtime, lineId);
+        this.lineId = lineId.current;
         this.status = initialStatus(runtime);
-        this.backgroundTaskCount = runtime.taskStore.activeCount() + runtime.execProcessManager.activeCount();
         runtime.taskStore.subscribe(() => {
-            this.backgroundTaskCount = runtime.taskStore.activeCount() + runtime.execProcessManager.activeCount();
             this.broadcastSync();
         });
         runtime.execProcessManager.subscribe(() => {
-            this.backgroundTaskCount = runtime.taskStore.activeCount() + runtime.execProcessManager.activeCount();
+            this.dropInactiveTerminalOutput();
             this.broadcastSync();
         });
+        runtime.execProcessManager.subscribeOutput((delta) => this.queueTerminalOutput(delta));
         runtime.engine.onSessionTitleChange(() => this.broadcastSync());
     }
-    subscribe(res) {
+    subscribe(res, clientInfo) {
         const subscriber = { response: res, blocked: false, needsSync: false, needsRuntimeContext: false };
         this.subscribers.add(subscriber);
         res.writeHead(200, {
@@ -353,19 +416,31 @@ export class WebRepl {
             Connection: "keep-alive",
             "X-Accel-Buffering": "no",
         });
+        if (clientInfo)
+            this.send(subscriber, "client.version", clientInfo);
         this.send(subscriber, "sync", this.snapshot(true));
         this.publishRuntimeContext([subscriber]);
         reqKeepAlive(res);
         res.on("close", () => this.subscribers.delete(subscriber));
     }
+    get backgroundTaskCount() {
+        return this.backgroundTasks().length;
+    }
+    requestClientReload(payload) {
+        const subscribers = [...this.subscribers].filter((subscriber) => !subscriber.response.destroyed);
+        for (const subscriber of subscribers)
+            this.send(subscriber, "client.reload", payload);
+        return subscribers.length;
+    }
     snapshot(includeCatalog = false) {
+        const backgroundTasks = this.backgroundTasks();
         return {
             lines: this.lines,
             status: this.status,
             busy: this.busy,
             queuedInput: this.queuedInput,
-            backgroundTaskCount: this.backgroundTaskCount,
-            backgroundTasks: this.backgroundTasks(),
+            backgroundTaskCount: backgroundTasks.length,
+            backgroundTasks,
             backgroundSessionRunCount: this.backgroundSessionRuns.size,
             runningSessionIds: [...this.backgroundSessionRuns.keys()],
             session: this.runtime.engine.snapshot().session,
@@ -401,6 +476,91 @@ export class WebRepl {
             }),
         };
     }
+    globalTools() {
+        const support = this.runtime.toolSupport;
+        if (!support)
+            return { items: [] };
+        return {
+            items: support.catalog.map((tool) => ({
+                ...tool,
+                configuredEnabled: support.globalOverrides[tool.name] ?? true,
+            })),
+        };
+    }
+    sessionTools() {
+        const support = this.runtime.toolSupport;
+        const sessionId = this.runtime.engine.snapshot().session?.sessionId;
+        if (!support)
+            return { sessionId, busy: this.busy, items: [] };
+        const activePluginIds = new Set(this.runtime.pluginSupport
+            ? activeWebRuntimePlugins(this.runtime.pluginSupport.catalog, this.runtime.pluginSupport.overrides).map((plugin) => plugin.id)
+            : []);
+        return {
+            sessionId,
+            busy: this.busy,
+            items: support.catalog.map((tool) => {
+                const override = support.sessionOverrides[tool.name];
+                const globallyEnabled = support.globalOverrides[tool.name] ?? true;
+                const available = tool.source !== "plugin" || Boolean(tool.pluginId && activePluginIds.has(tool.pluginId));
+                return {
+                    ...tool,
+                    available,
+                    globallyEnabled,
+                    mode: override === undefined ? "inherit" : override ? "enabled" : "disabled",
+                    effectiveEnabled: available && (override ?? globallyEnabled),
+                };
+            }),
+        };
+    }
+    async setGlobalTools(value) {
+        if (this.busy)
+            return actionFailure("TOOL_UPDATE_BLOCKED", "cannot change global tools while a response is running");
+        if (!isRecord(value))
+            return actionFailure("INVALID_REQUEST", "tool overrides must be an object");
+        const support = this.runtime.toolSupport;
+        if (!support)
+            return actionFailure("TOOL_NOT_CONFIGURED", "web tools are not configured");
+        const normalized = this.parseToolOverrides(value, support);
+        if (!normalized.ok)
+            return normalized;
+        try {
+            support.globalOverrides = normalized.value;
+            this.syncPluginToolRegistration();
+            applyToolOverrides(this.runtime.tools, support.catalog, support.globalOverrides, support.sessionOverrides);
+            if (support.persistGlobal)
+                await support.persistGlobal(support.globalOverrides);
+            await this.refreshToolConfiguration();
+            return { ok: true, state: this.globalTools() };
+        }
+        catch (error) {
+            return actionFailure("TOOL_UPDATE_FAILED", error instanceof Error ? error.message : String(error));
+        }
+    }
+    async setSessionTools(value) {
+        if (this.busy)
+            return actionFailure("TOOL_UPDATE_BLOCKED", "cannot change session tools while a response is running");
+        if (!isRecord(value))
+            return actionFailure("INVALID_REQUEST", "tool overrides must be an object");
+        const support = this.runtime.toolSupport;
+        if (!support)
+            return actionFailure("TOOL_NOT_CONFIGURED", "web tools are not configured");
+        const normalized = this.parseToolModes(value, support);
+        if (!normalized.ok)
+            return normalized;
+        try {
+            await this.applySessionToolOverrides(normalized.value, true);
+            return { ok: true, state: this.sessionTools() };
+        }
+        catch (error) {
+            return actionFailure("TOOL_UPDATE_FAILED", error instanceof Error ? error.message : String(error));
+        }
+    }
+    async loadSessionTools(sessionId) {
+        const support = this.runtime.toolSupport;
+        if (!support?.resolveSession || !sessionId)
+            return;
+        await this.applySessionToolOverrides(await support.resolveSession(sessionId), false);
+    }
     async setSessionPlugins(value) {
         if (this.busy)
             return actionFailure("PLUGIN_UPDATE_BLOCKED", "cannot change session plugins while a response is running");
@@ -435,6 +595,64 @@ export class WebRepl {
             return;
         await this.applySessionPluginOverrides(await support.resolve(sessionId), false);
     }
+    parseToolOverrides(value, support) {
+        const available = new Set(support.catalog.map((tool) => tool.name));
+        const overrides = {};
+        for (const [name, enabled] of Object.entries(value)) {
+            if (!available.has(name))
+                return actionFailure("TOOL_INVALID", `unknown tool: ${name}`);
+            if (typeof enabled !== "boolean")
+                return actionFailure("TOOL_INVALID", `invalid tool state: ${name}`);
+            overrides[name] = enabled;
+        }
+        return { ok: true, value: overrides };
+    }
+    parseToolModes(value, support) {
+        const available = new Set(support.catalog.map((tool) => tool.name));
+        const overrides = {};
+        for (const [name, mode] of Object.entries(value)) {
+            if (!available.has(name))
+                return actionFailure("TOOL_INVALID", `unknown tool: ${name}`);
+            if (mode === "enabled" || mode === true)
+                overrides[name] = true;
+            else if (mode === "disabled" || mode === false)
+                overrides[name] = false;
+            else if (mode !== "inherit" && mode !== null && mode !== undefined)
+                return actionFailure("TOOL_INVALID", `invalid tool mode: ${name}`);
+        }
+        return { ok: true, value: overrides };
+    }
+    async applySessionToolOverrides(overrides, persist) {
+        const support = this.runtime.toolSupport;
+        if (!support)
+            return;
+        support.sessionOverrides = normalizeToolOverrides(overrides, support.catalog);
+        this.syncPluginToolRegistration();
+        applyToolOverrides(this.runtime.tools, support.catalog, support.globalOverrides, support.sessionOverrides);
+        const sessionId = this.runtime.engine.snapshot().session?.sessionId;
+        if (persist && sessionId && support.persistSession)
+            await support.persistSession(sessionId, support.sessionOverrides);
+        await this.refreshToolConfiguration();
+    }
+    syncPluginToolRegistration() {
+        const pluginSupport = this.runtime.pluginSupport;
+        if (!pluginSupport)
+            return;
+        for (const plugin of pluginSupport.catalog)
+            for (const tool of plugin.tools)
+                this.runtime.tools.unregister(tool.name);
+        for (const plugin of activeWebRuntimePlugins(pluginSupport.catalog, pluginSupport.overrides)) {
+            for (const tool of plugin.tools)
+                this.runtime.tools.register(tool);
+        }
+    }
+    async refreshToolConfiguration() {
+        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 applySessionPluginOverrides(overrides, persist) {
         const support = this.runtime.pluginSupport;
         if (!support)
@@ -448,6 +666,9 @@ export class WebRepl {
             for (const tool of plugin.tools)
                 this.runtime.tools.register(tool);
         support.overrides = normalized;
+        const toolSupport = this.runtime.toolSupport;
+        if (toolSupport)
+            applyToolOverrides(this.runtime.tools, toolSupport.catalog, toolSupport.globalOverrides, toolSupport.sessionOverrides);
         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)
@@ -474,6 +695,7 @@ export class WebRepl {
             this.broadcastSync();
             return { ok: true };
         }
+        this.publishRuntimeContext();
         this.startRun(text, attachments);
         return { ok: true };
     }
@@ -532,7 +754,7 @@ export class WebRepl {
             const snapshot = this.runtime.engine.snapshot().session;
             if (!snapshot)
                 throw new Error("session transcripts are disabled");
-            await this.loadSessionPlugins(snapshot.sessionId);
+            await Promise.all([this.loadSessionPlugins(snapshot.sessionId), this.loadSessionTools(snapshot.sessionId)]);
             await this.refreshSessionView();
             return { ok: true };
         }
@@ -549,7 +771,7 @@ export class WebRepl {
             const snapshot = this.runtime.engine.snapshot().session;
             if (!snapshot)
                 throw new Error("session transcripts are disabled");
-            await this.loadSessionPlugins(snapshot.sessionId);
+            await Promise.all([this.loadSessionPlugins(snapshot.sessionId), this.loadSessionTools(snapshot.sessionId)]);
             await this.refreshSessionView();
             return { ok: true };
         }
@@ -628,22 +850,28 @@ export class WebRepl {
     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))
+        let block;
+        for (const entry of this.runtime.engine.getDisplayEntries()) {
+            if (entry.type !== "message" || entry.message.id !== messageId)
+                continue;
+            const candidate = entry.message.blocks[blockIndex];
+            if (candidate?.type === "image")
+                block = candidate;
+            break;
+        }
+        return block ? imagePayloadForBlock(block) : undefined;
+    }
+    imagePayloadById(imageId) {
+        if (!imageId)
             return undefined;
-        const body = Buffer.from(base64, "base64");
-        return body.length ? { body, mimeType } : undefined;
+        for (const entry of this.runtime.engine.getDisplayEntries()) {
+            if (entry.type !== "message")
+                continue;
+            const block = entry.message.blocks.find((candidate) => candidate.type === "image" && candidate.imageId === imageId);
+            if (block)
+                return imagePayloadForBlock(block);
+        }
+        return undefined;
     }
     async setFastMode(enabled) {
         try {
@@ -655,6 +883,25 @@ export class WebRepl {
             return actionFailure("FAST_MODE_UPDATE_FAILED", error instanceof Error ? error.message : String(error));
         }
     }
+    async setContextWindowK(value) {
+        if (this.busy)
+            return actionFailure("CONTEXT_WINDOW_UPDATE_BLOCKED", "cannot change context window while a response is running");
+        if (typeof value !== "string" || !/^\d+$/u.test(value) || Number(value) <= 0) {
+            return actionFailure("CONTEXT_WINDOW_INVALID", "context window must be a positive integer in k");
+        }
+        const contextWindowK = Number(value);
+        const contextWindowTokens = contextWindowK * 1000;
+        try {
+            await this.runtime.engine.setContextWindowTokensOverride(contextWindowTokens);
+            const metrics = await this.runtime.engine.contextMetrics();
+            this.runtime.initialMetrics = metrics;
+            this.setStatus({ ...this.status, metrics, activityTick: this.status.activityTick + 1 });
+            return { ok: true, contextWindowK, contextWindowTokens };
+        }
+        catch (error) {
+            return actionFailure("CONTEXT_WINDOW_UPDATE_FAILED", error instanceof Error ? error.message : String(error));
+        }
+    }
     loginForm(providerValue) {
         const provider = parseLoginProvider(providerValue);
         return createLoginFormPayload(this.runtime.envPath, provider);
@@ -711,6 +958,12 @@ export class WebRepl {
             this.broadcastSync();
         return id;
     }
+    appendCompaction(report, createdAt) {
+        this.lines = this.lines.map((line) => line.compaction
+            ? { ...line, compaction: { ...line.compaction, current: false } }
+            : line);
+        return this.append(compactionLine(report, createdAt, true));
+    }
     appendLineText(id, text) {
         this.lines = this.lines.map((line) => line.id === id ? { ...line, text: line.text + text } : line);
         this.broadcastDelta({ type: "line.text.append", id, text });
@@ -749,10 +1002,10 @@ export class WebRepl {
         this.interruptArmed = false;
         this.queuedInput = undefined;
         this.queuedAttachments = undefined;
-        this.pendingUserImageEchoLabels = undefined;
+        this.pendingUserImageEchoIds = undefined;
         this.pendingUserImageEchoMessageId = undefined;
         this.finalizeForegroundView();
-        this.finalizeLiveToolLines();
+        this.cancelLiveToolLines(reason);
         this.busy = false;
         this.status = { ...this.status, phase: "ready", detail: undefined, currentTool: undefined, inputTokenUpdatedAt: undefined, outputTokenUpdatedAt: undefined, retryCooldownUntil: undefined };
         this.broadcastSync();
@@ -765,10 +1018,15 @@ export class WebRepl {
             kind: "agent",
             taskId: task.taskId,
             agentId: task.agentId,
+            agentType: task.agentType,
             type: task.type,
             status: task.status,
             description: task.description,
+            prompt: task.prompt,
+            progress: task.progress,
+            outputFile: task.outputFile,
             createdAt: task.createdAt,
+            updatedAt: task.updatedAt,
         }));
         const terminalTasks = this.runtime.execProcessManager.list()
             .filter((terminal) => terminal.status === "running" && terminal.backgrounded)
@@ -786,8 +1044,26 @@ export class WebRepl {
             shell: terminal.shell,
             tty: terminal.tty,
             durationMs: terminal.duration_ms,
+            output: terminal.output,
+            outputEnd: terminal.outputEnd,
+        }));
+        const sessionTasks = [...this.backgroundSessionRuns.values()].map((run) => ({
+            kind: "session",
+            taskId: `session:${run.sessionId}`,
+            type: "会话",
+            status: "running",
+            description: run.title || "未命名会话",
+            createdAt: run.startedAt,
+            sessionId: run.sessionId,
         }));
-        return [...agentTasks, ...terminalTasks];
+        const createdAtTime = (value) => {
+            if (typeof value === "number")
+                return value;
+            const parsed = Date.parse(value);
+            return Number.isFinite(parsed) ? parsed : 0;
+        };
+        return [...agentTasks, ...terminalTasks, ...sessionTasks]
+            .sort((left, right) => createdAtTime(right.createdAt) - createdAtTime(left.createdAt));
     }
     async detachRunningForeground(reason) {
         if (!this.busy)
@@ -816,7 +1092,7 @@ export class WebRepl {
         this.interruptArmed = false;
         this.queuedInput = undefined;
         this.queuedAttachments = undefined;
-        this.pendingUserImageEchoLabels = undefined;
+        this.pendingUserImageEchoIds = undefined;
         this.pendingUserImageEchoMessageId = undefined;
         this.busy = false;
         this.status = { ...this.status, phase: "ready", detail: undefined };
@@ -858,11 +1134,145 @@ export class WebRepl {
             this.finalizeLiveLine(id);
         this.liveToolLineIds.clear();
     }
+    cancelLiveToolLines(reason) {
+        for (const id of this.liveToolLineIds.values()) {
+            const line = this.lines.find((item) => item.id === id);
+            const steps = (line?.toolStream?.steps ?? []).map((step) => step.status === "running" ? { ...step, status: "failed", phase: "cancelled" } : step);
+            this.lines = this.lines.map((item) => item.id === id ? { ...item, live: false, kind: "error", titleStatus: "failure", bodyTitle: reason, toolStream: { ...item.toolStream, phase: "cancelled", message: reason, steps } } : item);
+            this.queueDeltaOperation({ type: "line.patch", id, patch: { live: false, kind: "error", titleStatus: "failure", bodyTitle: reason, toolStream: { ...line?.toolStream, phase: "cancelled", message: reason, steps } } });
+        }
+        this.liveToolLineIds.clear();
+    }
+    patchLiveToolLine(toolUseId, patch) {
+        const id = this.liveToolLineIds.get(toolUseId);
+        if (id === undefined)
+            return;
+        const line = this.lines.find((item) => item.id === id);
+        if (!line)
+            return;
+        this.lines = this.lines.map((item) => item.id === id ? { ...item, ...patch } : item);
+        this.queueDeltaOperation({ type: "line.patch", id, patch });
+    }
+    applyToolProgress(event) {
+        const id = this.liveToolLineIds.get(event.toolUse.id);
+        if (id === undefined)
+            return;
+        const line = this.lines.find((item) => item.id === id);
+        if (!line)
+            return;
+        const progress = event.progress;
+        const previousStream = line.toolStream ?? {};
+        if (progress.sequence !== undefined && previousStream.sequence !== undefined && progress.sequence <= previousStream.sequence)
+            return;
+        const channel = progress.channel ?? inferToolStreamChannel(progress.data);
+        const operation = progress.operation ?? (channel === "stdout" || channel === "stderr" ? "append" : "replace");
+        const stream = { ...previousStream };
+        stream.channel = channel;
+        stream.phase = progress.phase;
+        stream.sequence = progress.sequence ?? stream.sequence;
+        if (progress.progress) {
+            stream.current = progress.progress.current;
+            stream.total = progress.progress.total;
+            stream.unit = progress.progress.unit;
+        }
+        const terminalDelta = terminalOutputDelta(progress.data);
+        const textDelta = toolStreamTextDelta(progress.data);
+        if (terminalDelta) {
+            const key = terminalDelta.stream === "stderr" ? "stderr" : "stdout";
+            stream[key] = operation === "replace"
+                ? trimToolStreamText(terminalDelta.text, 40_000)
+                : appendToolStreamText(stream[key], terminalDelta.text, 40_000);
+            stream.chunks = appendToolStreamChunk(stream.chunks, progress.sequence, key, terminalDelta.text, operation);
+        }
+        else if ((channel === "stdout" || channel === "stderr") && textDelta !== undefined) {
+            stream[channel] = operation === "replace"
+                ? trimToolStreamText(textDelta, 40_000)
+                : appendToolStreamText(stream[channel], textDelta, 40_000);
+            stream.chunks = appendToolStreamChunk(stream.chunks, progress.sequence, channel, textDelta, operation);
+        }
+        else if ((channel === "patch" || channel === "artifact") && textDelta !== undefined) {
+            stream.output = operation === "replace"
+                ? trimToolStreamText(textDelta, 40_000)
+                : appendToolStreamText(stream.output, textDelta, 40_000);
+            stream.chunks = appendToolStreamChunk(stream.chunks, progress.sequence, "output", textDelta, operation);
+            stream.message = progress.message;
+        }
+        else if (channel === "item") {
+            const key = progress.key || progress.phase || `step-${progress.sequence ?? Date.now()}`;
+            const steps = [...(stream.steps ?? [])];
+            const index = steps.findIndex((step) => step.key === key);
+            if (operation === "remove") {
+                if (index >= 0)
+                    steps.splice(index, 1);
+            }
+            else {
+                const status = toolStreamStepStatus(progress.phase);
+                const message = operation === "append" && index >= 0
+                    ? `${steps[index].message}${progress.message}`
+                    : progress.message;
+                const stepToolName = childToolName(progress.data) ?? steps[index]?.toolName;
+                const step = {
+                    key,
+                    message,
+                    toolName: stepToolName,
+                    toolLabel: stepToolName ? toolTitle(stepToolName, "running") : steps[index]?.toolLabel,
+                    status,
+                    phase: progress.phase,
+                    sequence: progress.sequence,
+                };
+                if (index >= 0)
+                    steps[index] = step;
+                else
+                    steps.push(step);
+            }
+            stream.steps = steps.slice(-24);
+            stream.message = progress.message;
+        }
+        else if (operation === "append") {
+            stream.message = `${stream.message ?? ""}${progress.message}`;
+        }
+        else if (operation === "remove") {
+            stream.message = undefined;
+        }
+        else {
+            stream.message = progress.message;
+        }
+        this.patchLiveToolLine(event.toolUse.id, { toolStream: stream });
+    }
+    applyAvailableToolResult(event) {
+        const liveLineId = this.liveToolLineIds.get(event.toolUse.id);
+        if (liveLineId === undefined)
+            return;
+        const liveLine = this.lines.find((item) => item.id === liveLineId);
+        if (!liveLine)
+            return;
+        let replacement;
+        for (const message of event.messages) {
+            renderToolResultMessage(message, (line, toolUseId) => {
+                if (toolUseId === event.toolUse.id)
+                    replacement = line;
+                return liveLineId;
+            }, runtimeToolResultPresenter(this.runtime));
+        }
+        const steps = (liveLine.toolStream?.steps ?? []).map((step) => step.status === "running" ? { ...step, status: event.ok ? "completed" : "failed" } : step);
+        if (replacement) {
+            this.replaceLine(liveLineId, {
+                ...replacement,
+                live: false,
+                presentationLevel: mergePresentationLevel(replacement.presentationLevel, liveLine.presentationLevel),
+                toolDisplay: mergeToolDisplays(replacement.toolDisplay, liveLine.toolDisplay),
+                toolStream: { ...liveLine.toolStream, steps, message: liveLine.toolStream?.message },
+            });
+        }
+        else {
+            this.replaceLine(liveLineId, { live: false, titleStatus: event.ok ? "success" : "failure", toolStream: { ...liveLine.toolStream, steps } });
+        }
+    }
     handleEvent(event) {
         this.reduce(event);
         if (event.type === "message" && this.matchesPendingUserImageEcho(event.message)) {
             const messageId = this.pendingUserImageEchoMessageId;
-            this.pendingUserImageEchoLabels = undefined;
+            this.pendingUserImageEchoIds = undefined;
             this.pendingUserImageEchoMessageId = undefined;
             renderMessageImages(event.message, (line) => this.append(line), messageId);
             this.broadcastSync();
@@ -872,6 +1282,10 @@ export class WebRepl {
             this.queueDeltaStatus();
             return;
         }
+        if (event.type === "context.compacted") {
+            this.appendCompaction(event.compaction);
+            return;
+        }
         if (event.type === "state" || event.type === "context.metrics" || event.type === "usage" || event.type === "retrying") {
             this.broadcastSync();
             return;
@@ -890,6 +1304,18 @@ export class WebRepl {
             this.appendLineText(id, event.text);
             return;
         }
+        if (event.type === "tool.progress") {
+            this.applyToolProgress(event);
+            return;
+        }
+        if (event.type === "tool.result.available") {
+            this.applyAvailableToolResult(event);
+            return;
+        }
+        if (event.type === "tool.batch.completed") {
+            this.broadcastSync();
+            return;
+        }
         if (event.type === "message") {
             let replacedStreamingContent = false;
             if (event.message.role === "assistant" && this.assistantLineId !== undefined) {
@@ -920,12 +1346,19 @@ export class WebRepl {
             if (event.message.role === "tool_result") {
                 renderToolResultMessage(event.message, (line, toolUseId) => {
                     const liveLineId = this.liveToolLineIds.get(toolUseId);
-                    if (liveLineId === undefined)
+                    if (liveLineId === undefined) {
+                        const existing = this.lines.find((item) => item.toolUseId === toolUseId);
+                        if (existing) {
+                            this.replaceLine(existing.id, { ...line, toolStream: existing.toolStream, presentationLevel: mergePresentationLevel(line.presentationLevel, existing.presentationLevel), toolDisplay: mergeToolDisplays(line.toolDisplay, existing.toolDisplay) });
+                            return existing.id;
+                        }
                         return this.append(line);
-                    this.replaceLine(liveLineId, line);
+                    }
+                    const liveLine = this.lines.find((item) => item.id === liveLineId);
+                    this.replaceLine(liveLineId, { ...line, toolStream: liveLine?.toolStream, presentationLevel: mergePresentationLevel(line.presentationLevel, liveLine?.presentationLevel), toolDisplay: mergeToolDisplays(line.toolDisplay, liveLine?.toolDisplay) });
                     this.liveToolLineIds.delete(toolUseId);
                     return liveLineId;
-                });
+                }, runtimeToolResultPresenter(this.runtime));
                 renderMessageImages(event.message, (line) => this.append(line));
                 return;
             }
@@ -946,16 +1379,15 @@ export class WebRepl {
         if (event.type === "tool.started") {
             this.finalizeLiveLine(this.assistantLineId);
             this.finalizeThinkingLine();
+            this.assistantLineId = undefined;
             const id = this.append({ ...formatToolUse(event.toolUse), live: true });
             this.liveToolLineIds.set(event.toolUse.id, id);
             return;
         }
         if (event.type === "tool.finished") {
             const id = this.liveToolLineIds.get(event.toolUse.id);
-            if (id !== undefined) {
+            if (id !== undefined)
                 this.finalizeLiveLine(id);
-                this.liveToolLineIds.delete(event.toolUse.id);
-            }
             return;
         }
         if (event.type === "terminal") {
@@ -970,13 +1402,13 @@ export class WebRepl {
             this.append({ kind: "error", text: event.error.message });
     }
     matchesPendingUserImageEcho(message) {
-        const pending = this.pendingUserImageEchoLabels;
+        const pending = this.pendingUserImageEchoIds;
         if (!pending?.length || message.role !== "user")
             return false;
-        const labels = message.blocks
-            .filter((block) => block.type === "image" && typeof block.label === "string")
-            .map((block) => block.label);
-        return labels.length === pending.length && labels.every((label, index) => label === pending[index]);
+        const imageIds = message.blocks
+            .filter((block) => block.type === "image" && typeof block.imageId === "string")
+            .map((block) => block.imageId);
+        return imageIds.length === pending.length && imageIds.every((imageId, index) => imageId === pending[index]);
     }
     async handleCommandOrPrompt(text, attachments = []) {
         const command = parseReplCommand(text);
@@ -1078,11 +1510,11 @@ export class WebRepl {
         const promptPayload = buildWebPromptPayload(command.text, attachments);
         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 optimisticImageIds = (promptPayload.blocks ?? [])
+            .filter((block) => block.type === "image" && typeof block.imageId === "string")
+            .map((block) => block.imageId);
+        this.pendingUserImageEchoIds = optimisticImageIds.length ? optimisticImageIds : undefined;
+        this.pendingUserImageEchoMessageId = optimisticImageIds.length ? optimisticMessageId : undefined;
         const runToken = ++this.foregroundRunToken;
         const abortController = new AbortController();
         this.activeAbortController = abortController;
@@ -1091,7 +1523,12 @@ export class WebRepl {
         this.setStatus({ ...this.status, phase: "running", detail: "working", usage: undefined, streamedOutputTokens: 0, inputTokenUpdatedAt: undefined, outputTokenUpdatedAt: undefined, retryCooldownUntil: undefined });
         const engine = this.runtime.engine;
         try {
-            for await (const event of engine.sendUserText(promptPayload.text, { abortSignal: abortController.signal, blocks: promptPayload.blocks, displayText: promptPayload.displayText })) {
+            for await (const event of engine.sendUserText(promptPayload.text, {
+                abortSignal: abortController.signal,
+                blocks: promptPayload.blocks,
+                displayText: promptPayload.displayText,
+                stopAfterTurn: () => this.queuedInput !== undefined,
+            })) {
                 if (this.foregroundRunToken !== runToken)
                     continue;
                 if (this.runtime.engine !== engine)
@@ -1122,7 +1559,7 @@ export class WebRepl {
                 this.activeAbortController = undefined;
             this.interruptArmed = false;
             this.finalizeForegroundView();
-            this.pendingUserImageEchoLabels = undefined;
+            this.pendingUserImageEchoIds = undefined;
             this.pendingUserImageEchoMessageId = undefined;
             const queuedText = this.queuedInput;
             const queuedAttach = this.queuedAttachments;
@@ -1155,7 +1592,10 @@ export class WebRepl {
             const metrics = await this.runtime.engine.contextMetrics();
             if (this.foregroundRunToken !== runToken)
                 return;
-            this.append(systemLine(type === "compact" ? formatManualCompaction(result) : formatPureCompaction(result)));
+            if (result.report)
+                this.appendCompaction(result.report);
+            else
+                this.append(systemLine(type === "compact" ? formatManualCompaction(result) : formatPureCompaction(result)));
             this.handleEvent({ type: "context.metrics", metrics });
         }
         catch (error) {
@@ -1174,7 +1614,9 @@ export class WebRepl {
     }
     send(subscriber, event, data) {
         if (subscriber.blocked) {
-            if (event === "runtime.context")
+            if (event === "client.reload")
+                subscriber.pendingClientReload = data;
+            else if (event === "runtime.context")
                 subscriber.needsRuntimeContext = true;
             else
                 subscriber.needsSync = true;
@@ -1189,6 +1631,11 @@ export class WebRepl {
             subscriber.blocked = false;
             if (subscriber.response.destroyed)
                 return;
+            if (subscriber.pendingClientReload) {
+                const payload = subscriber.pendingClientReload;
+                subscriber.pendingClientReload = undefined;
+                this.send(subscriber, "client.reload", payload);
+            }
             if (subscriber.needsSync) {
                 subscriber.needsSync = false;
                 this.send(subscriber, "sync", this.snapshot(false));
@@ -1204,6 +1651,7 @@ export class WebRepl {
         return createWebRuntimeContextPayload(snapshot, {
             revision,
             sessionId: this.runtime.engine.snapshot().session?.sessionId,
+            toolPresentations: Object.fromEntries((this.runtime.toolSupport?.catalog ?? []).map((tool) => [tool.name, tool.presentation])),
         });
     }
     publishRuntimeContext(targets) {
@@ -1264,6 +1712,39 @@ export class WebRepl {
         this.pendingDeltaOperations = [];
         this.pendingDeltaStatus = false;
     }
+    dropInactiveTerminalOutput() {
+        for (const sessionId of this.pendingTerminalOutput.keys()) {
+            if (!this.runtime.execProcessManager.isBackgroundRunning(sessionId))
+                this.pendingTerminalOutput.delete(sessionId);
+        }
+    }
+    queueTerminalOutput(delta) {
+        if (!this.subscribers.size || !this.runtime.execProcessManager.isBackgroundRunning(delta.sessionId))
+            return;
+        const outputStart = Number(delta.outputStart ?? 0);
+        const outputEnd = Number(delta.outputEnd ?? outputStart + delta.text.length);
+        const pending = this.pendingTerminalOutput.get(delta.sessionId);
+        if (pending && pending.outputEnd === outputStart) {
+            pending.text = appendBoundedText(pending.text, delta.text, TERMINAL_OUTPUT_EVENT_MAX_CHARS);
+            pending.outputEnd = outputEnd;
+        }
+        else {
+            this.pendingTerminalOutput.set(delta.sessionId, { text: delta.text.slice(-TERMINAL_OUTPUT_EVENT_MAX_CHARS), outputStart, outputEnd });
+        }
+        if (this.terminalOutputTimer)
+            return;
+        this.terminalOutputTimer = setTimeout(() => this.flushTerminalOutput(), TERMINAL_OUTPUT_FLUSH_MS);
+        this.terminalOutputTimer.unref?.();
+    }
+    flushTerminalOutput() {
+        this.terminalOutputTimer = undefined;
+        if (!this.pendingTerminalOutput.size)
+            return;
+        const updates = [...this.pendingTerminalOutput.entries()].map(([sessionId, output]) => ({ sessionId, ...output }));
+        this.pendingTerminalOutput.clear();
+        for (const subscriber of this.subscribers)
+            this.send(subscriber, "terminal.output", { updates });
+    }
     broadcastSync() {
         this.discardPendingDeltaOperations();
         const payload = this.snapshot(false);
@@ -1271,6 +1752,10 @@ export class WebRepl {
             this.send(subscriber, "sync", payload);
     }
 }
+function appendBoundedText(current, incoming, limit) {
+    const combined = current + incoming;
+    return combined.length <= limit ? combined : combined.slice(-limit);
+}
 export function compactLineOperations(operations) {
     const compacted = [];
     for (const operation of operations) {
@@ -1303,20 +1788,67 @@ async function route(req, res, router) {
             return sendFile(res, highlightAssetPath, "text/javascript; charset=utf-8");
         if (req.method === "GET" && url.pathname === "/vendor/highlight-theme.css")
             return sendFile(res, highlightThemeAssetPath, "text/css; charset=utf-8");
+        if (req.method === "GET" && url.pathname === "/api/client-info")
+            return sendJson(res, router.clientInfo());
+        if (req.method === "POST" && url.pathname === "/api/client-reload") {
+            const body = await readJsonBody(req);
+            return sendJson(res, await router.requestClientReload(body));
+        }
         const scope = webRuntimeScopeFromUrl(url);
         const repl = await router.get(scope);
         if (req.method === "GET" && url.pathname === "/events")
-            return repl.subscribe(res);
+            return repl.subscribe(res, router.clientInfo());
         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());
+        const workspaceRepl = repl;
+        if (req.method === "GET" && url.pathname === "/api/cwd") {
+            return sendJson(res, workspaceRepl.browseWorkspace
+                ? await workspaceRepl.browseWorkspace(url.searchParams.get("path") ?? undefined)
+                : actionFailure("CWD_NOT_CONFIGURED", "workspace navigation is not configured"));
+        }
+        if (req.method === "POST" && url.pathname === "/api/cwd/change") {
+            const body = await readJsonBody(req);
+            return sendJson(res, workspaceRepl.changeWorkspace
+                ? await workspaceRepl.changeWorkspace(body.path)
+                : actionFailure("CWD_NOT_CONFIGURED", "workspace navigation is not configured"));
+        }
+        if (req.method === "POST" && url.pathname === "/api/cwd/create") {
+            const body = await readJsonBody(req);
+            return sendJson(res, workspaceRepl.createWorkspaceDirectory
+                ? await workspaceRepl.createWorkspaceDirectory(body.path)
+                : actionFailure("CWD_NOT_CONFIGURED", "workspace navigation is not configured"));
+        }
+        if (req.method === "POST" && url.pathname === "/api/cwd/delete") {
+            const body = await readJsonBody(req);
+            return sendJson(res, workspaceRepl.deleteWorkspaceDirectory
+                ? await workspaceRepl.deleteWorkspaceDirectory(body.path)
+                : actionFailure("CWD_NOT_CONFIGURED", "workspace navigation is not configured"));
+        }
+        if (req.method === "GET" && url.pathname === "/api/tools")
+            return sendJson(res, repl.globalTools());
+        if (req.method === "POST" && url.pathname === "/api/tools/global") {
+            const body = await readJsonBody(req);
+            return sendJson(res, await repl.setGlobalTools(body.overrides));
+        }
+        if (req.method === "GET" && url.pathname === "/api/session-tools")
+            return sendJson(res, repl.sessionTools());
+        if (req.method === "POST" && url.pathname === "/api/session-tools") {
+            const body = await readJsonBody(req);
+            return sendJson(res, await repl.setSessionTools(body.overrides));
+        }
         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 imageIdMatch = /^\/api\/images\/by-id\/([^/]+)$/u.exec(url.pathname);
+        if (req.method === "GET" && imageIdMatch) {
+            const payload = repl.imagePayloadById(decodeURIComponent(imageIdMatch[1]));
+            return payload ? sendImage(res, payload) : sendJson(res, { error: "image not found" }, 404);
+        }
         const imageMatch = /^\/api\/images\/([^/]+)\/(\d+)$/u.exec(url.pathname);
         if (req.method === "GET" && imageMatch) {
             const payload = repl.imagePayload(decodeURIComponent(imageMatch[1]), Number(imageMatch[2]));
@@ -1332,6 +1864,10 @@ async function route(req, res, router) {
             const body = await readJsonBody(req);
             return sendJson(res, await repl.setFastMode(body.enabled === true));
         }
+        if (req.method === "POST" && url.pathname === "/api/context-window") {
+            const body = await readJsonBody(req);
+            return sendJson(res, await repl.setContextWindowK(body.value));
+        }
         if (req.method === "POST" && url.pathname === "/api/submit") {
             const body = await readJsonBody(req);
             return sendJson(res, await repl.submit(String(body.text ?? ""), sanitizeWebAttachments(body.attachments)));
@@ -1393,6 +1929,20 @@ 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 imagePayloadForBlock(block) {
+    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;
+}
 function sendImage(res, payload) {
     res.writeHead(200, {
         "Content-Type": payload.mimeType,
@@ -1416,7 +1966,8 @@ function sanitizeWebAttachments(value) {
         if (!isRecord(item))
             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 }];
+            const imageId = typeof item.imageId === "string" && /^image_[0-9a-f-]{36}$/iu.test(item.imageId) ? item.imageId : createImageId();
+            return [{ kind: "image", imageId, 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 [{
@@ -1454,14 +2005,44 @@ function initialLines(runtime, lineId) {
         lines.push({ id: ++lineId.current, ...line });
     return lines;
 }
+export function restoreWebHistoryLines(runtime) {
+    return restoredHistoryLines(runtime).map((line) => ({ ...line }));
+}
 function restoredHistoryLines(runtime) {
     const lines = [];
+    const historyToolLineIndexes = new Map();
     const append = (line) => {
+        if (line.toolUseId && line.titleStatus && historyToolLineIndexes.has(line.toolUseId)) {
+            const index = historyToolLineIndexes.get(line.toolUseId);
+            const started = lines[index];
+            lines[index] = { ...line, presentationLevel: mergePresentationLevel(line.presentationLevel, started.presentationLevel), toolDisplay: mergeToolDisplays(line.toolDisplay, started.toolDisplay) };
+            return index + 1;
+        }
         lines.push(line);
+        if (line.toolUseId && !line.titleStatus)
+            historyToolLineIndexes.set(line.toolUseId, lines.length - 1);
         return lines.length;
     };
-    for (const message of runtime.engine.getHistoryMessages())
-        renderMessage(message, append, undefined, { includeToolUseBlocks: true, includeThinkingBlocks: true });
+    const entries = runtime.engine.getDisplayEntries();
+    let lastCompactionIndex = -1;
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+        if (entries[index].type === "compact") {
+            lastCompactionIndex = index;
+            break;
+        }
+    }
+    for (const [entryIndex, entry] of entries.entries()) {
+        if (entry.type === "message") {
+            renderMessage(entry.message, append, undefined, {
+                includeToolUseBlocks: true,
+                includeThinkingBlocks: true,
+                presentToolResult: runtimeToolResultPresenter(runtime),
+            });
+            continue;
+        }
+        const report = entry.report ?? legacyCompactionReport(entry.reason);
+        append(compactionLine(report, entry.createdAt, entryIndex === lastCompactionIndex));
+    }
     return lines;
 }
 function initialStatus(runtime, metrics = runtime.initialMetrics) {
@@ -1471,7 +2052,18 @@ async function resetStatus(runtime) {
     return initialStatus(runtime, await runtime.engine.contextMetrics());
 }
 function buildWebPromptPayload(displayText, attachments) {
-    const activeAttachments = attachments.filter((attachment) => attachment.kind === "image" && displayText.includes(attachment.label));
+    const candidateAttachments = attachments.filter((attachment) => attachment.kind === "image" && displayText.includes(attachment.label));
+    const labels = new Set();
+    const imageIds = new Set();
+    for (const attachment of candidateAttachments) {
+        if (labels.has(attachment.label))
+            throw new Error(`Duplicate image label in one submission: ${attachment.label}`);
+        if (imageIds.has(attachment.imageId))
+            throw new Error(`Duplicate image identity in one submission: ${attachment.imageId}`);
+        labels.add(attachment.label);
+        imageIds.add(attachment.imageId);
+    }
+    const activeAttachments = candidateAttachments;
     const fileManifest = buildWebFileAttachmentManifest(attachments.filter((attachment) => attachment.kind === "file"));
     if (activeAttachments.length === 0) {
         const text = [displayText.trim(), fileManifest].filter(Boolean).join("\n\n");
@@ -1486,7 +2078,7 @@ function buildWebPromptPayload(displayText, attachments) {
             break;
         }
         pushTextBlock(blocks, displayText.slice(cursor, next.index));
-        blocks.push({ type: "image", mimeType: next.attachment.mimeType, data: next.attachment.data, label: next.attachment.label });
+        blocks.push({ type: "image", imageId: next.attachment.imageId, 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}` : "");
@@ -1531,9 +2123,76 @@ function pushTextBlock(blocks, text) {
     else
         blocks.push({ type: "text", text });
 }
+function inferToolStreamChannel(data) {
+    if (data && typeof data === "object" && !Array.isArray(data) && data.type === "terminal.output.delta") {
+        return data.stream === "stderr" ? "stderr" : "stdout";
+    }
+    return "state";
+}
+function terminalOutputDelta(data) {
+    if (!data || typeof data !== "object" || Array.isArray(data))
+        return undefined;
+    const record = data;
+    if (record.type !== "terminal.output.delta" || typeof record.text !== "string")
+        return undefined;
+    return { stream: record.stream === "stderr" ? "stderr" : "stdout", text: record.text };
+}
+function toolStreamTextDelta(data) {
+    if (typeof data === "string")
+        return data;
+    if (!data || typeof data !== "object" || Array.isArray(data))
+        return undefined;
+    const record = data;
+    for (const value of [record.text, record.delta, record.patch, record.content]) {
+        if (typeof value === "string")
+            return value;
+    }
+    return undefined;
+}
+function childToolName(data) {
+    if (!data || typeof data !== "object" || Array.isArray(data))
+        return undefined;
+    const childEvent = data.child_event;
+    if (!childEvent || typeof childEvent !== "object" || Array.isArray(childEvent))
+        return undefined;
+    const toolUse = childEvent.toolUse;
+    if (!toolUse || typeof toolUse !== "object" || Array.isArray(toolUse))
+        return undefined;
+    return stringValue(toolUse.name);
+}
+function appendToolStreamChunk(chunks, sequence, stream, text, operation) {
+    const next = operation === "replace" ? [] : [...(chunks ?? [])];
+    next.push({ sequence: sequence ?? (next.at(-1)?.sequence ?? 0) + 1, stream, text });
+    let total = 0;
+    const retained = [];
+    for (let index = next.length - 1; index >= 0; index -= 1) {
+        const chunk = next[index];
+        if (total >= 40_000)
+            break;
+        retained.push(chunk);
+        total += chunk.text.length;
+    }
+    return retained.reverse();
+}
+function trimToolStreamText(value, maxChars) {
+    return value.length <= maxChars ? value : value.slice(value.length - maxChars);
+}
+function appendToolStreamText(current, delta, maxChars) {
+    return trimToolStreamText(`${current ?? ""}${delta}`, maxChars);
+}
+function toolStreamStepStatus(phase) {
+    const normalized = phase?.toLowerCase() ?? "";
+    if (normalized.includes("fail") || normalized.includes("error") || normalized.includes("cancel") || normalized.includes("abort"))
+        return "failed";
+    if (normalized.includes("complete") || normalized.includes("finish") || normalized.includes("done") || normalized.includes("success"))
+        return "completed";
+    return "running";
+}
 function reduceStatus(status, event) {
     if (event.type === "state")
         return { ...status, phase: event.phase, detail: event.detail, currentTool: event.phase === "running_tools" ? status.currentTool : undefined, usage: event.phase === "preparing" ? undefined : status.usage, streamedOutputTokens: event.phase === "preparing" ? 0 : status.streamedOutputTokens, inputTokenUpdatedAt: event.phase === "preparing" ? undefined : status.inputTokenUpdatedAt, outputTokenUpdatedAt: event.phase === "preparing" ? undefined : status.outputTokenUpdatedAt, retryCooldownUntil: event.phase === "preparing" ? undefined : status.retryCooldownUntil, activityTick: status.activityTick + 1 };
+    if (event.type === "context.compacted")
+        return { ...status, phase: "compacting", detail: formatCompactionReportSummary(event.compaction), activityTick: status.activityTick + 1 };
     if (event.type === "context.metrics")
         return { ...status, metrics: event.metrics, inputTokenUpdatedAt: event.metrics.estimatedInputTokens !== status.metrics?.estimatedInputTokens ? Date.now() : status.inputTokenUpdatedAt, activityTick: status.activityTick + 1 };
     if (event.type === "usage")
@@ -1548,8 +2207,10 @@ function reduceStatus(status, event) {
         return { ...status, phase: "calling_model", detail: `retrying in ${(event.delayMs / 1000).toFixed(1)}s`, retryCooldownUntil: Date.now() + event.delayMs, activityTick: status.activityTick + 1 };
     if (event.type === "tool.started")
         return { ...status, phase: "running_tools", currentTool: { id: event.toolUse.id, name: event.toolUse.name, input: event.toolUse.input, startedAt: Date.now() }, activityTick: status.activityTick + 1 };
-    if (event.type === "tool.finished")
-        return { ...status, currentTool: status.currentTool?.id === event.toolUse.id ? undefined : status.currentTool, activityTick: status.activityTick + 1 };
+    if (event.type === "tool.progress")
+        return { ...status, phase: "running_tools", detail: event.progress.message || status.detail, currentTool: { id: event.toolUse.id, name: event.toolUse.name, input: event.toolUse.input, startedAt: status.currentTool?.id === event.toolUse.id ? status.currentTool.startedAt : Date.now() }, activityTick: status.activityTick + 1 };
+    if (event.type === "tool.result.available" || event.type === "tool.finished" || event.type === "tool.batch.completed")
+        return { ...status, currentTool: "toolUse" in event && status.currentTool?.id === event.toolUse.id ? undefined : status.currentTool, activityTick: status.activityTick + 1 };
     if (event.type === "terminal")
         return { ...status, phase: "stopped", detail: event.reason, currentTool: undefined, inputTokenUpdatedAt: undefined, outputTokenUpdatedAt: undefined, retryCooldownUntil: undefined, activityTick: status.activityTick + 1 };
     if (event.type === "message" || event.type === "error")
@@ -1862,6 +2523,7 @@ function renderMessage(message, append, activeAssistantId, options = {}) {
     if (message.role === "assistant" && activeAssistantId !== undefined && message.blocks.some((block) => block.type === "text"))
         return true;
     const parentToolName = typeof message.metadata?.tool === "string" ? message.metadata.tool : undefined;
+    const parentToolUseId = message.blocks.find((block) => block.type === "tool_result")?.toolUseId;
     let rendered = false;
     for (const [blockIndex, block] of message.blocks.entries()) {
         if (block.type === "text") {
@@ -1878,7 +2540,7 @@ function renderMessage(message, append, activeAssistantId, options = {}) {
             const line = imageLineForBlock(message.role, block, message.id, blockIndex);
             if (!line)
                 continue;
-            append({ ...line, messageId: message.id, parentToolName });
+            append({ ...line, messageId: message.id, parentToolName, parentToolUseId });
             rendered = true;
         }
         else if (block.type === "thinking") {
@@ -1888,22 +2550,22 @@ function renderMessage(message, append, activeAssistantId, options = {}) {
             rendered = true;
         }
         else if (block.type === "tool_use" && options.includeToolUseBlocks) {
-            append({ ...formatToolUse(block), messageId: message.id, live: false });
+            append({ ...formatToolUse(block), messageId: message.id, toolUseId: block.id, live: false });
             rendered = true;
         }
         else if (block.type === "tool_result") {
-            append({ ...formatToolResultLine(block.name, block.output, block.ok), messageId: message.id });
+            append({ ...formatToolResultLine(block.name, block.output, block.ok, options.presentToolResult), messageId: message.id, toolUseId: block.toolUseId });
             rendered = true;
         }
     }
     return rendered;
 }
-function renderToolResultMessage(message, append) {
+function renderToolResultMessage(message, append, presentToolResult) {
     let rendered = false;
     for (const block of message.blocks) {
         if (block.type !== "tool_result")
             continue;
-        append({ ...formatToolResultLine(block.name, block.output, block.ok), messageId: message.id, toolUseId: block.toolUseId }, block.toolUseId);
+        append({ ...formatToolResultLine(block.name, block.output, block.ok, presentToolResult), messageId: message.id, toolUseId: block.toolUseId }, block.toolUseId);
         rendered = true;
     }
     return rendered;
@@ -1927,13 +2589,18 @@ function imageLineForBlock(role, block, messageId, blockIndex) {
     const kind = kindForRole(role);
     if (kind === "meta")
         return undefined;
+    const resolution = resolveImageBlockDataResultSync(block);
     return {
         kind,
         text: block.label ?? `[image ${block.mimeType}]`,
         image: {
-            src: `/api/images/${encodeURIComponent(messageId)}/${blockIndex}`,
+            src: resolution.available ? (block.imageId ? `/api/images/by-id/${encodeURIComponent(block.imageId)}` : `/api/images/${encodeURIComponent(messageId)}/${blockIndex}`) : undefined,
+            imageId: block.imageId,
             label: block.label,
             mimeType: block.mimeType,
+            available: resolution.available,
+            error: resolution.available ? undefined : resolution.error,
+            blockIndex,
         },
     };
 }
@@ -1985,39 +2652,192 @@ function titleForKind(kind) {
 function systemLine(text, summaryMaxLines) {
     return { kind: "system", title: "System", text, previewStyle: "summary", summaryMaxLines };
 }
+function legacyCompactionReport(reason) {
+    return {
+        reason: reason && reason !== "none" ? reason : "manualcompact",
+        summary: "此检查点由旧版 neoctl 持久化，未保存详细压缩报告。",
+        continuationState: "该旧版检查点没有可用的详细续接上下文。",
+        sourceMessages: 0,
+        preservedUserMessages: 0,
+        newWindowMessages: 0,
+        charsFreed: 0,
+        modelDriven: false,
+        imageCount: 0,
+    };
+}
+function compactionLine(report, createdAt = new Date().toISOString(), current = true) {
+    return {
+        kind: "meta",
+        title: "Context compaction",
+        text: formatCompactionReportSummary(report),
+        format: "plain",
+        compaction: { ...report, createdAt, current },
+    };
+}
+function compactionReportFromBoundary(message) {
+    if (!message?.metadata?.compactBoundary)
+        return undefined;
+    const stored = message.metadata.compactionReport;
+    if (stored?.continuationState)
+        return { ...stored };
+    const text = message.blocks.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+    const continuationState = /<compact_state>\s*([\s\S]*?)\s*<\/compact_state>/i.exec(text)?.[1]?.trim();
+    if (!continuationState)
+        return undefined;
+    const reasonValue = typeof message.metadata.compactionReason === "string" ? message.metadata.compactionReason : "autocompact";
+    const reason = isCompactionReason(reasonValue) ? reasonValue : "autocompact";
+    const imageRegistry = message.metadata.imageRegistry;
+    return {
+        reason,
+        summary: continuationState,
+        continuationState,
+        sourceMessages: 0,
+        preservedUserMessages: 0,
+        newWindowMessages: 1,
+        charsFreed: 0,
+        modelDriven: message.metadata.modelDriven === true,
+        imageCount: Array.isArray(imageRegistry?.images) ? imageRegistry.images.length : 0,
+    };
+}
+function isCompactionReason(value) {
+    return ["snip", "microcompact", "autocompact", "reactive_compact", "manualcompact", "purecompact"].includes(value);
+}
+function formatCompactionReportSummary(report) {
+    return `${report.newWindowMessages} message(s) in new window, ${report.preservedUserMessages} user message(s) preserved`;
+}
 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" && 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 toolPresentation = toolPresentationForSource(toolUse.name);
+    const presentationLevel = toolPresentationLevel(toolUse.name, toolUse.input);
+    if (toolUse.name === "plan_update" && isWebPlanPayload(toolUse.input))
+        return { kind: "tool", toolName: toolUse.name, toolPresentation, title: toolPresentation.label, bodyTitle: webPlanBodyTitle(toolUse.input), text: serializeWebPlanPayload(toolUse.input), presentationLevel, collapsible: true };
+    if (toolUse.name === "image_create")
+        return { kind: "tool", toolName: toolUse.name, toolPresentation, toolUseId: toolUse.id, title: toolPresentation.label, bodyTitle: "图片模型处理中", text: JSON.stringify(toolUse.input ?? {}, null, 2), format: "plain", previewStyle: "summary", presentationLevel: "primary", collapsible: true };
     const summary = summarizeToolUse(toolUse.name, toolUse.input);
-    return { kind: "tool", toolName: toolUse.name, title: toolTitle(toolUse.name, "running"), bodyTitle: summary.bodyTitle, text: summary.text, previewStyle: "summary", collapsible: true };
+    return { kind: "tool", toolName: toolUse.name, toolPresentation, toolUseId: toolUse.id, title: toolPresentation.label, bodyTitle: summary.bodyTitle, text: summary.text, toolDisplay: buildToolUseDisplay(toolUse.name, toolUse.input), previewStyle: "summary", presentationLevel, collapsible: true };
+}
+function formatToolResultLine(toolName, output, ok, presentToolResult) {
+    const presentation = normalizeToolResultPresentation(presentToolResult?.(toolName, output, ok));
+    const resources = presentation?.resources ?? toolResources(output);
+    const formatted = resources?.length
+        ? { text: ok ? "资源已准备好。" : "资源准备失败。", full: true, bodyTitle: ok ? "资源已就绪" : "资源准备失败" }
+        : formatToolResult(toolName, output, ok);
+    return {
+        kind: ok ? "tool" : "error",
+        toolName,
+        toolPresentation: toolPresentationForSource(toolName),
+        title: presentation?.title ?? toolTitle(toolName, "finished"),
+        bodyTitle: presentation?.bodyTitle ?? formatted.bodyTitle,
+        titleStatus: ok ? "success" : "failure",
+        text: presentation?.text ?? formatted.text,
+        toolDisplay: resources?.length ? undefined : buildToolResultDisplay(toolName, output, ok),
+        format: formatted.format,
+        live: false,
+        previewStyle: formatted.full ? undefined : "summary",
+        summaryMaxLines: formatted.summaryMaxLines,
+        presentationLevel: presentation?.presentationLevel ?? toolPresentationLevel(toolName, output),
+        resources,
+        collapsible: true,
+    };
 }
-function formatToolResultLine(toolName, output, ok) {
-    const formatted = formatToolResult(toolName, output, ok);
-    return { kind: ok ? "tool" : "error", toolName, title: toolTitle(toolName, "finished"), bodyTitle: formatted.bodyTitle, titleStatus: ok ? "success" : "failure", text: formatted.text, format: formatted.format, live: false, previewStyle: formatted.full ? undefined : "summary", summaryMaxLines: formatted.summaryMaxLines, collapsible: true };
+function toolPresentationLevel(toolName, payload) {
+    if (toolName === "image_create")
+        return "primary";
+    if (!isRecord(payload))
+        return "process";
+    const direct = payload.presentationLevel;
+    const ui = isRecord(payload.ui) ? payload.ui.presentationLevel : undefined;
+    const underscoredUi = isRecord(payload._ui) ? payload._ui.presentationLevel : undefined;
+    return [direct, ui, underscoredUi].some((value) => value === "primary") ? "primary" : "process";
+}
+function toolUiMetadata(payload) {
+    if (!isRecord(payload))
+        return undefined;
+    const containers = [payload, payload.output, payload.result].filter(isRecord);
+    for (const container of containers) {
+        if (isRecord(container._ui))
+            return container._ui;
+        if (isRecord(container.ui))
+            return container.ui;
+    }
+    return undefined;
 }
-function toolTitle(toolName, _phase) {
-    const labels = {
-        agent: "子任务",
-        edit: "编辑文件",
-        exec_command: "执行命令",
-        write_stdin: "终端交互",
-        expose_downloads: "文件下载",
-        grep: "搜索文本",
-        image2: "图片生成",
-        image_note: "记录图片说明",
-        list: "列出文件",
-        load_image: "读取图片",
-        plan: "任务计划",
-        read: "读取文件",
-        search: "网络搜索",
-        write: "写入文件",
+function toolResources(payload) {
+    const ui = toolUiMetadata(payload);
+    if (!ui || !Array.isArray(ui.resources))
+        return undefined;
+    return normalizeUiResources(ui.resources);
+}
+function normalizeUiResources(values) {
+    if (!Array.isArray(values))
+        return undefined;
+    const resources = values.flatMap((value) => {
+        if (!isRecord(value))
+            return [];
+        const kind = stringValue(value.kind);
+        const url = stringValue(value.url);
+        if (!kind || !url || !safeResourceUrl(url))
+            return [];
+        return [{
+                kind,
+                url,
+                reference: stringValue(value.reference) ?? canonicalResourceReference(url),
+                label: stringValue(value.label),
+                downloadName: stringValue(value.downloadName),
+                sizeBytes: numberValue(value.sizeBytes),
+                expiresAt: numberValue(value.expiresAt),
+                mimeType: stringValue(value.mimeType),
+                height: clampResourceHeight(numberValue(value.height)),
+            }];
+    });
+    return resources.length > 0 ? resources : undefined;
+}
+function canonicalResourceReference(url) {
+    return url.startsWith("/") ? `sandbox:${url}` : url;
+}
+function clampResourceHeight(value) {
+    return value === undefined ? undefined : Math.max(240, Math.min(1600, Math.round(value)));
+}
+function normalizeToolResultPresentation(value) {
+    if (!isRecord(value))
+        return undefined;
+    const level = value.presentationLevel === "primary" || value.presentationLevel === "process" ? value.presentationLevel : undefined;
+    return {
+        title: stringValue(value.title),
+        bodyTitle: stringValue(value.bodyTitle),
+        text: stringValue(value.text),
+        presentationLevel: level,
+        resources: normalizeUiResources(value.resources),
     };
-    return labels[toolName] ?? toolName;
+}
+function runtimeToolResultPresenter(runtime) {
+    return (toolName, output, ok) => {
+        const support = runtime.pluginSupport;
+        if (!support)
+            return undefined;
+        const sessionId = runtime.engine.snapshot().session?.sessionId;
+        for (const plugin of activeWebRuntimePlugins(support.catalog, support.overrides)) {
+            if (typeof plugin.presentToolResult !== "function")
+                continue;
+            try {
+                const presentation = plugin.presentToolResult({ toolName, output, ok, sessionId });
+                if (presentation !== undefined && presentation !== null)
+                    return presentation;
+            }
+            catch (error) {
+                console.warn(`plugin ${plugin.id} failed to present ${toolName}:`, error);
+            }
+        }
+        return undefined;
+    };
+}
+function safeResourceUrl(value) {
+    return /^(?:https?:\/\/|\/)/i.test(value) && !/^\/\//.test(value);
+}
+function toolTitle(toolName, _phase) {
+    return builtinToolPresentation(toolName)?.label ?? toolName;
 }
 function summarizeToolUse(toolName, input) {
     const purpose = toolUsePurpose(toolName, input);
@@ -2032,65 +2852,304 @@ function toolUsePurpose(toolName, input) {
     const description = typeof input.description === "string" ? input.description.trim() : "";
     if (description)
         return description;
+    const taskId = stringValue(input.task_id);
+    if (toolName === "subagent_output")
+        return taskId ? `读取子任务 ${taskId} 的输出` : "读取子任务输出";
+    if (toolName === "subagent_list")
+        return "查看子任务状态";
+    if (toolName === "subagent_get")
+        return taskId ? `查看子任务 ${taskId}` : "查看子任务";
+    if (toolName === "subagent_stop")
+        return taskId ? `停止子任务 ${taskId}` : "停止子任务";
+    if (toolName === "subagent_resume")
+        return taskId ? `恢复子任务 ${taskId}` : "恢复子任务";
+    if (toolName === "subagent_message")
+        return stringValue(input.target) ? `向 ${stringValue(input.target)} 发送消息` : "发送子任务消息";
     if (toolName === "expose_downloads")
         return "准备网页下载链接";
-    if (toolName === "read" && typeof input.path === "string")
+    if (toolName === "file_read" && typeof input.path === "string")
         return `读取 ${path.basename(input.path)}`;
-    if (toolName === "list" && typeof input.path === "string")
+    if (toolName === "file_list" && typeof input.path === "string")
         return `查看 ${input.path}`;
-    if (toolName === "grep" && typeof input.query === "string")
+    if (toolName === "file_search" && typeof input.query === "string")
         return `搜索 ${input.query}`;
-    if (toolName === "write" && typeof input.path === "string")
+    if (toolName === "file_write" && typeof input.path === "string")
         return `写入 ${path.basename(input.path)}`;
-    if (toolName === "edit" && typeof input.path === "string")
+    if (toolName === "file_edit" && typeof input.path === "string")
         return `修改 ${path.basename(input.path)}`;
     return undefined;
 }
+function mergePresentationLevel(result, started) {
+    return result === "primary" || started === "primary" ? "primary" : result ?? started;
+}
+function mergeToolDisplays(result, started) {
+    if (!result)
+        return started;
+    if (!started)
+        return result;
+    const facts = [...started.facts];
+    for (const fact of result.facts) {
+        const existing = facts.findIndex((item) => item.label === fact.label);
+        if (existing >= 0)
+            facts[existing] = fact;
+        else
+            facts.push(fact);
+    }
+    const subject = result.subject || started.subject;
+    const purpose = result.purpose || started.purpose;
+    return normalizeToolDisplay({
+        subject,
+        purpose,
+        facts,
+        previews: result.previews.length > 0 ? result.previews : started.previews,
+    });
+}
+function normalizeToolDisplay(display) {
+    let subject = display.subject?.trim() || undefined;
+    const purpose = display.purpose?.trim() || undefined;
+    if (subject && purpose && normalizeDisplayText(subject) === normalizeDisplayText(purpose))
+        subject = undefined;
+    const visibleText = new Set([subject, purpose].filter((value) => Boolean(value)).map(normalizeDisplayText));
+    const facts = display.facts.filter((fact) => {
+        const normalized = normalizeDisplayText(fact.value);
+        if (!normalized || visibleText.has(normalized))
+            return false;
+        visibleText.add(normalized);
+        return true;
+    });
+    const previews = display.previews.filter((preview) => {
+        const normalized = normalizeDisplayText(preview.content);
+        if (!normalized || visibleText.has(normalized))
+            return false;
+        visibleText.add(normalized);
+        return true;
+    });
+    return { subject, purpose, facts, previews };
+}
+function normalizeDisplayText(value) {
+    return value.replace(/\s+/gu, " ").trim().toLowerCase();
+}
+function buildToolUseDisplay(toolName, input) {
+    const data = isRecord(input) ? input : {};
+    const purpose = toolUsePurpose(toolName, input);
+    const subject = toolName === "terminal_run" ? undefined : toolDisplaySubject(toolName, data);
+    const facts = [];
+    const previews = [];
+    if (toolName === "terminal_run")
+        pushToolPreview(previews, "命令", "code", data.cmd);
+    else if (toolName === "terminal_control") {
+        pushToolFact(facts, "会话", data.session_id, true);
+        pushToolFact(facts, "输入", data.chars, true);
+    }
+    else if (toolName === "file_search")
+        pushToolFact(facts, "范围", data.path, true);
+    else if (toolName === "image_inspect")
+        pushToolFact(facts, "图片", arrayLabel(data.imageRefs), true);
+    else if (toolName === "image_create") {
+        pushToolFact(facts, "模式", data.mode === "edit" ? "编辑" : "生成");
+        pushToolFact(facts, "名称", data.semanticName);
+    }
+    else if (toolName === "expose_downloads")
+        pushToolFact(facts, "文件", arrayLabel(data.paths), true);
+    else if (toolName === "subagent_message")
+        pushToolFact(facts, "接收方", data.target);
+    else if (toolName.startsWith("subagent_"))
+        pushToolFact(facts, "任务", data.task_id, true);
+    else if (toolName.startsWith("secret_")) {
+        pushToolFact(facts, "密钥", data.key, true);
+        pushToolFact(facts, "用途", data.reason);
+    }
+    else if (toolName === "subagent_run") {
+        pushToolFact(facts, "任务", data.description ?? data.prompt);
+        pushToolFact(facts, "类型", data.subagent_type ?? data.mode);
+    }
+    return normalizeToolDisplay({ subject, purpose, facts, previews });
+}
+function buildToolResultDisplay(toolName, output, ok) {
+    const data = isRecord(output) ? output : {};
+    const facts = [];
+    const previews = [];
+    let subject = toolDisplaySubject(toolName, data);
+    let purpose = stringValue(data.description);
+    if ((toolName === "file_edit" || toolName === "file_write") && isEditToolOutput(data)) {
+        subject = data.path;
+        pushToolPreview(previews, undefined, "diff", compactEditDiff(data));
+    }
+    else if (isExecOutput(data)) {
+        subject = undefined;
+        purpose = stringValue(data.description);
+        pushToolPreview(previews, "命令", "code", data.command);
+        const outputText = [stringValue(data.stdout), stringValue(data.stderr)].filter(Boolean).join("\n");
+        if (outputText)
+            pushToolPreview(previews, data.stderr ? "输出 / 错误" : "输出", "code", outputText);
+        if (data.timed_out && !outputText)
+            pushToolFact(facts, "状态", "命令执行超时", false, "warning");
+        else if ((!ok || (typeof data.exit_code === "number" && data.exit_code !== 0)) && !outputText)
+            pushToolFact(facts, "状态", `退出码 ${data.exit_code ?? "未知"}`, false, "danger");
+    }
+    else if (toolName === "file_search") {
+        subject = stringValue(data.query) || stringValue(data.grepPath) || stringValue(data.path);
+        pushToolPreview(previews, undefined, "list", grepPreview(data));
+    }
+    else if (toolName === "web_search") {
+        subject = stringValue(data.query);
+        pushToolPreview(previews, undefined, "list", searchPreview(data));
+    }
+    else if (toolName === "file_read") {
+        subject = stringValue(data.path);
+        if (numberValue(data.startLine) !== undefined && numberValue(data.endLine) !== undefined)
+            pushToolFact(facts, "范围", `${data.startLine}–${data.endLine} 行`);
+        pushToolPreview(previews, undefined, "code", data.content);
+    }
+    else if (toolName === "file_list") {
+        subject = stringValue(data.path);
+        pushToolPreview(previews, undefined, "list", listPreview(data));
+    }
+    else if (toolName === "image_create") {
+        subject = stringValue(data.semanticName);
+        pushToolFact(facts, "图片", `${numberValue(data.returnedImages) ?? arrayLength(data.images)} 张`);
+        pushToolFact(facts, "尺寸", data.size);
+    }
+    else if (toolName === "image_inspect") {
+        subject = arrayLabel(data.imageRefs);
+    }
+    else if (toolResources(output)?.length) {
+        subject = toolResources(output)?.map((item) => item.label || item.downloadName).filter(Boolean).join("、");
+    }
+    else if (toolName.startsWith("subagent_") || toolName === "subagent_run") {
+        subject = stringValue(data.description) || stringValue(data.task_id) || stringValue(data.agent_id);
+    }
+    else if (toolName === "subagent_message") {
+        subject = stringValue(data.target);
+    }
+    else if (toolName.startsWith("secret_")) {
+        subject = stringValue(data.key);
+        pushToolFact(facts, "密钥", data.key, true);
+        if (toolName === "secret_list")
+            pushToolFact(facts, "数量", `${arrayLength(data.secrets)} 项`);
+    }
+    else if (toolName === "subagent_report") {
+    }
+    else {
+        subject = subject || stringValue(data.path) || stringValue(data.id) || stringValue(data.name);
+    }
+    return normalizeToolDisplay({ subject, purpose, facts, previews });
+}
+function toolDisplaySubject(toolName, data) {
+    if (["file_read", "file_write", "file_edit", "file_list"].includes(toolName))
+        return stringValue(data.path);
+    if (toolName === "terminal_run")
+        return stringValue(data.cmd) || stringValue(data.command);
+    if (toolName === "file_search" || toolName === "web_search")
+        return stringValue(data.query);
+    if (toolName === "image_create")
+        return stringValue(data.semanticName);
+    if (toolName === "subagent_message")
+        return stringValue(data.target);
+    if (toolName.startsWith("subagent_"))
+        return stringValue(data.task_id);
+    return undefined;
+}
+function pushToolPreview(previews, label, kind, value) {
+    if (typeof value !== "string" || !value.trim())
+        return;
+    const content = value.replace(/\r\n/g, "\n").trim();
+    previews.push({ label, kind, content: truncate(content, 1400) });
+}
+function compactEditDiff(output) {
+    const lines = [];
+    for (const hunk of output.patch.slice(0, 3)) {
+        lines.push(`@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`);
+        lines.push(...hunk.lines.slice(0, 14));
+    }
+    return lines.join("\n");
+}
+function grepPreview(data) {
+    if (!Array.isArray(data.matches))
+        return "";
+    return data.matches.slice(0, 5).filter(isRecord).map((match) => {
+        const file = stringValue(match.file) || "";
+        const line = numberValue(match.line);
+        const text = stringValue(match.text) || "";
+        return `${file}${line !== undefined ? `:${line}` : ""}  ${text}`.trim();
+    }).filter(Boolean).join("\n");
+}
+function searchPreview(data) {
+    if (!Array.isArray(data.results))
+        return "";
+    return data.results.slice(0, 4).filter(isRecord).map((result) => {
+        const title = stringValue(result.title) || stringValue(result.url) || "";
+        return title;
+    }).filter(Boolean).join("\n");
+}
+function listPreview(data) {
+    if (!Array.isArray(data.entries))
+        return "";
+    return data.entries.slice(0, 8).filter(isRecord).map((entry) => stringValue(entry.path) || stringValue(entry.name) || "").filter(Boolean).join("\n");
+}
+function pushToolFact(facts, label, value, code = false, tone = "neutral") {
+    const normalized = stringValue(value);
+    if (!normalized || facts.some((fact) => fact.label === label && fact.value === normalized))
+        return;
+    facts.push({ label, value: truncate(normalized, 220), code, tone });
+}
+function stringValue(value) {
+    if (typeof value === "string" && value.trim())
+        return value.replace(/\s+/gu, " ").trim();
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    return undefined;
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function arrayLength(value) {
+    return Array.isArray(value) ? value.length : 0;
+}
+function arrayLabel(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.trim().length > 0).join("、") : undefined;
+}
+function editOperationLabel(operation) {
+    if (operation === "create")
+        return "新建";
+    if (operation === "edit")
+        return "修改";
+    if (operation === "write")
+        return "写入";
+    return operation;
+}
+function formatDuration(durationMs) {
+    return durationMs >= 1000 ? `${(durationMs / 1000).toFixed(durationMs >= 10000 ? 0 : 1)} 秒` : `${durationMs} 毫秒`;
+}
+function taskStatusDisplay(value, ok) {
+    const labels = { pending: "排队中", queued: "排队中", running: "运行中", completed: "已完成", failed: "失败", killed: "已停止", stopped: "已停止" };
+    const status = stringValue(value);
+    return status ? labels[status] ?? status : ok ? "已完成" : "失败";
+}
 function formatToolResult(toolName, output, ok) {
-    if ((toolName === "edit" || toolName === "write") && isRecord(output) && isEditToolOutput(output))
+    if ((toolName === "file_edit" || toolName === "file_write") && isRecord(output) && isEditToolOutput(output))
         return { text: formatEditToolDiff(output, ok), format: "diff", summaryMaxLines: EDIT_TOOL_SUMMARY_MAX_LINES };
     if (isExecOutput(output))
         return { text: formatExecToolResult(output, ok), format: "plain", summaryMaxLines: EXPANDED_SUMMARY_MAX_LINES };
-    if (toolName === "list" && isRecord(output))
+    if (toolName === "file_list" && isRecord(output))
         return { text: formatListToolResult(output, ok) };
-    if (toolName === "read" && isRecord(output))
+    if (toolName === "file_read" && isRecord(output))
         return { text: formatReadToolResult(output, ok) };
-    if (toolName === "grep" && isRecord(output))
+    if (toolName === "file_search" && isRecord(output))
         return { text: formatGrepToolResult(output, ok) };
-    if (toolName === "search" && isRecord(output))
+    if (toolName === "web_search" && isRecord(output))
         return { text: formatWebSearchToolResult(output, ok), summaryMaxLines: EXPANDED_SUMMARY_MAX_LINES };
-    if (toolName === "image2" && isRecord(output))
+    if (toolName === "image_create" && isRecord(output))
         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" && isWebPlanPayload(output))
+    const resources = toolResources(output);
+    if (resources?.length)
+        return { text: ok ? "资源已准备好。" : "资源准备失败。", full: true, bodyTitle: ok ? "资源已就绪" : "资源准备失败" };
+    if (toolName === "plan_update" && 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 };
 }
-function formatExposeDownloadsToolResult(output, ok) {
-    const downloads = extractDownloadEntries(output);
-    if (!ok)
-        return downloads.length ? `下载准备失败\n${formatDownloadEntries(downloads)}` : "下载准备失败";
-    if (!downloads.length)
-        return "文件已准备好，请点击下载。";
-    return `文件已准备好，请点击下载。\n${formatDownloadEntries(downloads)}`;
-}
-function formatDownloadEntries(downloads) {
-    return downloads.map((entry) => {
-        const filename = entry.filename || entry.name || "下载文件";
-        const url = entry.url || (entry.id ? `/api/downloads/${encodeURIComponent(entry.id)}` : "");
-        return url ? `- ${filename}: ${url}` : `- ${filename}`;
-    }).join("\n");
-}
-function extractDownloadEntries(output) {
-    if (!isRecord(output))
-        return [];
-    const candidates = [output.downloads, isRecord(output.output) ? output.output.downloads : undefined, isRecord(output.result) ? output.result.downloads : undefined];
-    const downloads = candidates.find(Array.isArray);
-    return Array.isArray(downloads) ? downloads.filter(isRecord).map((entry) => ({ ...entry })) : [];
-}
 function isEditToolOutput(value) {
     return typeof value.path === "string" && typeof value.operation === "string" && typeof value.replacements === "number" && Array.isArray(value.patch) && value.patch.every(isEditPatchHunk);
 }
@@ -2395,8 +3454,9 @@ function formatUsageTotals(totals) {
 }
 function formatManualCompaction(result) {
     if (!result.changed)
-        return "No context compaction was needed.";
-    return `context compacted: ${result.messages.length} message(s) retained, ${formatNumber(result.charsFreed ?? result.tokensFreed ?? 0)} chars removed`;
+        return "No conversation context available to compact.";
+    const preservedUsers = result.report?.preservedUserMessages ?? result.messages.filter((message) => message.metadata?.compactPreservedUser === true).length;
+    return `context compacted: ${result.messages.length} message(s) in new window, ${preservedUsers} user message(s) preserved`;
 }
 function formatPureCompaction(result) {
     if (!result.changed)
@@ -2406,6 +3466,8 @@ function formatPureCompaction(result) {
 function formatNumber(value) {
     return value === undefined ? "?" : new Intl.NumberFormat("en-US").format(Math.round(value));
 }
+const TERMINAL_OUTPUT_FLUSH_MS = 100;
+const TERMINAL_OUTPUT_EVENT_MAX_CHARS = 40_000;
 const THINKING_SUMMARY_MAX_LINES = 1000;
 const EXPANDED_SUMMARY_MAX_LINES = 1000;
 const EDIT_TOOL_SUMMARY_MAX_LINES = EXPANDED_SUMMARY_MAX_LINES;