neoctl 0.2.17 → 0.2.23

package/dist/model/model-metadata.json

@@ -1,5 +1,5 @@
 {
-  "updatedAt": "2026-05-10",
+  "updatedAt": "2026-08-04",
   "notes": [
     "Static model metadata used for local REPL telemetry. Values are best-effort and should be refreshed when providers update model cards.",
     "MODEL_CONTEXT_WINDOW_TOKENS or OPENAI_CONTEXT_WINDOW_TOKENS overrides contextWindowTokens at runtime.",
@@ -8,7 +8,7 @@
     "reasoningEfforts lists the exact reasoning.effort values the /model command may set; omitted/empty means no supported effort enum is configured for that model."
   ],
   "sources": {
-    "openai-models": "https://platform.openai.com/docs/models",
+    "openai-models": "https://developers.openai.com/api/docs/models",
     "anthropic-models": "https://docs.anthropic.com/en/docs/about-claude/models/overview",
     "anthropic-context-windows": "https://docs.anthropic.com/en/docs/build-with-claude/context-windows",
     "gemini-models": "https://ai.google.dev/gemini-api/docs/models",
@@ -16,10 +16,74 @@
     "anthropic-vision": "https://docs.anthropic.com/en/docs/build-with-claude/vision",
     "mistral-vision": "https://docs.mistral.ai/capabilities/vision",
     "openai-reasoning": "https://developers.openai.com/api/docs/guides/reasoning"
-  },
-  "models": [
-    {
-      "id": "gpt-5.5",
+  },
+  "models": [
+    {
+      "id": "gpt-5.6-sol",
+      "provider": "openai",
+      "modelIds": [
+        "gpt-5.6",
+        "gpt-5.6-sol"
+      ],
+      "contextWindowTokens": 1050000,
+      "maxOutputTokens": 128000,
+      "knowledgeCutoff": "2026-02-16",
+      "reasoning": true,
+      "imageInput": true,
+      "source": "openai-models",
+      "reasoningEfforts": [
+        "none",
+        "low",
+        "medium",
+        "high",
+        "xhigh",
+        "max"
+      ]
+    },
+    {
+      "id": "gpt-5.6-terra",
+      "provider": "openai",
+      "modelIds": [
+        "gpt-5.6-terra"
+      ],
+      "contextWindowTokens": 1050000,
+      "maxOutputTokens": 128000,
+      "knowledgeCutoff": "2026-02-16",
+      "reasoning": true,
+      "imageInput": true,
+      "source": "openai-models",
+      "reasoningEfforts": [
+        "none",
+        "low",
+        "medium",
+        "high",
+        "xhigh",
+        "max"
+      ]
+    },
+    {
+      "id": "gpt-5.6-luna",
+      "provider": "openai",
+      "modelIds": [
+        "gpt-5.6-luna"
+      ],
+      "contextWindowTokens": 1050000,
+      "maxOutputTokens": 128000,
+      "knowledgeCutoff": "2026-02-16",
+      "reasoning": true,
+      "imageInput": true,
+      "source": "openai-models",
+      "reasoningEfforts": [
+        "none",
+        "low",
+        "medium",
+        "high",
+        "xhigh",
+        "max"
+      ]
+    },
+    {
+      "id": "gpt-5.5",
       "provider": "openai",
       "modelIds": [
         "gpt-5.5"

package/dist/repl/commands.js

@@ -195,7 +195,7 @@ export function cliHelpText(binaryName = "neo") {
         `  ${binaryName} -web`,
         `  ${binaryName} -web --port 3001`,
         `  ${binaryName} -model`,
-        `  ${binaryName} -model gpt-5.5 high`,
+        `  ${binaryName} -model gpt-5.6 high`,
         `  ${binaryName} -new`,
         "",
         "Inside the REPL, use the original slash form such as /help or /model.",

package/dist/repl/index.js

@@ -3090,7 +3090,7 @@ const LOGIN_FIELD_DEFINITIONS = {
     openai: [
         { key: "apiKey", label: "API key", envKey: "OPENAI_API_KEY", scope: "provider", required: true, secret: true, placeholder: "sk-..." },
         { key: "baseUrl", label: "Base URL", envKey: "OPENAI_BASE_URL", scope: "provider", placeholder: "https://api.openai.com" },
-        { key: "model", label: "Model", envKey: "OPENAI_MODEL", scope: "provider", required: true, placeholder: "gpt-5.5" },
+        { key: "model", label: "Model", envKey: "OPENAI_MODEL", scope: "provider", required: true, placeholder: "gpt-5.6" },
         { key: "fallbackModel", label: "Fallback model", envKey: "OPENAI_FALLBACK_MODEL", scope: "provider" },
         { key: "endpoint", label: "Endpoint", envKey: "OPENAI_ENDPOINT", scope: "provider", placeholder: "auto", options: ["auto", "responses", "chat"] },
         ...SHARED_LOGIN_FIELDS,
@@ -3430,7 +3430,7 @@ function defaultBaseUrlForLoginProvider(provider) {
 function defaultModelForLoginProvider(provider) {
     if (provider === "anthropic")
         return "claude-sonnet-4-6";
-    return "gpt-5.5";
+    return "gpt-5.6";
 }
 function loginFormViewHeight(state) {
     return state.step === "provider" ? state.providers.length + 3 : LOGIN_FIELD_DEFINITIONS[state.provider].length + 4;

package/dist/tools/builtins/ripgrep-binary.js

@@ -16,7 +16,7 @@ export function resolveBundledRipgrepBinary(env = process.env) {
         if (fs.existsSync(executablePath))
             return { executablePath, platformKey };
     }
-    throw new Error(`Bundled ripgrep binary not found for ${platformKey}. Run npm run vendor:rg before using the grep tool.`);
+    throw new Error(`Required bundled ripgrep binary not found for ${platformKey}. Reinstall neoctl or restore the Git-managed vendor/ripgrep resources.`);
 }
 export function ripgrepPlatformKey() {
     const key = `${process.platform}-${process.arch}`;

package/dist/tools/builtins/ripgrep-binary.js.map

@@ -1 +1 @@
-{"version":3,"file":"ripgrep-binary.js","sourceRoot":"","sources":["../../../src/tools/builtins/ripgrep-binary.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,SAAS,CAAC;AACzB,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAOzC,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAE/D,MAAM,UAAU,2BAA2B,CAAC,MAAyB,OAAO,CAAC,GAAG;IAC9E,MAAM,WAAW,GAAG,kBAAkB,EAAE,CAAC;IACzC,MAAM,UAAU,GAAG,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC;IAClE,MAAM,QAAQ,GAAG,GAAG,CAAC,aAAa,CAAC;IAEnC,IAAI,QAAQ,EAAE,CAAC;QACb,MAAM,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC9C,sBAAsB,CAAC,cAAc,EAAE,eAAe,CAAC,CAAC;QACxD,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,CAAC;IACzC,CAAC;IAED,KAAK,MAAM,IAAI,IAAI,cAAc,CAAC,GAAG,CAAC,EAAE,CAAC;QACvC,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;QACrF,IAAI,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC;YAAE,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,CAAC;IAC5E,CAAC;IAED,MAAM,IAAI,KAAK,CACb,wCAAwC,WAAW,qDAAqD,CACzG,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,kBAAkB;IAChC,MAAM,GAAG,GAAG,GAAG,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;IAClD,QAAQ,GAAG,EAAE,CAAC;QACZ,KAAK,WAAW,CAAC;QACjB,KAAK,aAAa,CAAC;QACnB,KAAK,WAAW,CAAC;QACjB,KAAK,aAAa,CAAC;QACnB,KAAK,YAAY,CAAC;QAClB,KAAK,cAAc;YACjB,OAAO,GAAG,CAAC;QACb;YACE,MAAM,IAAI,KAAK,CAAC,iCAAiC,GAAG,EAAE,CAAC,CAAC;IAC5D,CAAC;AACH,CAAC;AAED,SAAS,cAAc,CAAC,GAAsB;IAC5C,MAAM,eAAe,GAAG,OAAsD,CAAC;IAC/E,MAAM,KAAK,GAAG;QACZ,GAAG,CAAC,gBAAgB;QACpB,OAAO,CAAC,GAAG,EAAE;QACb,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,UAAU,CAAC;QACnC,eAAe,CAAC,aAAa;QAC7B,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC;KAC/B,CAAC,MAAM,CAAC,CAAC,KAAK,EAAmB,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;IAErD,OAAO,CAAC,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;AAC/D,CAAC;AAED,SAAS,sBAAsB,CAAC,cAAsB,EAAE,MAAc;IACpE,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC,EAAE,CAAC;QACnC,MAAM,IAAI,KAAK,CAAC,GAAG,MAAM,wCAAwC,cAAc,EAAE,CAAC,CAAC;IACrF,CAAC;AACH,CAAC"}
+{"version":3,"file":"ripgrep-binary.js","sourceRoot":"","sources":["../../../src/tools/builtins/ripgrep-binary.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,SAAS,CAAC;AACzB,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAOzC,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAE/D,MAAM,UAAU,2BAA2B,CAAC,MAAyB,OAAO,CAAC,GAAG;IAC9E,MAAM,WAAW,GAAG,kBAAkB,EAAE,CAAC;IACzC,MAAM,UAAU,GAAG,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC;IAClE,MAAM,QAAQ,GAAG,GAAG,CAAC,aAAa,CAAC;IAEnC,IAAI,QAAQ,EAAE,CAAC;QACb,MAAM,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC9C,sBAAsB,CAAC,cAAc,EAAE,eAAe,CAAC,CAAC;QACxD,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,CAAC;IACzC,CAAC;IAED,KAAK,MAAM,IAAI,IAAI,cAAc,CAAC,GAAG,CAAC,EAAE,CAAC;QACvC,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;QACrF,IAAI,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC;YAAE,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,CAAC;IAC5E,CAAC;IAED,MAAM,IAAI,KAAK,CACb,iDAAiD,WAAW,yEAAyE,CACtI,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,kBAAkB;IAChC,MAAM,GAAG,GAAG,GAAG,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;IAClD,QAAQ,GAAG,EAAE,CAAC;QACZ,KAAK,WAAW,CAAC;QACjB,KAAK,aAAa,CAAC;QACnB,KAAK,WAAW,CAAC;QACjB,KAAK,aAAa,CAAC;QACnB,KAAK,YAAY,CAAC;QAClB,KAAK,cAAc;YACjB,OAAO,GAAG,CAAC;QACb;YACE,MAAM,IAAI,KAAK,CAAC,iCAAiC,GAAG,EAAE,CAAC,CAAC;IAC5D,CAAC;AACH,CAAC;AAED,SAAS,cAAc,CAAC,GAAsB;IAC5C,MAAM,eAAe,GAAG,OAAsD,CAAC;IAC/E,MAAM,KAAK,GAAG;QACZ,GAAG,CAAC,gBAAgB;QACpB,OAAO,CAAC,GAAG,EAAE;QACb,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,UAAU,CAAC;QACnC,eAAe,CAAC,aAAa;QAC7B,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC;KAC/B,CAAC,MAAM,CAAC,CAAC,KAAK,EAAmB,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;IAErD,OAAO,CAAC,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;AAC/D,CAAC;AAED,SAAS,sBAAsB,CAAC,cAAsB,EAAE,MAAc;IACpE,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC,EAAE,CAAC;QACnC,MAAM,IAAI,KAAK,CAAC,GAAG,MAAM,wCAAwC,cAAc,EAAE,CAAC,CAAC;IACrF,CAAC;AACH,CAAC"}

package/dist/web/html.js

@@ -231,7 +231,7 @@ es.addEventListener('error', () => {
   connection.hidden = false;
   connection.textContent = 'reconnecting…';
 });
-es.addEventListener('sync', (event) => {
+es.addEventListener('sync', (event) => {
   const payload = JSON.parse(event.data);
   state.lines = payload.lines || [];
   state.status = payload.status || state.status;
@@ -245,8 +245,27 @@ es.addEventListener('sync', (event) => {
   if (payload.catalog) state.catalog = payload.catalog;
   if (payload.interactive) state.interactive = payload.interactive;
   updateInputPlaceholder();
-  scheduleRender();
-});
+  scheduleRender();
+});
+es.addEventListener('delta', (event) => {
+  const payload = JSON.parse(event.data);
+  for (const operation of payload.operations || []) {
+    if (operation.type === 'line.append') {
+      if (!state.lines.some((line) => String(line.id) === String(operation.line && operation.line.id))) state.lines.push(operation.line);
+      continue;
+    }
+    const index = state.lines.findIndex((line) => String(line.id) === String(operation.id));
+    if (index < 0) {
+      location.reload();
+      return;
+    }
+    const line = state.lines[index];
+    if (operation.type === 'line.text.append') state.lines[index] = { ...line, text: String(line.text || '') + String(operation.text || '') };
+    else if (operation.type === 'line.patch') state.lines[index] = { ...line, ...(operation.patch || {}) };
+  }
+  if (payload.status) state.status = payload.status;
+  scheduleRender();
+});
 
 function scheduleRender() {
   if (renderPending) return;

package/dist/web/html.js.map

@@ -1 +1 @@
-{"version":3,"file":"html.js","sourceRoot":"","sources":["../../src/web/html.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAq1B1B,CAAC"}
+{"version":3,"file":"html.js","sourceRoot":"","sources":["../../src/web/html.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAw2B1B,CAAC"}

package/dist/web/index.d.ts

@@ -49,6 +49,8 @@ interface UiLine {
     id: number;
     kind: "system" | "user" | "assistant" | "thinking" | "tool" | "error" | "meta";
     text: string;
+    toolName?: string;
+    parentToolName?: string;
     title?: string;
     bodyTitle?: string;
     titleStatus?: "success" | "failure";
@@ -62,6 +64,12 @@ interface UiLine {
 interface UiStatus {
     phase: string;
     detail?: string;
+    currentTool?: {
+        id: string;
+        name: string;
+        input: unknown;
+        startedAt: number;
+    };
     metrics?: ContextMetrics;
     usage?: ModelUsage;
     streamedOutputTokens: number;
@@ -126,9 +134,22 @@ interface WebSetAppPromptPayload {
     content?: string;
     id?: string;
     title?: string;
+    usage?: string;
     source?: string;
     clear?: boolean;
 }
+type WebLineOperation = {
+    type: "line.append";
+    line: UiLine;
+} | {
+    type: "line.text.append";
+    id: number;
+    text: string;
+} | {
+    type: "line.patch";
+    id: number;
+    patch: Partial<UiLine>;
+};
 export declare function runWebServer(argv?: string[], runtimeOptions?: RunWebServerOptions): Promise<void>;
 export declare function createWebRuntime(options?: CreateWebRuntimeOptions): Promise<WebRuntime>;
 export declare class WebRuntimeRouter {
@@ -144,10 +165,15 @@ export declare function createWebRuntimeRouter(options?: WebRuntimeRouterOptions
 export declare class WebRepl {
     private runtime;
     private readonly subscribers;
+    private eventSequence;
+    private pendingDeltaOperations;
+    private pendingDeltaStatus;
+    private pendingDeltaTimer;
     private lineId;
     private assistantLineId;
     private thinkingLineId;
     private finalizedThinkingLineId;
+    private readonly liveToolLineIds;
     private activeAbortController;
     private interruptArmed;
     private lines;
@@ -254,7 +280,7 @@ export declare class WebRepl {
         cancelled: boolean;
     };
     private append;
-    private updateLine;
+    private appendLineText;
     private replaceLineText;
     private replaceLine;
     private setBusy;
@@ -267,11 +293,19 @@ export declare class WebRepl {
     private reduce;
     private finalizeLiveLine;
     private finalizeThinkingLine;
+    private finalizeLiveToolLines;
     private handleEvent;
     private matchesPendingUserImageEcho;
     private handleCommandOrPrompt;
     private runCompaction;
     private send;
+    private broadcastDelta;
+    private queueDeltaOperation;
+    private queueDeltaStatus;
+    private scheduleDeltaFlush;
+    private flushDeltaOperations;
+    private discardPendingDeltaOperations;
     private broadcastSync;
 }
+export declare function compactLineOperations(operations: WebLineOperation[]): WebLineOperation[];
 export {};

package/dist/web/index.js

@@ -249,10 +249,15 @@ function webRuntimeScopeKey(scope) {
 export class WebRepl {
     runtime;
     subscribers = new Set();
+    eventSequence = 0;
+    pendingDeltaOperations = [];
+    pendingDeltaStatus = false;
+    pendingDeltaTimer;
     lineId = 0;
     assistantLineId;
     thinkingLineId;
     finalizedThinkingLineId;
+    liveToolLineIds = new Map();
     activeAbortController;
     interruptArmed = false;
     lines;
@@ -278,16 +283,17 @@ export class WebRepl {
         runtime.engine.onSessionTitleChange(() => this.broadcastSync());
     }
     subscribe(res) {
-        this.subscribers.add(res);
+        const subscriber = { response: res, blocked: false, needsSync: false };
+        this.subscribers.add(subscriber);
         res.writeHead(200, {
             "Content-Type": "text/event-stream; charset=utf-8",
             "Cache-Control": "no-cache, no-transform",
             Connection: "keep-alive",
             "X-Accel-Buffering": "no",
         });
-        this.send(res, "sync", this.snapshot(true));
+        this.send(subscriber, "sync", this.snapshot(true));
         reqKeepAlive(res);
-        res.on("close", () => this.subscribers.delete(res));
+        res.on("close", () => this.subscribers.delete(subscriber));
     }
     snapshot(includeCatalog = false) {
         return {
@@ -394,6 +400,7 @@ export class WebRepl {
         this.assistantLineId = undefined;
         this.thinkingLineId = undefined;
         this.finalizedThinkingLineId = undefined;
+        this.liveToolLineIds.clear();
         if (line)
             this.append(line);
         this.broadcastSync();
@@ -426,8 +433,18 @@ export class WebRepl {
                     content: payload.content ?? "",
                     id: payload.id,
                     title: payload.title,
+                    usage: payload.usage,
                     source: payload.source,
                 });
+            const usage = payload.usage?.trim();
+            if (!shouldClear && usage) {
+                this.append({
+                    kind: "meta",
+                    title: "提示词用法",
+                    text: usage,
+                    format: "markdown",
+                });
+            }
             this.broadcastSync();
             return { ok: true, appPrompt };
         }
@@ -493,15 +510,19 @@ export class WebRepl {
             this.broadcastSync();
         return { ok: true, cancelled: had };
     }
-    append(line) {
+    append(line, streaming = false) {
         const id = ++this.lineId;
-        this.lines.push({ id, ...line });
-        this.broadcastSync();
+        const nextLine = { id, ...line };
+        this.lines.push(nextLine);
+        if (streaming)
+            this.broadcastDelta({ type: "line.append", line: nextLine });
+        else
+            this.broadcastSync();
         return id;
     }
-    updateLine(id, updater) {
-        this.lines = this.lines.map((line) => line.id === id ? { ...line, text: updater(line.text) } : line);
-        this.broadcastSync();
+    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 });
     }
     replaceLineText(id, text) {
         this.lines = this.lines.map((line) => line.id === id ? { ...line, text } : line);
@@ -538,8 +559,9 @@ export class WebRepl {
         this.queuedInput = undefined;
         this.queuedAttachments = undefined;
         this.finalizeForegroundView();
+        this.finalizeLiveToolLines();
         this.busy = false;
-        this.status = { ...this.status, phase: "ready", detail: undefined, inputTokenUpdatedAt: undefined, outputTokenUpdatedAt: undefined, retryCooldownUntil: undefined };
+        this.status = { ...this.status, phase: "ready", detail: undefined, currentTool: undefined, inputTokenUpdatedAt: undefined, outputTokenUpdatedAt: undefined, retryCooldownUntil: undefined };
         this.broadcastSync();
         return runWasActive;
     }
@@ -608,6 +630,7 @@ export class WebRepl {
         if (id === undefined)
             return;
         this.lines = this.lines.map((line) => line.id === id ? { ...line, live: false } : line);
+        this.queueDeltaOperation({ type: "line.patch", id, patch: { live: false } });
     }
     finalizeThinkingLine() {
         const id = this.thinkingLineId;
@@ -617,6 +640,11 @@ export class WebRepl {
         this.finalizedThinkingLineId = id;
         this.thinkingLineId = undefined;
     }
+    finalizeLiveToolLines() {
+        for (const id of this.liveToolLineIds.values())
+            this.finalizeLiveLine(id);
+        this.liveToolLineIds.clear();
+    }
     handleEvent(event) {
         this.reduce(event);
         if (event.type === "message" && this.matchesPendingUserImageEcho(event.message)) {
@@ -624,22 +652,26 @@ export class WebRepl {
             this.broadcastSync();
             return;
         }
-        if (event.type === "state" || event.type === "context.metrics" || event.type === "usage" || event.type === "tool_call.delta" || event.type === "retrying") {
+        if (event.type === "tool_call.delta") {
+            this.queueDeltaStatus();
+            return;
+        }
+        if (event.type === "state" || event.type === "context.metrics" || event.type === "usage" || event.type === "retrying") {
             this.broadcastSync();
             return;
         }
         if (event.type === "assistant.delta") {
             this.finalizeThinkingLine();
-            const id = this.assistantLineId ?? this.append({ kind: "assistant", text: "", live: true });
+            const id = this.assistantLineId ?? this.append({ kind: "assistant", text: "", live: true }, true);
             this.assistantLineId = id;
-            this.updateLine(id, (text) => text + event.text);
+            this.appendLineText(id, event.text);
             return;
         }
         if (event.type === "thinking.delta") {
-            const id = this.thinkingLineId ?? this.finalizedThinkingLineId ?? this.append(thinkingLine("", true));
+            const id = this.thinkingLineId ?? this.finalizedThinkingLineId ?? this.append(thinkingLine("", true), true);
             this.thinkingLineId = id;
             this.finalizedThinkingLineId = undefined;
-            this.updateLine(id, (text) => text + event.text);
+            this.appendLineText(id, event.text);
             return;
         }
         if (event.type === "message") {
@@ -670,7 +702,14 @@ export class WebRepl {
                 return;
             }
             if (event.message.role === "tool_result") {
-                renderToolResultMessage(event.message, (line) => this.append(line));
+                renderToolResultMessage(event.message, (line, toolUseId) => {
+                    const liveLineId = this.liveToolLineIds.get(toolUseId);
+                    if (liveLineId === undefined)
+                        return this.append(line);
+                    this.replaceLine(liveLineId, line);
+                    this.liveToolLineIds.delete(toolUseId);
+                    return liveLineId;
+                });
                 renderMessageImages(event.message, (line) => this.append(line));
                 return;
             }
@@ -691,13 +730,22 @@ export class WebRepl {
         if (event.type === "tool.started") {
             this.finalizeLiveLine(this.assistantLineId);
             this.finalizeThinkingLine();
+            const id = this.append({ ...formatToolUse(event.toolUse), live: true });
+            this.liveToolLineIds.set(event.toolUse.id, id);
             return;
         }
-        if (event.type === "tool.finished")
+        if (event.type === "tool.finished") {
+            const id = this.liveToolLineIds.get(event.toolUse.id);
+            if (id !== undefined) {
+                this.finalizeLiveLine(id);
+                this.liveToolLineIds.delete(event.toolUse.id);
+            }
             return;
+        }
         if (event.type === "terminal") {
             this.finalizeLiveLine(this.assistantLineId);
             this.finalizeThinkingLine();
+            this.finalizeLiveToolLines();
             this.assistantLineId = undefined;
             this.broadcastSync();
             return;
@@ -905,15 +953,86 @@ export class WebRepl {
             this.setStatus({ ...this.status, phase: "ready", detail: undefined, activityTick: this.status.activityTick + 1 });
         }
     }
-    send(res, event, data) {
-        res.write(`event: ${event}\n`);
-        res.write(`data: ${JSON.stringify(data)}\n\n`);
+    send(subscriber, event, data) {
+        if (subscriber.blocked) {
+            subscriber.needsSync = true;
+            return;
+        }
+        const eventId = ++this.eventSequence;
+        const frame = `id: ${eventId}\nevent: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+        if (subscriber.response.write(frame))
+            return;
+        subscriber.blocked = true;
+        subscriber.response.once("drain", () => {
+            subscriber.blocked = false;
+            if (!subscriber.needsSync || subscriber.response.destroyed)
+                return;
+            subscriber.needsSync = false;
+            this.send(subscriber, "sync", this.snapshot(false));
+        });
+    }
+    broadcastDelta(operation) {
+        this.queueDeltaOperation(operation);
+    }
+    queueDeltaOperation(operation) {
+        this.pendingDeltaOperations.push(operation);
+        this.scheduleDeltaFlush();
+    }
+    queueDeltaStatus() {
+        this.pendingDeltaStatus = true;
+        this.scheduleDeltaFlush();
+    }
+    scheduleDeltaFlush() {
+        if (this.pendingDeltaTimer)
+            return;
+        this.pendingDeltaTimer = setTimeout(() => this.flushDeltaOperations(), 25);
+        this.pendingDeltaTimer.unref?.();
+    }
+    flushDeltaOperations() {
+        this.pendingDeltaTimer = undefined;
+        if (this.pendingDeltaOperations.length === 0 && !this.pendingDeltaStatus)
+            return;
+        const operations = compactLineOperations(this.pendingDeltaOperations);
+        this.pendingDeltaOperations = [];
+        this.pendingDeltaStatus = false;
+        const payload = {
+            protocolVersion: 2,
+            sessionId: this.runtime.engine.snapshot().session?.sessionId,
+            operations,
+            status: this.status,
+        };
+        for (const subscriber of this.subscribers)
+            this.send(subscriber, "delta", payload);
+    }
+    discardPendingDeltaOperations() {
+        if (this.pendingDeltaTimer)
+            clearTimeout(this.pendingDeltaTimer);
+        this.pendingDeltaTimer = undefined;
+        this.pendingDeltaOperations = [];
+        this.pendingDeltaStatus = false;
     }
     broadcastSync() {
+        this.discardPendingDeltaOperations();
         const payload = this.snapshot(false);
-        for (const res of this.subscribers)
-            this.send(res, "sync", payload);
+        for (const subscriber of this.subscribers)
+            this.send(subscriber, "sync", payload);
+    }
+}
+export function compactLineOperations(operations) {
+    const compacted = [];
+    for (const operation of operations) {
+        const previous = compacted.at(-1);
+        if (operation.type === "line.text.append" && previous?.type === "line.text.append" && previous.id === operation.id) {
+            previous.text += operation.text;
+            continue;
+        }
+        if (operation.type === "line.patch" && previous?.type === "line.patch" && previous.id === operation.id) {
+            previous.patch = { ...previous.patch, ...operation.patch };
+            continue;
+        }
+        compacted.push(operation.type === "line.patch" ? { ...operation, patch: { ...operation.patch } } : { ...operation });
     }
+    return compacted;
 }
 function reqKeepAlive(res) {
     const timer = setInterval(() => res.write(": keep-alive\n\n"), 25_000);
@@ -1100,7 +1219,7 @@ function pushTextBlock(blocks, text) {
 }
 function reduceStatus(status, event) {
     if (event.type === "state")
-        return { ...status, phase: event.phase, detail: event.detail, 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 };
+        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.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")
@@ -1113,9 +1232,13 @@ function reduceStatus(status, event) {
         return { ...status, phase: "calling_model", streamedOutputTokens: status.streamedOutputTokens + estimateTokens(event.argumentsDelta), outputTokenUpdatedAt: Date.now(), activityTick: status.activityTick + 1 };
     if (event.type === "retrying")
         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 === "terminal")
-        return { ...status, phase: "stopped", detail: event.reason, inputTokenUpdatedAt: undefined, outputTokenUpdatedAt: undefined, retryCooldownUntil: undefined, activityTick: status.activityTick + 1 };
-    if (event.type === "message" || event.type === "tool.started" || event.type === "tool.finished" || event.type === "error")
+        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")
         return { ...status, activityTick: status.activityTick + 1 };
     return status;
 }
@@ -1237,7 +1360,7 @@ const LOGIN_FIELD_DEFINITIONS = {
     openai: [
         { key: "apiKey", label: "API key", envKey: "OPENAI_API_KEY", scope: "provider", required: true, secret: true, placeholder: "sk-..." },
         { key: "baseUrl", label: "Base URL", envKey: "OPENAI_BASE_URL", scope: "provider", placeholder: "https://api.openai.com" },
-        { key: "model", label: "Model", envKey: "OPENAI_MODEL", scope: "provider", required: true, placeholder: "gpt-5.5" },
+        { key: "model", label: "Model", envKey: "OPENAI_MODEL", scope: "provider", required: true, placeholder: "gpt-5.6" },
         { key: "fallbackModel", label: "Fallback model", envKey: "OPENAI_FALLBACK_MODEL", scope: "provider" },
         { key: "endpoint", label: "Endpoint", envKey: "OPENAI_ENDPOINT", scope: "provider", placeholder: "auto", options: ["auto", "responses", "chat"] },
         ...SHARED_LOGIN_FIELDS,
@@ -1292,7 +1415,7 @@ function defaultBaseUrlForLoginProvider(provider) {
 function defaultModelForLoginProvider(provider) {
     if (provider === "anthropic")
         return "claude-sonnet-4-6";
-    return "gpt-5.5";
+    return "gpt-5.6";
 }
 function validateLoginFormPayload(payload) {
     for (const field of LOGIN_FIELD_DEFINITIONS[payload.provider]) {
@@ -1444,6 +1567,7 @@ function renderMessage(message, append, activeAssistantId, options = {}) {
         return false;
     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;
     let rendered = false;
     for (const block of message.blocks) {
         if (block.type === "text") {
@@ -1460,7 +1584,7 @@ function renderMessage(message, append, activeAssistantId, options = {}) {
             const line = imageLineForBlock(message.role, block);
             if (!line)
                 continue;
-            append(line);
+            append({ ...line, parentToolName });
             rendered = true;
         }
         else if (block.type === "thinking") {
@@ -1485,20 +1609,21 @@ function renderToolResultMessage(message, append) {
     for (const block of message.blocks) {
         if (block.type !== "tool_result")
             continue;
-        append(formatToolResultLine(block.name, block.output, block.ok));
+        append(formatToolResultLine(block.name, block.output, block.ok), block.toolUseId);
         rendered = true;
     }
     return rendered;
 }
 function renderMessageImages(message, append) {
     let rendered = false;
+    const parentToolName = typeof message.metadata?.tool === "string" ? message.metadata.tool : undefined;
     for (const block of message.blocks) {
         if (block.type !== "image")
             continue;
         const line = imageLineForBlock(message.role, block);
         if (!line)
             continue;
-        append(line);
+        append({ ...line, parentToolName });
         rendered = true;
     }
     return rendered;
@@ -1586,13 +1711,15 @@ function thinkingLine(text, live = false) {
 }
 function formatToolUse(toolUse) {
     if (toolUse.name === "plan" && isPlanToolPayload(toolUse.input))
-        return { kind: "tool", title: toolTitle(toolUse.name, "running"), bodyTitle: planToolBodyTitle(toolUse.input), text: formatPlanToolPayload(toolUse.input), collapsible: true };
+        return { kind: "tool", toolName: toolUse.name, title: toolTitle(toolUse.name, "running"), bodyTitle: planToolBodyTitle(toolUse.input), text: formatPlanToolPayload(toolUse.input), collapsible: true };
+    if (toolUse.name === "image2")
+        return { kind: "tool", toolName: toolUse.name, title: toolTitle(toolUse.name, "running"), bodyTitle: "图片模型处理中", text: JSON.stringify(toolUse.input ?? {}, null, 2), format: "plain", previewStyle: "summary", collapsible: true };
     const summary = summarizeToolUse(toolUse.name, toolUse.input);
-    return { kind: "tool", title: toolTitle(toolUse.name, "running"), bodyTitle: summary.bodyTitle, text: summary.text, previewStyle: "summary", collapsible: true };
+    return { kind: "tool", toolName: toolUse.name, title: toolTitle(toolUse.name, "running"), bodyTitle: summary.bodyTitle, text: summary.text, previewStyle: "summary", collapsible: true };
 }
 function formatToolResultLine(toolName, output, ok) {
     const formatted = formatToolResult(toolName, output, ok);
-    return { kind: ok ? "tool" : "error", 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 };
+    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 toolTitle(toolName, _phase) {
     const labels = {