newmark-agent 0.5.7 → 0.5.9

package/dist/wsl-agent-host.bundle.cjs

@@ -4281,6 +4281,234 @@ var require_jpeg_js = __commonJS({
   }
 });
 
+// src/core/flow.ts
+var fs6, path7, FlowEngine;
+var init_flow = __esm({
+  "src/core/flow.ts"() {
+    "use strict";
+    fs6 = __toESM(require("fs"));
+    path7 = __toESM(require("path"));
+    FlowEngine = class _FlowEngine {
+      static load(dir, name50) {
+        const p = path7.join(dir, `${name50}.Flow.json`);
+        try {
+          return JSON.parse(fs6.readFileSync(p, "utf-8").replace(/^\uFEFF/, ""));
+        } catch {
+          return null;
+        }
+      }
+      static save(dir, workflow) {
+        const p = path7.join(dir, `${workflow.name}.Flow.json`);
+        fs6.writeFileSync(p, JSON.stringify(workflow, null, 2), "utf-8");
+      }
+      static delete(dir, name50) {
+        const p = path7.join(dir, `${name50}.Flow.json`);
+        if (fs6.existsSync(p)) fs6.unlinkSync(p);
+      }
+      static listAll(dir) {
+        try {
+          return fs6.readdirSync(dir).filter((f3) => f3.endsWith(".Flow.json")).map((f3) => f3.replace(".Flow.json", "")).sort();
+        } catch {
+          return [];
+        }
+      }
+      static describeWorkflow(wf) {
+        const comps = [...wf.components].sort((a3, b2) => a3.id - b2.id);
+        if (comps.length === 0) return "";
+        const parts = [];
+        for (const c3 of comps) {
+          if (c3.type === "dialog") {
+            parts.push(c3.mode.charAt(0).toUpperCase() + c3.mode.slice(1));
+          } else {
+            const label = c3.prompt.replace(/\{#prompt#\}/g, "<i>").replace(/\n/g, " ").slice(0, 22);
+            parts.push(`?${label}?`);
+          }
+        }
+        return parts.join(" \u2192 ");
+      }
+      static validate(wf) {
+        const errors = [];
+        if (!wf.components || wf.components.length === 0) {
+          errors.push({ message: "No components defined." });
+          return errors;
+        }
+        const ids = /* @__PURE__ */ new Set();
+        for (const c3 of wf.components) {
+          if (typeof c3.id === "number") ids.add(c3.id);
+        }
+        const seenIds = /* @__PURE__ */ new Set();
+        for (const c3 of wf.components) {
+          if (seenIds.has(c3.id)) {
+            errors.push({ componentId: c3.id, message: `Duplicate component ID: ${c3.id}` });
+          }
+          seenIds.add(c3.id);
+          if (c3.type === "dialog") {
+            const mode = c3.mode.toLowerCase();
+            if (!["build", "plan", "goal"].includes(mode)) {
+              errors.push({ componentId: c3.id, message: `Invalid dialog mode '${c3.mode}' (must be build/plan/goal)` });
+            }
+          } else if (c3.type === "logic") {
+            if (!ids.has(c3.goto_true)) {
+              errors.push({ componentId: c3.id, message: `goto_true=${c3.goto_true} not found` });
+            }
+            if (!ids.has(c3.goto_false)) {
+              errors.push({ componentId: c3.id, message: `goto_false=${c3.goto_false} not found` });
+            }
+          } else {
+            errors.push({ componentId: c3.id, message: `Unknown component type '${c3.type}'` });
+          }
+        }
+        return errors;
+      }
+      static detectCycles(wf) {
+        const comps = [...wf.components].sort((a3, b2) => a3.id - b2.id);
+        if (comps.length === 0) return [];
+        const idToIdx = /* @__PURE__ */ new Map();
+        comps.forEach((c3, i4) => idToIdx.set(c3.id, i4));
+        const graph = /* @__PURE__ */ new Map();
+        for (let index = 0; index < comps.length; index++) {
+          const c3 = comps[index];
+          graph.set(c3.id, []);
+          if (c3.type === "dialog") {
+            const next = comps[index + 1];
+            if (next) graph.get(c3.id).push(next.id);
+          } else if (c3.type === "logic") {
+            if (idToIdx.has(c3.goto_true)) graph.get(c3.id).push(c3.goto_true);
+            if (idToIdx.has(c3.goto_false)) graph.get(c3.id).push(c3.goto_false);
+          }
+        }
+        const WHITE = 0, GRAY = 1, BLACK = 2;
+        const color2 = /* @__PURE__ */ new Map();
+        for (const c3 of comps) color2.set(c3.id, WHITE);
+        const cycles = [];
+        const dfsPath = [];
+        function dfs(node) {
+          color2.set(node, GRAY);
+          dfsPath.push(node);
+          for (const nb of graph.get(node) || []) {
+            if (!color2.has(nb)) continue;
+            if (color2.get(nb) === GRAY) {
+              const start = dfsPath.indexOf(nb);
+              cycles.push(dfsPath.slice(start));
+            } else if (color2.get(nb) === WHITE) {
+              dfs(nb);
+            }
+          }
+          dfsPath.pop();
+          color2.set(node, BLACK);
+        }
+        for (const c3 of comps) {
+          if (color2.get(c3.id) === WHITE) dfs(c3.id);
+        }
+        const unique2 = [];
+        const seen = /* @__PURE__ */ new Set();
+        for (const cyc of cycles) {
+          const key3 = [...cyc].sort((a3, b2) => a3 - b2).join(",");
+          if (!seen.has(key3)) {
+            seen.add(key3);
+            unique2.push(cyc);
+          }
+        }
+        return unique2;
+      }
+      static getCycleWarnings(wf) {
+        const cycles = _FlowEngine.detectCycles(wf);
+        return cycles.map(
+          (cyc) => `[!] Potential logic cycle in '${wf.name}': components [${cyc.join(", ")}] can form a loop.`
+        );
+      }
+      static findWorkflow(name50, dir) {
+        const names = _FlowEngine.listAll(dir);
+        if (names.length === 0) return null;
+        if (names.includes(name50)) return name50;
+        const nameLower = name50.toLowerCase();
+        for (const n3 of names) {
+          if (n3.toLowerCase() === nameLower) return n3;
+        }
+        for (const n3 of names) {
+          if (n3.toLowerCase().includes(nameLower)) return n3;
+        }
+        return null;
+      }
+      static autoTrigger(text, dir) {
+        const names = _FlowEngine.listAll(dir);
+        const textLower = text.toLowerCase();
+        const results = [];
+        for (const n3 of names) {
+          const nLower = n3.toLowerCase();
+          if (nLower === textLower) {
+            results.push({ name: n3, score: 1 });
+          } else if (textLower.includes(nLower) || nLower.includes(textLower)) {
+            const longer = nLower.length > textLower.length ? nLower : textLower;
+            const shorter = nLower.length > textLower.length ? textLower : nLower;
+            const ratio = shorter.length / Math.max(longer.length, 1);
+            results.push({ name: n3, score: 0.5 + 0.4 * Math.min(ratio, 1) });
+          } else {
+            const words = nLower.split(/[\s_-]+/).filter((w) => w.length > 0);
+            const matchCount = words.filter((w) => textLower.includes(w)).length;
+            if (matchCount > 0) {
+              results.push({ name: n3, score: 0.2 + 0.6 * (matchCount / Math.max(words.length, 1)) });
+            }
+          }
+        }
+        results.sort((a3, b2) => b2.score - a3.score);
+        return results;
+      }
+      static buildDialogPrompt(component, userInput) {
+        const raw = component.prompt;
+        const ui = userInput || "";
+        const hasPlaceholder = raw.includes("{#prompt#}");
+        if (component.mode === "plan" && ui) {
+          if (hasPlaceholder) {
+            return raw.replace(/\{#prompt#\}/g, ui);
+          } else {
+            return `Plan: ${raw}
+User context: ${ui}`;
+          }
+        }
+        return hasPlaceholder ? raw.replace(/\{#prompt#\}/g, ui) : raw;
+      }
+      static generateSequence(workflow, start, input2) {
+        const orderedComponents = [...workflow.components];
+        const seq = [];
+        let cur = start;
+        let count = 0;
+        const max2 = workflow.components.length + 10;
+        while (count < max2) {
+          count++;
+          const comp = workflow.components.find((c3) => c3.id === cur);
+          if (!comp) break;
+          if (comp.type === "dialog") {
+            const expanded = _FlowEngine.buildDialogPrompt(comp, input2);
+            seq.push({ id: comp.id, mode: comp.mode, prompt: expanded, isLogic: false });
+            const index = orderedComponents.findIndex((item) => item.id === comp.id);
+            if (index < 0 || index + 1 >= orderedComponents.length) break;
+            cur = orderedComponents[index + 1].id;
+          } else {
+            seq.push({
+              id: comp.id,
+              prompt: comp.prompt.replace(/\{#prompt#\}/g, input2),
+              isLogic: true,
+              gotoTrue: comp.goto_true,
+              gotoFalse: comp.goto_false
+            });
+            break;
+          }
+        }
+        return seq;
+      }
+      static resolveGoto(workflow, cur, cond) {
+        const comp = workflow.components.find((c3) => c3.id === cur);
+        if (comp?.type === "logic") {
+          return cond ? comp.goto_true : comp.goto_false;
+        }
+        const index = workflow.components.findIndex((component) => component.id === cur);
+        return index >= 0 && index + 1 < workflow.components.length ? workflow.components[index + 1].id : -1;
+      }
+    };
+  }
+});
+
 // node_modules/regenerator-runtime/runtime.js
 var require_runtime = __commonJS({
   "node_modules/regenerator-runtime/runtime.js"(exports2, module2) {
@@ -326027,234 +326255,6 @@ var require_readability = __commonJS({
   }
 });
 
-// src/core/flow.ts
-var fs16, path18, FlowEngine;
-var init_flow = __esm({
-  "src/core/flow.ts"() {
-    "use strict";
-    fs16 = __toESM(require("fs"));
-    path18 = __toESM(require("path"));
-    FlowEngine = class _FlowEngine {
-      static load(dir, name50) {
-        const p = path18.join(dir, `${name50}.Flow.json`);
-        try {
-          return JSON.parse(fs16.readFileSync(p, "utf-8").replace(/^\uFEFF/, ""));
-        } catch {
-          return null;
-        }
-      }
-      static save(dir, workflow) {
-        const p = path18.join(dir, `${workflow.name}.Flow.json`);
-        fs16.writeFileSync(p, JSON.stringify(workflow, null, 2), "utf-8");
-      }
-      static delete(dir, name50) {
-        const p = path18.join(dir, `${name50}.Flow.json`);
-        if (fs16.existsSync(p)) fs16.unlinkSync(p);
-      }
-      static listAll(dir) {
-        try {
-          return fs16.readdirSync(dir).filter((f3) => f3.endsWith(".Flow.json")).map((f3) => f3.replace(".Flow.json", "")).sort();
-        } catch {
-          return [];
-        }
-      }
-      static describeWorkflow(wf) {
-        const comps = [...wf.components].sort((a3, b2) => a3.id - b2.id);
-        if (comps.length === 0) return "";
-        const parts = [];
-        for (const c3 of comps) {
-          if (c3.type === "dialog") {
-            parts.push(c3.mode.charAt(0).toUpperCase() + c3.mode.slice(1));
-          } else {
-            const label = c3.prompt.replace(/\{#prompt#\}/g, "<i>").replace(/\n/g, " ").slice(0, 22);
-            parts.push(`?${label}?`);
-          }
-        }
-        return parts.join(" \u2192 ");
-      }
-      static validate(wf) {
-        const errors = [];
-        if (!wf.components || wf.components.length === 0) {
-          errors.push({ message: "No components defined." });
-          return errors;
-        }
-        const ids = /* @__PURE__ */ new Set();
-        for (const c3 of wf.components) {
-          if (typeof c3.id === "number") ids.add(c3.id);
-        }
-        const seenIds = /* @__PURE__ */ new Set();
-        for (const c3 of wf.components) {
-          if (seenIds.has(c3.id)) {
-            errors.push({ componentId: c3.id, message: `Duplicate component ID: ${c3.id}` });
-          }
-          seenIds.add(c3.id);
-          if (c3.type === "dialog") {
-            const mode = c3.mode.toLowerCase();
-            if (!["build", "plan", "goal"].includes(mode)) {
-              errors.push({ componentId: c3.id, message: `Invalid dialog mode '${c3.mode}' (must be build/plan/goal)` });
-            }
-          } else if (c3.type === "logic") {
-            if (!ids.has(c3.goto_true)) {
-              errors.push({ componentId: c3.id, message: `goto_true=${c3.goto_true} not found` });
-            }
-            if (!ids.has(c3.goto_false)) {
-              errors.push({ componentId: c3.id, message: `goto_false=${c3.goto_false} not found` });
-            }
-          } else {
-            errors.push({ componentId: c3.id, message: `Unknown component type '${c3.type}'` });
-          }
-        }
-        return errors;
-      }
-      static detectCycles(wf) {
-        const comps = [...wf.components].sort((a3, b2) => a3.id - b2.id);
-        if (comps.length === 0) return [];
-        const idToIdx = /* @__PURE__ */ new Map();
-        comps.forEach((c3, i4) => idToIdx.set(c3.id, i4));
-        const graph = /* @__PURE__ */ new Map();
-        for (let index = 0; index < comps.length; index++) {
-          const c3 = comps[index];
-          graph.set(c3.id, []);
-          if (c3.type === "dialog") {
-            const next = comps[index + 1];
-            if (next) graph.get(c3.id).push(next.id);
-          } else if (c3.type === "logic") {
-            if (idToIdx.has(c3.goto_true)) graph.get(c3.id).push(c3.goto_true);
-            if (idToIdx.has(c3.goto_false)) graph.get(c3.id).push(c3.goto_false);
-          }
-        }
-        const WHITE = 0, GRAY = 1, BLACK = 2;
-        const color2 = /* @__PURE__ */ new Map();
-        for (const c3 of comps) color2.set(c3.id, WHITE);
-        const cycles = [];
-        const dfsPath = [];
-        function dfs(node) {
-          color2.set(node, GRAY);
-          dfsPath.push(node);
-          for (const nb of graph.get(node) || []) {
-            if (!color2.has(nb)) continue;
-            if (color2.get(nb) === GRAY) {
-              const start = dfsPath.indexOf(nb);
-              cycles.push(dfsPath.slice(start));
-            } else if (color2.get(nb) === WHITE) {
-              dfs(nb);
-            }
-          }
-          dfsPath.pop();
-          color2.set(node, BLACK);
-        }
-        for (const c3 of comps) {
-          if (color2.get(c3.id) === WHITE) dfs(c3.id);
-        }
-        const unique2 = [];
-        const seen = /* @__PURE__ */ new Set();
-        for (const cyc of cycles) {
-          const key3 = [...cyc].sort((a3, b2) => a3 - b2).join(",");
-          if (!seen.has(key3)) {
-            seen.add(key3);
-            unique2.push(cyc);
-          }
-        }
-        return unique2;
-      }
-      static getCycleWarnings(wf) {
-        const cycles = _FlowEngine.detectCycles(wf);
-        return cycles.map(
-          (cyc) => `[!] Potential logic cycle in '${wf.name}': components [${cyc.join(", ")}] can form a loop.`
-        );
-      }
-      static findWorkflow(name50, dir) {
-        const names = _FlowEngine.listAll(dir);
-        if (names.length === 0) return null;
-        if (names.includes(name50)) return name50;
-        const nameLower = name50.toLowerCase();
-        for (const n3 of names) {
-          if (n3.toLowerCase() === nameLower) return n3;
-        }
-        for (const n3 of names) {
-          if (n3.toLowerCase().includes(nameLower)) return n3;
-        }
-        return null;
-      }
-      static autoTrigger(text, dir) {
-        const names = _FlowEngine.listAll(dir);
-        const textLower = text.toLowerCase();
-        const results = [];
-        for (const n3 of names) {
-          const nLower = n3.toLowerCase();
-          if (nLower === textLower) {
-            results.push({ name: n3, score: 1 });
-          } else if (textLower.includes(nLower) || nLower.includes(textLower)) {
-            const longer = nLower.length > textLower.length ? nLower : textLower;
-            const shorter = nLower.length > textLower.length ? textLower : nLower;
-            const ratio = shorter.length / Math.max(longer.length, 1);
-            results.push({ name: n3, score: 0.5 + 0.4 * Math.min(ratio, 1) });
-          } else {
-            const words = nLower.split(/[\s_-]+/).filter((w) => w.length > 0);
-            const matchCount = words.filter((w) => textLower.includes(w)).length;
-            if (matchCount > 0) {
-              results.push({ name: n3, score: 0.2 + 0.6 * (matchCount / Math.max(words.length, 1)) });
-            }
-          }
-        }
-        results.sort((a3, b2) => b2.score - a3.score);
-        return results;
-      }
-      static buildDialogPrompt(component, userInput) {
-        const raw = component.prompt;
-        const ui = userInput || "";
-        const hasPlaceholder = raw.includes("{#prompt#}");
-        if (component.mode === "plan" && ui) {
-          if (hasPlaceholder) {
-            return raw.replace(/\{#prompt#\}/g, ui);
-          } else {
-            return `Plan: ${raw}
-User context: ${ui}`;
-          }
-        }
-        return hasPlaceholder ? raw.replace(/\{#prompt#\}/g, ui) : raw;
-      }
-      static generateSequence(workflow, start, input2) {
-        const orderedComponents = [...workflow.components];
-        const seq = [];
-        let cur = start;
-        let count = 0;
-        const max2 = workflow.components.length + 10;
-        while (count < max2) {
-          count++;
-          const comp = workflow.components.find((c3) => c3.id === cur);
-          if (!comp) break;
-          if (comp.type === "dialog") {
-            const expanded = _FlowEngine.buildDialogPrompt(comp, input2);
-            seq.push({ id: comp.id, mode: comp.mode, prompt: expanded, isLogic: false });
-            const index = orderedComponents.findIndex((item) => item.id === comp.id);
-            if (index < 0 || index + 1 >= orderedComponents.length) break;
-            cur = orderedComponents[index + 1].id;
-          } else {
-            seq.push({
-              id: comp.id,
-              prompt: comp.prompt.replace(/\{#prompt#\}/g, input2),
-              isLogic: true,
-              gotoTrue: comp.goto_true,
-              gotoFalse: comp.goto_false
-            });
-            break;
-          }
-        }
-        return seq;
-      }
-      static resolveGoto(workflow, cur, cond) {
-        const comp = workflow.components.find((c3) => c3.id === cur);
-        if (comp?.type === "logic") {
-          return cond ? comp.goto_true : comp.goto_false;
-        }
-        const index = workflow.components.findIndex((component) => component.id === cur);
-        return index >= 0 && index + 1 < workflow.components.length ? workflow.components[index + 1].id : -1;
-      }
-    };
-  }
-});
-
 // src/core/agentKernel/agent-loop.ts
 async function runAgentLoop(prompts, config, signal) {
   throwIfAborted3(signal);
@@ -328713,6 +328713,30 @@ function parseProviderSse(raw) {
   }
   return events;
 }
+function assembleCompatibleToolArguments(parts) {
+  const nonEmpty = (parts || []).map(String).filter((part) => part && part !== "null");
+  if (!nonEmpty.length) return "{}";
+  const isJsonObject = (value) => {
+    try {
+      const parsed = JSON.parse(value);
+      return !!parsed && typeof parsed === "object" && !Array.isArray(parsed);
+    } catch {
+      return false;
+    }
+  };
+  const incremental = nonEmpty.join("");
+  if (isJsonObject(incremental)) return incremental;
+  let compatible = "";
+  for (const incoming of nonEmpty) {
+    if (!compatible) compatible = incoming;
+    else if (incoming === compatible) continue;
+    else if (incoming.startsWith(compatible)) compatible = incoming;
+    else if (compatible.startsWith(incoming)) continue;
+    else compatible += incoming;
+  }
+  if (isJsonObject(compatible)) return compatible;
+  return [...nonEmpty].reverse().find(isJsonObject) || compatible;
+}
 function isContentPolicyBlocked(json) {
   const choices = Array.isArray(json.choices) ? json.choices : [];
   const choice = choices[0] || {};
@@ -328941,6 +328965,8 @@ var ChatCompletionsAdapter = class {
     let contentPolicyBlocked = false;
     let emittedContent = false;
     let emittedTool = false;
+    let emittedReasoning = false;
+    let explicitCompletion = false;
     try {
       while (true) {
         const { done, value } = await readProviderStreamChunk(reader, signal);
@@ -328952,7 +328978,10 @@ var ChatCompletionsAdapter = class {
           const trimmed = line.trim();
           if (!trimmed.startsWith("data: ")) continue;
           const data = trimmed.slice(6);
-          if (data === "[DONE]") continue;
+          if (data === "[DONE]") {
+            explicitCompletion = true;
+            continue;
+          }
           let json;
           try {
             json = JSON.parse(data);
@@ -328965,11 +328994,16 @@ var ChatCompletionsAdapter = class {
           }
           if (isContentPolicyBlocked(json)) contentPolicyBlocked = true;
           const choices = Array.isArray(json.choices) ? json.choices : [];
-          const delta = choices[0]?.delta;
+          const choice = choices[0];
+          if (choice?.finish_reason !== void 0 && choice.finish_reason !== null) explicitCompletion = true;
+          const delta = choice?.delta;
           if (!delta) continue;
           if (delta.reasoning_content) {
             const reasoning = this.extractText(delta.reasoning_content);
-            if (reasoning) yield { type: "reasoning.summary.delta", delta: reasoning };
+            if (reasoning) {
+              emittedReasoning = true;
+              yield { type: "reasoning.summary.delta", delta: reasoning };
+            }
           }
           const textDelta = this.extractText(delta.content);
           if (textDelta) {
@@ -329014,13 +329048,17 @@ var ChatCompletionsAdapter = class {
             type: "tool_call.completed",
             id: currentToolCall.id,
             name: currentToolCall.name,
-            arguments: currentToolCall.argumentParts.join("")
+            arguments: assembleCompatibleToolArguments(currentToolCall.argumentParts)
           };
         }
       } else if (!emittedContent && !emittedTool && contentPolicyBlocked) {
         yield { type: "response.failed", error: "[Error] Content policy refusal (content_filter)." };
         return;
       }
+      if (!explicitCompletion && !emittedContent && !emittedTool && !emittedReasoning) {
+        yield { type: "response.failed", error: "[LLM Error] Chat stream ended before an explicit completion." };
+        return;
+      }
       yield { type: "response.completed" };
     } finally {
       reader.releaseLock();
@@ -329217,6 +329255,7 @@ var ResponsesAdapter = class {
               const key3 = `${String(payload.item_id || "")}:${String(payload.summary_index || 0)}`;
               const delta = this.extractText(payload.delta);
               if (delta) {
+                emittedContent = true;
                 reasoningSummaries.set(key3, (reasoningSummaries.get(key3) || "") + delta);
                 yield { type: "reasoning.summary.delta", delta };
               }
@@ -329247,7 +329286,7 @@ var ResponsesAdapter = class {
                 calls.set(key3, {
                   id: String(item.call_id || item.id || key3),
                   name: String(item.name || ""),
-                  arguments: String(item.arguments || ""),
+                  argumentParts: item.arguments ? [String(item.arguments)] : [],
                   emitted: false
                 });
               }
@@ -329255,9 +329294,9 @@ var ResponsesAdapter = class {
             }
             if (eventType === "response.function_call_arguments.delta") {
               const key3 = String(payload.item_id || payload.call_id || payload.output_index || "");
-              const call = calls.get(key3) || { id: String(payload.call_id || key3), name: String(payload.name || ""), arguments: "", emitted: false };
+              const call = calls.get(key3) || { id: String(payload.call_id || key3), name: String(payload.name || ""), argumentParts: [], emitted: false };
               const delta = String(payload.delta || "");
-              call.arguments += delta;
+              if (delta) call.argumentParts.push(delta);
               calls.set(key3, call);
               yield { type: "tool_call.arguments.delta", id: call.id, delta };
               continue;
@@ -329269,19 +329308,20 @@ var ResponsesAdapter = class {
                 const call = calls.get(key3) || {
                   id: String(item.call_id || item.id || key3),
                   name: String(item.name || ""),
-                  arguments: String(item.arguments || ""),
+                  argumentParts: item.arguments ? [String(item.arguments)] : [],
                   emitted: false
                 };
                 call.id = String(item.call_id || call.id);
                 call.name = String(item.name || call.name);
-                call.arguments = typeof item.arguments === "string" ? item.arguments : call.arguments;
+                if (typeof item.arguments === "string" && item.arguments) call.argumentParts.push(item.arguments);
                 if (!call.emitted) {
                   call.emitted = true;
+                  const argumentsJson = assembleCompatibleToolArguments(call.argumentParts);
                   yield { type: "tool_call.started", id: call.id, name: call.name };
-                  if (call.arguments && call.arguments !== "{}") {
-                    yield { type: "tool_call.arguments.delta", id: call.id, delta: call.arguments };
+                  if (argumentsJson !== "{}") {
+                    yield { type: "tool_call.arguments.delta", id: call.id, delta: argumentsJson };
                   }
-                  yield { type: "tool_call.completed", id: call.id, name: call.name, arguments: call.arguments };
+                  yield { type: "tool_call.completed", id: call.id, name: call.name, arguments: argumentsJson };
                 }
                 calls.set(key3, call);
               }
@@ -329306,8 +329346,14 @@ var ResponsesAdapter = class {
       } else if (!completed) {
         yield { type: "response.failed", error: "[LLM Error] Responses stream ended before response.completed." };
       } else if (!emittedContent && calls.size === 0) {
-        yield { type: "response.failed", error: "[Error] Empty Responses stream." };
+        yield { type: "response.failed", error: "[Error] Provider returned an empty response." };
       } else {
+        for (const call of calls.values()) {
+          if (call.emitted) continue;
+          const argumentsJson = assembleCompatibleToolArguments(call.argumentParts);
+          yield { type: "tool_call.started", id: call.id, name: call.name };
+          yield { type: "tool_call.completed", id: call.id, name: call.name, arguments: argumentsJson };
+        }
         yield { type: "response.completed" };
       }
     } finally {
@@ -330186,7 +330232,7 @@ ${responsePath}
    * `provider_adapters_v2` context flag. Request serialization and SSE
    * normalization are delegated to the shared provider adapters while the
    * transport orchestration (loopback node-http, fetch -> node-http fallback,
-   * 120s/30s timeouts) and the 4xx Chat -> Responses downgrade stay here.
+   * cancellation-only streaming and the 4xx Chat -> Responses downgrade) stay here.
    * The emitted request body and StreamToken stream are byte-equivalent to
    * the legacy inlined path.
    */
@@ -330323,9 +330369,9 @@ ${responsePath}
   }
   /**
    * Loopback-aware transport injected into adapter `execute`. Streaming
-   * requests retain the fetch-to-node fallback for transport failures, while
-   * a local deadline is returned directly so one request cannot become a
-   * second Windows fallback request.
+   * requests retain the fetch-to-node fallback for transport failures. They
+   * have no response deadline; only caller cancellation or a concrete
+   * transport/provider failure may end the request.
    */
   buildProviderAdapterTransport() {
     return async (request, signal) => {
@@ -330335,7 +330381,7 @@ ${responsePath}
         const forwardAbort = () => abort.abort(signal?.reason);
         if (signal?.aborted) forwardAbort();
         else signal?.addEventListener("abort", forwardAbort, { once: true });
-        const effectiveTimeout = this.effectiveRequestTimeout(12e4);
+        const effectiveTimeout = 0;
         const timer = effectiveTimeout > 0 ? setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout) : void 0;
         try {
           try {
@@ -330480,7 +330526,7 @@ ${responsePath}
     const forwardAbort = () => abort.abort(signal?.reason);
     if (signal?.aborted) forwardAbort();
     else signal?.addEventListener("abort", forwardAbort, { once: true });
-    const effectiveTimeout = this.effectiveRequestTimeout(12e4);
+    const effectiveTimeout = 0;
     const timeout = effectiveTimeout > 0 ? setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout) : void 0;
     let reader = null;
     try {
@@ -330512,10 +330558,14 @@ ${responsePath}
       }
       const decoder = new TextDecoder();
       let buffer = "";
-      let currentToolCall = null;
+      const toolCalls = /* @__PURE__ */ new Map();
+      const toolCallOrder = [];
+      let syntheticToolIndex = 0;
+      let lastToolIndex = 0;
       let currentReasoningContent = "";
       let contentPolicyBlocked = false;
       let emittedContent = false;
+      let explicitCompletion = false;
       const streamSignal = signal || new AbortController().signal;
       while (true) {
         const { done, value } = await readProviderStreamChunk(reader, streamSignal);
@@ -330527,7 +330577,10 @@ ${responsePath}
           const trimmed = line.trim();
           if (!trimmed.startsWith("data: ")) continue;
           const data = trimmed.slice(6);
-          if (data === "[DONE]") continue;
+          if (data === "[DONE]") {
+            explicitCompletion = true;
+            continue;
+          }
           try {
             const json = JSON.parse(data);
             if (json.usage) yield { type: "usage", text: "", usage: extractProviderUsage(json) };
@@ -330545,24 +330598,44 @@ ${responsePath}
             }
             if (delta.tool_calls) {
               for (const tc of delta.tool_calls) {
-                if (tc.id) {
-                  if (currentToolCall) {
-                    yield { type: "tool_call", text: "", toolCall: currentToolCall, reasoningContent: currentReasoningContent || void 0 };
-                  }
-                  currentToolCall = { id: tc.id, name: tc.function?.name || "", arguments: tc.function?.arguments || "" };
-                } else if (tc.function?.arguments && currentToolCall) {
-                  currentToolCall.arguments += tc.function.arguments;
+                const rawIndex = Number(tc.index);
+                const index = Number.isInteger(rawIndex) && rawIndex >= 0 ? rawIndex : tc.id ? syntheticToolIndex++ : lastToolIndex;
+                lastToolIndex = index;
+                let call = toolCalls.get(index);
+                if (!call && (tc.id || tc.function?.name)) {
+                  call = { id: tc.id || "", name: tc.function?.name || "", argumentParts: [] };
+                  toolCalls.set(index, call);
+                  toolCallOrder.push(index);
                 }
+                if (!call) continue;
+                if (tc.id && !call.id) call.id = tc.id;
+                if (tc.function?.name && !call.name) call.name = tc.function.name;
+                if (tc.function?.arguments) call.argumentParts.push(tc.function.arguments);
               }
             }
           } catch {
           }
         }
       }
-      if (currentToolCall && currentToolCall.arguments) {
-        yield { type: "tool_call", text: "", toolCall: currentToolCall, reasoningContent: currentReasoningContent || void 0 };
+      if (toolCallOrder.length) {
+        for (const index of toolCallOrder) {
+          const call = toolCalls.get(index);
+          if (!call) continue;
+          yield {
+            type: "tool_call",
+            text: "",
+            toolCall: {
+              id: call.id,
+              name: call.name,
+              arguments: assembleCompatibleToolArguments(call.argumentParts)
+            },
+            reasoningContent: currentReasoningContent || void 0
+          };
+        }
       } else if (!emittedContent && contentPolicyBlocked) {
         yield { type: "text", text: "[Error] Content policy refusal (content_filter)." };
+      } else if (!explicitCompletion && !emittedContent && !currentReasoningContent) {
+        yield { type: "text", text: "[LLM Error] GitHub Models stream ended before an explicit completion." };
       }
     } finally {
       reader?.releaseLock();
@@ -331249,8 +331322,8 @@ async function fuzzyDiscoverWithoutGuide(input2, explicit, preferredModels = [])
 }
 
 // src/tools/index.ts
-var fs14 = __toESM(require("fs"));
-var path16 = __toESM(require("path"));
+var fs15 = __toESM(require("fs"));
+var path17 = __toESM(require("path"));
 var crypto8 = __toESM(require("crypto"));
 var import_url2 = require("url");
 
@@ -331594,7 +331667,8 @@ var MemoryLabManager = class {
       "Use memory_lab_read to inspect index.json before deciding what memory is relevant.",
       "Use memory_lab_query for bounded task-relevant retrieval; do not inject the complete index when a focused query is sufficient.",
       "Use memory_lab_read with component/name/slug to read a component core markdown file.",
-      "Use memory_lab_update only when the user asks to create or update durable memory, passing name, description, tags, optional tagPaths, content, and optional kind=file|folder.",
+      "Use memory_lab_update only when the user asks to create or update durable memory. Create with name, tags, and content; patch an existing component with component plus only changed fields.",
+      "For small body edits prefer contentAppend or oldText/newText over resending the complete content.",
       "For an existing component, pass expectedUpdatedAt from the latest read/query result. A stale update is rejected instead of overwriting newer memory.",
       "Use memory_lab_delete only when the user explicitly asks to forget/remove durable memory. Delete moves the prior revision to Memory Lab/archive and records a policy event.",
       "Every mutation should include a concise reason and source. ADD, UPDATE, and DELETE decisions are append-only in policy.jsonl and are recoverable from archive.",
@@ -331702,6 +331776,39 @@ var MemoryLabManager = class {
       source: String(input2.source || "").trim()
     };
   }
+  preparePatch(input2) {
+    const selector2 = String(input2.component || "").trim();
+    if (!selector2) throw new Error("Memory component is required for a patch.");
+    const current = this.read(selector2);
+    if (!current.ok || !current.component) throw new Error(current.error || `Memory component not found: ${selector2}`);
+    const existing = current.component.meta;
+    const oldContent = current.component.content;
+    let content = input2.content !== void 0 ? String(input2.content) : oldContent;
+    if (input2.contentAppend !== void 0) content = `${oldContent}${String(input2.contentAppend)}`;
+    if (input2.oldText !== void 0) {
+      const oldText = String(input2.oldText);
+      if (!oldText) throw new Error("oldText must not be empty.");
+      const matches = oldContent.split(oldText).length - 1;
+      if (!matches) throw new Error("oldText was not found in the Memory Lab component.");
+      if (matches > 1 && input2.replaceAll !== true) throw new Error(`oldText matched ${matches} places; pass replaceAll=true or a unique fragment.`);
+      content = input2.replaceAll === true ? oldContent.split(oldText).join(String(input2.newText || "")) : oldContent.replace(oldText, String(input2.newText || ""));
+    }
+    const name50 = input2.name === void 0 ? existing.name : String(input2.name);
+    if (this.slugify(name50) !== current.component.slug) {
+      throw new Error("Renaming a Memory Lab component is not supported by incremental patch; create the new component then delete the old one.");
+    }
+    return this.prepareUpdate({
+      name: name50,
+      description: input2.description === void 0 ? existing.description : String(input2.description),
+      tags: input2.tags === void 0 ? existing.tags : input2.tags,
+      tagPaths: input2.tagPaths === void 0 ? existing.tagPaths : input2.tagPaths,
+      content,
+      kind: input2.kind === void 0 ? existing.kind : input2.kind,
+      expectedUpdatedAt: String(input2.expectedUpdatedAt || existing.updatedAt),
+      reason: input2.reason,
+      source: input2.source
+    });
+  }
   update(prepared) {
     this.ensure();
     const index = this.loadIndex();
@@ -332248,20 +332355,23 @@ ${JSON.stringify(payload, null, 2)}`;
   }
 };
 
+// src/tools/index.ts
+init_flow();
+
 // src/core/compat.ts
-var fs6 = __toESM(require("fs"));
-var path7 = __toESM(require("path"));
+var fs7 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
 var os2 = __toESM(require("os"));
 function readJson(filePath) {
   try {
-    return JSON.parse(fs6.readFileSync(filePath, "utf-8").replace(/^\uFEFF/, ""));
+    return JSON.parse(fs7.readFileSync(filePath, "utf-8").replace(/^\uFEFF/, ""));
   } catch {
     return null;
   }
 }
 function readJsonLoose(filePath) {
   try {
-    const withoutBom = fs6.readFileSync(filePath, "utf-8").replace(/^\uFEFF/, "");
+    const withoutBom = fs7.readFileSync(filePath, "utf-8").replace(/^\uFEFF/, "");
     const withoutComments = withoutBom.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|\s)\/\/.*$/gm, "$1");
     return JSON.parse(withoutComments);
   } catch {
@@ -332342,7 +332452,7 @@ function normalizeToolResult(output, metadata) {
   return { ok: !error, output, error, metadata };
 }
 function componentPaths(root2, value) {
-  return asStringArray(value).map((item) => path7.resolve(root2, item));
+  return asStringArray(value).map((item) => path8.resolve(root2, item));
 }
 function manifestComponentPaths(root2, manifest, ...keys) {
   for (const key3 of keys) {
@@ -332353,7 +332463,7 @@ function manifestComponentPaths(root2, manifest, ...keys) {
 function discoverComponentFiles(root2, relativeDirs, extension, maxDepth = 2) {
   const files = [];
   for (const dir of relativeDirs) {
-    files.push(...listFilesRecursive(path7.join(root2, dir), extension, maxDepth));
+    files.push(...listFilesRecursive(path8.join(root2, dir), extension, maxDepth));
   }
   return Array.from(new Set(files)).sort();
 }
@@ -332378,12 +332488,12 @@ function collectMcpServers(...values) {
 function defaultComponentWarnings(kind, components) {
   const warnings = [];
   for (const item of components) {
-    if (path7.isAbsolute(item) && !fs6.existsSync(item)) warnings.push(`${kind} path does not exist: ${item}`);
+    if (path8.isAbsolute(item) && !fs7.existsSync(item)) warnings.push(`${kind} path does not exist: ${item}`);
   }
   return warnings;
 }
 function normalizeCodexPlugin(root2, manifest) {
-  const name50 = asString(manifest.name) || path7.basename(root2);
+  const name50 = asString(manifest.name) || path8.basename(root2);
   const components = {
     skills: manifestComponentPaths(root2, manifest, "skills"),
     agents: manifestComponentPaths(root2, manifest, "agents"),
@@ -332414,7 +332524,7 @@ function normalizeCodexPlugin(root2, manifest) {
   };
 }
 function normalizeClaudePlugin(root2, manifest) {
-  const name50 = asString(manifest.name) || path7.basename(root2);
+  const name50 = asString(manifest.name) || path8.basename(root2);
   const experimental = nestedRecord(manifest.experimental);
   const components = {
     skills: manifestComponentPaths(root2, manifest, "skills"),
@@ -332452,7 +332562,7 @@ function normalizeClaudePlugin(root2, manifest) {
   };
 }
 function normalizeNewmarkPlugin(root2, manifest) {
-  const name50 = asString(manifest.name) || path7.basename(root2);
+  const name50 = asString(manifest.name) || path8.basename(root2);
   return {
     id: `newmark:${name50}`,
     ecosystem: "newmark",
@@ -332481,7 +332591,7 @@ function findPluginRoots(root2, maxDepth = 5) {
     if (depth > maxDepth) return;
     let entries;
     try {
-      entries = fs6.readdirSync(dir, { withFileTypes: true });
+      entries = fs7.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -332490,7 +332600,7 @@ function findPluginRoots(root2, maxDepth = 5) {
     }
     for (const entry of entries) {
       if (!entry.isDirectory() || skip.has(entry.name) || entry.name.startsWith("release.locked-")) continue;
-      walk4(path7.join(dir, entry.name), depth + 1);
+      walk4(path8.join(dir, entry.name), depth + 1);
     }
   };
   walk4(root2, 0);
@@ -332499,20 +332609,20 @@ function findPluginRoots(root2, maxDepth = 5) {
 function discoverPluginManifests(root2) {
   const manifests = [];
   for (const pluginRoot of findPluginRoots(root2)) {
-    const codexPath = path7.join(pluginRoot, ".codex-plugin", "plugin.json");
-    const claudePath = path7.join(pluginRoot, ".claude-plugin", "plugin.json");
-    const newmarkPath = path7.join(pluginRoot, ".newmark-plugin", "plugin.json");
-    const codex = fs6.existsSync(codexPath) ? readJson(codexPath) : null;
-    const claude = fs6.existsSync(claudePath) ? readJson(claudePath) : null;
-    const newmark = fs6.existsSync(newmarkPath) ? readJson(newmarkPath) : null;
+    const codexPath = path8.join(pluginRoot, ".codex-plugin", "plugin.json");
+    const claudePath = path8.join(pluginRoot, ".claude-plugin", "plugin.json");
+    const newmarkPath = path8.join(pluginRoot, ".newmark-plugin", "plugin.json");
+    const codex = fs7.existsSync(codexPath) ? readJson(codexPath) : null;
+    const claude = fs7.existsSync(claudePath) ? readJson(claudePath) : null;
+    const newmark = fs7.existsSync(newmarkPath) ? readJson(newmarkPath) : null;
     if (codex && typeof codex === "object") manifests.push(normalizeCodexPlugin(pluginRoot, codex));
     if (claude && typeof claude === "object") manifests.push(normalizeClaudePlugin(pluginRoot, claude));
     if (newmark && typeof newmark === "object") manifests.push(normalizeNewmarkPlugin(pluginRoot, newmark));
   }
   const projectOpencode = readOpenCodeManifest(root2, "project");
   if (projectOpencode) manifests.push(projectOpencode);
-  const userOpenCodeRoot = path7.join(os2.homedir(), ".config", "opencode");
-  if (path7.resolve(userOpenCodeRoot) !== path7.resolve(path7.join(root2, ".opencode"))) {
+  const userOpenCodeRoot = path8.join(os2.homedir(), ".config", "opencode");
+  if (path8.resolve(userOpenCodeRoot) !== path8.resolve(path8.join(root2, ".opencode"))) {
     const userOpenCode = readOpenCodeManifest(userOpenCodeRoot, "user");
     if (userOpenCode) manifests.push(userOpenCode);
   }
@@ -332520,20 +332630,20 @@ function discoverPluginManifests(root2) {
 }
 function readOpenCodeConfig(root2) {
   const candidates = [
-    path7.join(root2, "opencode.json"),
-    path7.join(root2, "opencode.jsonc"),
-    path7.join(root2, ".opencode", "opencode.json"),
-    path7.join(root2, ".opencode", "opencode.jsonc")
+    path8.join(root2, "opencode.json"),
+    path8.join(root2, "opencode.jsonc"),
+    path8.join(root2, ".opencode", "opencode.json"),
+    path8.join(root2, ".opencode", "opencode.jsonc")
   ];
   for (const filePath of candidates) {
-    if (fs6.existsSync(filePath)) return { path: filePath, value: readJsonLoose(filePath) };
+    if (fs7.existsSync(filePath)) return { path: filePath, value: readJsonLoose(filePath) };
   }
   return null;
 }
 function readOpenCodeManifest(root2, scope) {
-  const localRoot = scope === "project" ? path7.join(root2, ".opencode") : root2;
-  const opencodeToolsDir = path7.join(localRoot, "tools");
-  const opencodePluginsDir = path7.join(localRoot, "plugins");
+  const localRoot = scope === "project" ? path8.join(root2, ".opencode") : root2;
+  const opencodeToolsDir = path8.join(localRoot, "tools");
+  const opencodePluginsDir = path8.join(localRoot, "plugins");
   const tools = listCodeFiles(opencodeToolsDir);
   const pluginFiles = listCodeFiles(opencodePluginsDir);
   const config = readOpenCodeConfig(root2);
@@ -332574,18 +332684,18 @@ function readOpenCodeManifest(root2, scope) {
 }
 function discoverOpenCodeInstructionFiles(projectRoot, localRoot) {
   const candidates = [
-    path7.join(projectRoot, "AGENTS.md"),
-    path7.join(projectRoot, ".opencode", "instructions.md"),
-    path7.join(projectRoot, ".opencode", "AGENTS.md"),
-    path7.join(localRoot, "instructions.md"),
-    path7.join(localRoot, "AGENTS.md")
+    path8.join(projectRoot, "AGENTS.md"),
+    path8.join(projectRoot, ".opencode", "instructions.md"),
+    path8.join(projectRoot, ".opencode", "AGENTS.md"),
+    path8.join(localRoot, "instructions.md"),
+    path8.join(localRoot, "AGENTS.md")
   ];
-  return Array.from(new Set(candidates.filter((filePath) => fs6.existsSync(filePath)))).sort();
+  return Array.from(new Set(candidates.filter((filePath) => fs7.existsSync(filePath)))).sort();
 }
 function dedupeManifests(manifests) {
   const seen = /* @__PURE__ */ new Set();
   return manifests.filter((item) => {
-    const key3 = `${item.id}:${path7.resolve(item.root)}`;
+    const key3 = `${item.id}:${path8.resolve(item.root)}`;
     if (seen.has(key3)) return false;
     seen.add(key3);
     return true;
@@ -332593,14 +332703,14 @@ function dedupeManifests(manifests) {
 }
 function listCodeFiles(dir) {
   try {
-    return fs6.readdirSync(dir, { withFileTypes: true }).filter((e3) => e3.isFile() && /\.(?:c?js|mjs|ts)$/.test(e3.name)).map((e3) => path7.join(dir, e3.name)).sort();
+    return fs7.readdirSync(dir, { withFileTypes: true }).filter((e3) => e3.isFile() && /\.(?:c?js|mjs|ts)$/.test(e3.name)).map((e3) => path8.join(dir, e3.name)).sort();
   } catch {
     return [];
   }
 }
 function parseFrontmatterMarkdown(filePath) {
   try {
-    const content = fs6.readFileSync(filePath, "utf-8").replace(/^\uFEFF/, "");
+    const content = fs7.readFileSync(filePath, "utf-8").replace(/^\uFEFF/, "");
     const match = content.match(/^---\s*([\s\S]*?)\s*---\s*/);
     if (!match) return { metadata: {}, body: content };
     const metadata = {};
@@ -332629,7 +332739,7 @@ function parseMetadataValue(raw) {
 function parseSimpleToml(filePath) {
   try {
     const metadata = {};
-    const content = fs6.readFileSync(filePath, "utf-8").replace(/^\uFEFF/, "");
+    const content = fs7.readFileSync(filePath, "utf-8").replace(/^\uFEFF/, "");
     const multiline = null;
     if (multiline) return metadata;
     const lines = content.split(/\r?\n/);
@@ -332663,7 +332773,7 @@ function parseSimpleToml(filePath) {
   }
 }
 function agentPresetFromMetadata(filePath, ecosystem, metadata, body = "") {
-  const name50 = asString(metadata.name) || path7.basename(filePath).replace(/\.(?:toml|md)$/i, "");
+  const name50 = asString(metadata.name) || path8.basename(filePath).replace(/\.(?:toml|md)$/i, "");
   const description = asString(metadata.description);
   const instructions = asString(metadata.developer_instructions || metadata.instructions || metadata.prompt) || body.trim();
   if (!name50 || !description) return null;
@@ -332691,12 +332801,12 @@ function listFilesRecursive(root2, extension, maxDepth = 4) {
     if (depth > maxDepth) return;
     let entries;
     try {
-      entries = fs6.readdirSync(dir, { withFileTypes: true });
+      entries = fs7.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = path7.join(dir, entry.name);
+      const full = path8.join(dir, entry.name);
       if (entry.isFile() && extension.test(entry.name)) results.push(full);
       if (entry.isDirectory() && !entry.name.startsWith(".git") && entry.name !== "node_modules") walk4(full, depth + 1);
     }
@@ -332707,10 +332817,10 @@ function listFilesRecursive(root2, extension, maxDepth = 4) {
 function discoverAgentPresets(root2) {
   const presets = [];
   const codexDirs = [
-    path7.join(root2, ".codex", "agents"),
-    path7.join(root2, ".agents", "agents"),
-    path7.join(os2.homedir(), ".codex", "agents"),
-    path7.join(os2.homedir(), ".agents", "agents")
+    path8.join(root2, ".codex", "agents"),
+    path8.join(root2, ".agents", "agents"),
+    path8.join(os2.homedir(), ".codex", "agents"),
+    path8.join(os2.homedir(), ".agents", "agents")
   ];
   for (const dir of codexDirs) {
     for (const filePath of listFilesRecursive(dir, /\.toml$/i, 1)) {
@@ -332719,14 +332829,14 @@ function discoverAgentPresets(root2) {
     }
   }
   const claudeDirs = [
-    path7.join(root2, ".claude", "agents"),
-    path7.join(os2.homedir(), ".claude", "agents"),
-    path7.join(os2.homedir(), ".config", "opencode", "agents")
+    path8.join(root2, ".claude", "agents"),
+    path8.join(os2.homedir(), ".claude", "agents"),
+    path8.join(os2.homedir(), ".config", "opencode", "agents")
   ];
   for (const dir of claudeDirs) {
     for (const filePath of listFilesRecursive(dir, /\.md$/i, 1)) {
       const parsed = parseFrontmatterMarkdown(filePath);
-      const ecosystem = filePath.includes(`${path7.sep}.config${path7.sep}opencode${path7.sep}`) ? "opencode" : "claude-code";
+      const ecosystem = filePath.includes(`${path8.sep}.config${path8.sep}opencode${path8.sep}`) ? "opencode" : "claude-code";
       const preset = agentPresetFromMetadata(filePath, ecosystem, parsed.metadata, parsed.body);
       if (preset) presets.push(preset);
     }
@@ -332763,15 +332873,15 @@ function findAgentPreset(root2, selector2) {
       preset.id,
       preset.name,
       `${preset.ecosystem}:${preset.name}`,
-      path7.basename(preset.path)
+      path8.basename(preset.path)
     ].map((value) => String(value || "").toLowerCase());
-    return keys.includes(normalized) || path7.resolve(preset.path).toLowerCase() === path7.resolve(wanted).toLowerCase();
+    return keys.includes(normalized) || path8.resolve(preset.path).toLowerCase() === path8.resolve(wanted).toLowerCase();
   }) || null;
 }
 
 // src/tools/terminalTakeover.ts
-var fs7 = __toESM(require("fs"));
-var path8 = __toESM(require("path"));
+var fs8 = __toESM(require("fs"));
+var path9 = __toESM(require("path"));
 var import_child_process2 = require("child_process");
 var import_crypto5 = require("crypto");
 var ROOT_TERMINAL_ACTOR_ID = "00000000-0000-4000-8000-000000000001";
@@ -332786,7 +332896,7 @@ function isoNow() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
 function canonicalPersistenceRoot(root2) {
-  const resolved = path8.resolve(root2 || process.cwd());
+  const resolved = path9.resolve(root2 || process.cwd());
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function portableWorkspacePath(input2) {
@@ -332795,7 +332905,7 @@ function portableWorkspacePath(input2) {
   if (wsl) return `${wsl[1].toLowerCase()}:/${String(wsl[2] || "").replace(/^\/+|\/+$/g, "")}`.replace(/\/$/, "");
   const drive = /^([a-zA-Z]):(?:\/(.*))?$/.exec(raw);
   if (drive) return `${drive[1].toLowerCase()}:/${String(drive[2] || "").replace(/^\/+|\/+$/g, "")}`.replace(/\/$/, "");
-  const resolved = path8.resolve(raw).replace(/\\/g, "/").replace(/\/+$/g, "");
+  const resolved = path9.resolve(raw).replace(/\\/g, "/").replace(/\/+$/g, "");
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function terminalTakeoverWorkspaceId(workspacePath) {
@@ -332890,12 +333000,12 @@ function nodePtyHasConptyDll() {
   if (process.platform !== "win32") return false;
   try {
     const packageJson = require.resolve("node-pty/package.json");
-    const packageRoot = path8.dirname(packageJson);
+    const packageRoot = path9.dirname(packageJson);
     return [
-      path8.join(packageRoot, "build", "Release", "conpty", "conpty.dll"),
-      path8.join(packageRoot, "build", "Debug", "conpty", "conpty.dll"),
-      path8.join(packageRoot, "prebuilds", `${process.platform}-${process.arch}`, "conpty", "conpty.dll")
-    ].some((candidate) => fs7.existsSync(candidate));
+      path9.join(packageRoot, "build", "Release", "conpty", "conpty.dll"),
+      path9.join(packageRoot, "build", "Debug", "conpty", "conpty.dll"),
+      path9.join(packageRoot, "prebuilds", `${process.platform}-${process.arch}`, "conpty", "conpty.dll")
+    ].some((candidate) => fs8.existsSync(candidate));
   } catch {
     return false;
   }
@@ -333128,7 +333238,7 @@ function spawnTakeoverPty(shell, cwd, env, cols, rows) {
   };
 }
 function persistencePath(root2) {
-  return path8.join(root2, "Terminal", "Takeover.json");
+  return path9.join(root2, "Terminal", "Takeover.json");
 }
 function validPersistedRecord(input2) {
   if (!input2 || typeof input2 !== "object") return null;
@@ -333169,7 +333279,7 @@ function ensurePersistenceLoaded(rootRaw) {
   if (loaded) return loaded;
   const records = /* @__PURE__ */ new Map();
   try {
-    const parsed = JSON.parse(fs7.readFileSync(persistencePath(root2), "utf-8"));
+    const parsed = JSON.parse(fs8.readFileSync(persistencePath(root2), "utf-8"));
     if (Array.isArray(parsed.records)) {
       for (const input2 of parsed.records) {
         const record = validPersistedRecord(input2);
@@ -333187,19 +333297,19 @@ function persistEndedRecords(rootRaw) {
   const output = { version: 1, updatedAt: isoNow(), records };
   const filePath = persistencePath(root2);
   const tempPath = `${filePath}.tmp-${process.pid}-${(0, import_crypto5.randomUUID)()}`;
-  fs7.mkdirSync(path8.dirname(filePath), { recursive: true });
-  const fd = fs7.openSync(tempPath, "w");
+  fs8.mkdirSync(path9.dirname(filePath), { recursive: true });
+  const fd = fs8.openSync(tempPath, "w");
   try {
-    fs7.writeFileSync(fd, JSON.stringify(output, null, 2), "utf-8");
-    fs7.fsyncSync(fd);
+    fs8.writeFileSync(fd, JSON.stringify(output, null, 2), "utf-8");
+    fs8.fsyncSync(fd);
   } finally {
-    fs7.closeSync(fd);
+    fs8.closeSync(fd);
   }
   try {
-    fs7.renameSync(tempPath, filePath);
+    fs8.renameSync(tempPath, filePath);
   } catch (error) {
     try {
-      fs7.rmSync(tempPath, { force: true });
+      fs8.rmSync(tempPath, { force: true });
     } catch {
     }
     throw error;
@@ -333432,8 +333542,8 @@ function runTerminalTakeover(input2) {
 }
 
 // src/tools/computerUse.ts
-var fs8 = __toESM(require("fs"));
-var path9 = __toESM(require("path"));
+var fs9 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
 var crypto6 = __toESM(require("crypto"));
 var os3 = __toESM(require("os"));
 
@@ -333641,8 +333751,8 @@ async function runPowerShell(script, timeout = 3e4, lane = "action") {
   return await runPersistentPowerShell(script, timeout, lane);
 }
 function tempScreenshotDir() {
-  const dir = path9.join(os3.tmpdir(), "newmark-computer-use");
-  fs8.mkdirSync(dir, { recursive: true });
+  const dir = path10.join(os3.tmpdir(), "newmark-computer-use");
+  fs9.mkdirSync(dir, { recursive: true });
   const now2 = Date.now();
   if (now2 - lastScreenshotCleanupAt >= SCREENSHOT_CLEANUP_INTERVAL_MS) {
     lastScreenshotCleanupAt = now2;
@@ -333664,7 +333774,7 @@ function ephemeralScreenshotPath(kind, directory = tempScreenshotDir(), createdA
   const pid = Math.max(1, Math.floor(Number(ownerPid) || process.pid));
   const timestamp = Math.max(0, Math.floor(Number(createdAt) || Date.now()));
   const nonce = /^[a-f0-9]{8}$/i.test(String(suffix)) ? String(suffix).toLowerCase() : crypto6.randomBytes(4).toString("hex");
-  return path9.join(directory, `${kind}-p${pid}-t${timestamp}-${nonce}.jpg`);
+  return path10.join(directory, `${kind}-p${pid}-t${timestamp}-${nonce}.jpg`);
 }
 function isProcessAlive(pid) {
   if (!Number.isSafeInteger(pid) || pid <= 0) return false;
@@ -333677,14 +333787,14 @@ function isProcessAlive(pid) {
   }
 }
 function cleanupStaleScreenshots(options = {}) {
-  const directory = options.directory || path9.join(os3.tmpdir(), "newmark-computer-use");
+  const directory = options.directory || path10.join(os3.tmpdir(), "newmark-computer-use");
   const now2 = Number.isFinite(Number(options.now)) ? Number(options.now) : Date.now();
   const processAlive = options.isProcessAlive || isProcessAlive;
   const ownedPattern = /^(?:observe|app)-p([1-9]\d*)-t(\d{10,16})-[a-f0-9]{8}\.jpg$/i;
   const legacyPattern = /^(?:observe|app)-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z-[a-f0-9]{8}\.jpg$/i;
   let names = [];
   try {
-    names = fs8.readdirSync(directory);
+    names = fs9.readdirSync(directory);
   } catch {
     return { removed: 0 };
   }
@@ -333693,10 +333803,10 @@ function cleanupStaleScreenshots(options = {}) {
     const owned = ownedPattern.exec(name50);
     const isLegacy = !owned && legacyPattern.test(name50);
     if (!owned && !isLegacy) continue;
-    const filePath = path9.join(directory, name50);
+    const filePath = path10.join(directory, name50);
     let stats;
     try {
-      stats = fs8.lstatSync(filePath);
+      stats = fs9.lstatSync(filePath);
       if (!stats.isFile() || stats.isSymbolicLink()) continue;
     } catch {
       continue;
@@ -333720,7 +333830,7 @@ function cleanupStaleScreenshots(options = {}) {
     }
     if (!shouldRemove) continue;
     try {
-      fs8.unlinkSync(filePath);
+      fs9.unlinkSync(filePath);
       removed += 1;
     } catch {
     }
@@ -333743,7 +333853,7 @@ function captureBounds(maxWidth, maxHeight) {
 }
 function removeEphemeralScreenshot(outPath) {
   try {
-    fs8.unlinkSync(outPath);
+    fs9.unlinkSync(outPath);
   } catch {
   }
 }
@@ -333819,7 +333929,7 @@ async function startTakeoverOverlay(durationMs = 0, input2 = {}) {
   const width = 2;
   const speedSeconds = 3;
   const ownerPid = Math.max(0, Math.floor(Number(input2.ownerPid ?? process.pid) || 0));
-  const scriptPath = path9.join(tempScreenshotDir(), `takeover-overlay-${timestampName()}-${crypto6.randomBytes(4).toString("hex")}.ps1`);
+  const scriptPath = path10.join(tempScreenshotDir(), `takeover-overlay-${timestampName()}-${crypto6.randomBytes(4).toString("hex")}.ps1`);
   const script = [
     "Add-Type -AssemblyName System.Windows.Forms",
     "Add-Type -AssemblyName System.Drawing",
@@ -333958,7 +334068,7 @@ async function startTakeoverOverlay(durationMs = 0, input2 = {}) {
     "[System.Windows.Forms.Application]::Run()",
     "try { Remove-Item -LiteralPath $PSCommandPath -Force -ErrorAction SilentlyContinue } catch {}"
   ].filter(Boolean).join("\r\n");
-  fs8.writeFileSync(scriptPath, `\uFEFF${script}`, "utf8");
+  fs9.writeFileSync(scriptPath, `\uFEFF${script}`, "utf8");
   const createCommand = [
     `$cmd = 'powershell.exe -NoProfile -ExecutionPolicy Bypass -File ' + ${psQuote(`"${scriptPath}"`)}`,
     `$startup = ([wmiclass]'Win32_ProcessStartup').CreateInstance()`,
@@ -333971,7 +334081,7 @@ async function startTakeoverOverlay(durationMs = 0, input2 = {}) {
   const pid = Number(String(result.output || "").trim().split(/\r?\n/).pop() || 0);
   if (!Number.isFinite(pid) || pid <= 0 || !result.ok) {
     try {
-      fs8.unlinkSync(scriptPath);
+      fs9.unlinkSync(scriptPath);
     } catch {
     }
     return { ok: false, action: "takeover_start", error: result.output || "Overlay failed to start." };
@@ -333998,7 +334108,7 @@ function parseJsonArray(text) {
   return [];
 }
 function observationKey(workspacePath, ownerId) {
-  return `${path9.resolve(workspacePath || process.cwd()).toLowerCase()}::${String(ownerId || "direct")}`;
+  return `${path10.resolve(workspacePath || process.cwd()).toLowerCase()}::${String(ownerId || "direct")}`;
 }
 function sceneGeneration(apps, elements) {
   const seed = [
@@ -334214,7 +334324,7 @@ async function cropScreenshot(workspacePath, ownerId, allowEphemeralVisionImage,
       ...parsed
     };
     if (includeRawUi) payload.perception.elements = elements;
-    const imageAvailable = parsed.image_available === true && fs8.existsSync(outPath);
+    const imageAvailable = parsed.image_available === true && fs9.existsSync(outPath);
     if (allowEphemeralVisionImage && imageAvailable) {
       payload.vision_image_path = outPath;
       retainedForVision = true;
@@ -334477,7 +334587,7 @@ async function screenshot(workspacePath, ownerId, allowEphemeralVisionImage, inc
       ...parsed
     };
     if (includeRawUi) payload.perception.elements = ui.elements;
-    const imageAvailable = parsed.image_available === true && fs8.existsSync(outPath);
+    const imageAvailable = parsed.image_available === true && fs9.existsSync(outPath);
     if (allowEphemeralVisionImage && imageAvailable) {
       payload.vision_image_path = outPath;
       retainedForVision = true;
@@ -334801,13 +334911,13 @@ async function runComputerUse(options) {
 }
 
 // src/core/ssh.ts
-var fs10 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
+var fs11 = __toESM(require("fs"));
+var path12 = __toESM(require("path"));
 
 // src/core/asyncProcess.ts
 var import_child_process4 = require("child_process");
-var fs9 = __toESM(require("fs/promises"));
-var path10 = __toESM(require("path"));
+var fs10 = __toESM(require("fs/promises"));
+var path11 = __toESM(require("path"));
 var STOP_SETTLEMENT_WATCHDOG_MS = 500;
 function signalMessage(signal) {
   const reason = signal?.reason;
@@ -334817,7 +334927,7 @@ function signalMessage(signal) {
 }
 function trustedWindowsTaskkillPath() {
   const windowsRoot = String(process.env.SystemRoot || process.env.WINDIR || "C:\\Windows");
-  return path10.join(windowsRoot, "System32", "taskkill.exe");
+  return path11.join(windowsRoot, "System32", "taskkill.exe");
 }
 function stopProcessTree(child) {
   const pid = child.pid;
@@ -334986,7 +335096,7 @@ async function runAsyncWindowsBatch(command, args, options = {}) {
 }
 async function accessible(filePath) {
   try {
-    await fs9.access(filePath);
+    await fs10.access(filePath);
     return true;
   } catch {
     return false;
@@ -334995,14 +335105,14 @@ async function accessible(filePath) {
 async function resolveWindowsLauncher(command) {
   const clean = String(command || "").trim();
   if (!clean) return "";
-  if (path10.isAbsolute(clean) || /[\\/]/.test(clean)) {
-    const absolute = path10.resolve(clean);
+  if (path11.isAbsolute(clean) || /[\\/]/.test(clean)) {
+    const absolute = path11.resolve(clean);
     return await accessible(absolute) ? absolute : "";
   }
-  for (const entry of String(process.env.PATH || "").split(path10.delimiter)) {
+  for (const entry of String(process.env.PATH || "").split(path11.delimiter)) {
     const directory = entry.trim().replace(/^"|"$/g, "");
     if (!directory) continue;
-    const candidate = path10.join(directory, clean);
+    const candidate = path11.join(directory, clean);
     if (await accessible(candidate)) return candidate;
   }
   return "";
@@ -335010,11 +335120,11 @@ async function resolveWindowsLauncher(command) {
 async function resolveNpmBatchTarget(batchPath) {
   let source = "";
   try {
-    source = await fs9.readFile(batchPath, "utf8");
+    source = await fs10.readFile(batchPath, "utf8");
   } catch {
     return null;
   }
-  const directory = path10.dirname(batchPath);
+  const directory = path11.dirname(batchPath);
   let relativeScript = "";
   const direct = /(?:%~dp0|%dp0%)\\?([^"\r\n]+)"\s+%\*/i.exec(source);
   if (direct) relativeScript = direct[1];
@@ -335028,10 +335138,10 @@ async function resolveNpmBatchTarget(batchPath) {
     }
   }
   if (!relativeScript) return null;
-  const scriptPath = path10.resolve(directory, relativeScript.replace(/\\/g, path10.sep));
-  const directoryPrefix = `${path10.resolve(directory).toLowerCase()}${path10.sep}`;
+  const scriptPath = path11.resolve(directory, relativeScript.replace(/\\/g, path11.sep));
+  const directoryPrefix = `${path11.resolve(directory).toLowerCase()}${path11.sep}`;
   if (!scriptPath.toLowerCase().startsWith(directoryPrefix) || !await accessible(scriptPath)) return null;
-  const siblingNode = path10.join(directory, "node.exe");
+  const siblingNode = path11.join(directory, "node.exe");
   const nodePath = await accessible(siblingNode) ? siblingNode : await resolveWindowsLauncher("node.exe") || await resolveWindowsLauncher("node");
   return nodePath ? { nodePath, scriptPath } : null;
 }
@@ -335074,19 +335184,19 @@ var SshManager = class {
   rootPath;
   runner;
   storePath() {
-    return path11.join(this.rootPath, "Work", "SSH.json");
+    return path12.join(this.rootPath, "Work", "SSH.json");
   }
   ensureStore() {
     try {
-      fs10.mkdirSync(path11.join(this.rootPath, "Work"), { recursive: true });
-      if (!fs10.existsSync(this.storePath())) fs10.writeFileSync(this.storePath(), "[]", "utf-8");
+      fs11.mkdirSync(path12.join(this.rootPath, "Work"), { recursive: true });
+      if (!fs11.existsSync(this.storePath())) fs11.writeFileSync(this.storePath(), "[]", "utf-8");
     } catch {
     }
   }
   readRaw() {
     this.ensureStore();
     try {
-      const parsed = JSON.parse(fs10.readFileSync(this.storePath(), "utf-8").replace(/^\uFEFF/, ""));
+      const parsed = JSON.parse(fs11.readFileSync(this.storePath(), "utf-8").replace(/^\uFEFF/, ""));
       if (!Array.isArray(parsed)) return [];
       return parsed.map((item) => this.normalize(item)).filter((item) => !!item);
     } catch {
@@ -335095,7 +335205,7 @@ var SshManager = class {
   }
   writeRaw(items) {
     this.ensureStore();
-    fs10.writeFileSync(this.storePath(), JSON.stringify(items, null, 2), "utf-8");
+    fs11.writeFileSync(this.storePath(), JSON.stringify(items, null, 2), "utf-8");
   }
   normalize(raw) {
     if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
@@ -335275,8 +335385,8 @@ var SshManager = class {
 };
 
 // src/core/workspace.ts
-var fs11 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var fs12 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
 var crypto7 = __toESM(require("crypto"));
 function lastEmbeddedWindowsPath(input2) {
   const matcher = /[A-Za-z]:[\\/]/g;
@@ -335295,22 +335405,22 @@ function normalizeHostWorkspacePath(input2, platform = process.platform) {
   const raw = String(input2 || "").trim();
   const embeddedWindowsPath = lastEmbeddedWindowsPath(raw);
   if (platform === "win32") {
-    if (embeddedWindowsPath) return path12.win32.normalize(embeddedWindowsPath.replace(/\//g, "\\"));
+    if (embeddedWindowsPath) return path13.win32.normalize(embeddedWindowsPath.replace(/\//g, "\\"));
     const wsl = /^\/mnt\/([a-zA-Z])(?:\/(.*))?$/.exec(raw.replace(/\\/g, "/"));
-    if (wsl) return path12.win32.normalize(`${wsl[1].toUpperCase()}:\\${String(wsl[2] || "").replace(/\//g, "\\")}`);
-    return path12.win32.resolve(raw || ".");
+    if (wsl) return path13.win32.normalize(`${wsl[1].toUpperCase()}:\\${String(wsl[2] || "").replace(/\//g, "\\")}`);
+    return path13.win32.resolve(raw || ".");
   }
   if (platform === "linux" && embeddedWindowsPath) {
     const drive = embeddedWindowsPath[0].toLowerCase();
     const rest = embeddedWindowsPath.slice(3).replace(/\\/g, "/").replace(/^\/+/, "");
-    return path12.posix.resolve(`/mnt/${drive}/${rest}`);
+    return path13.posix.resolve(`/mnt/${drive}/${rest}`);
   }
-  return path12.posix.resolve(raw || ".");
+  return path13.posix.resolve(raw || ".");
 }
 function isPathInside(parent, child) {
   try {
-    const relative6 = path12.relative(path12.resolve(parent), path12.resolve(child));
-    return relative6 === "" || !!relative6 && !relative6.startsWith("..") && !path12.isAbsolute(relative6);
+    const relative6 = path13.relative(path13.resolve(parent), path13.resolve(child));
+    return relative6 === "" || !!relative6 && !relative6.startsWith("..") && !path13.isAbsolute(relative6);
   } catch {
     return false;
   }
@@ -335318,7 +335428,7 @@ function isPathInside(parent, child) {
 function isProtectedInstallWorkspacePath(candidate) {
   const value = String(candidate || "").trim();
   if (!value) return false;
-  const roots = [path12.dirname(process.execPath)];
+  const roots = [path13.dirname(process.execPath)];
   if (process.platform === "win32") {
     roots.push(
       process.env.ProgramFiles || "",
@@ -335326,7 +335436,7 @@ function isProtectedInstallWorkspacePath(candidate) {
       process.env.ProgramW6432 || ""
     );
   }
-  const resolved = path12.resolve(value);
+  const resolved = path13.resolve(value);
   return roots.filter(Boolean).some((root2) => isPathInside(root2, resolved));
 }
 var WorkspaceManager = class {
@@ -335336,16 +335446,16 @@ var WorkspaceManager = class {
     this.detached = options.detached === true;
     this.pcHash = this.loadPcHash();
     if (this.detached) return;
-    const workDir = path12.join(rootPath, "Work");
+    const workDir = path13.join(rootPath, "Work");
     try {
-      fs11.mkdirSync(workDir, { recursive: true });
+      fs12.mkdirSync(workDir, { recursive: true });
     } catch {
     }
     for (const fn of ["Local.json", "External.json"]) {
-      const p = path12.join(workDir, fn);
-      if (!fs11.existsSync(p)) {
+      const p = path13.join(workDir, fn);
+      if (!fs12.existsSync(p)) {
         try {
-          fs11.writeFileSync(p, "[]", "utf-8");
+          fs12.writeFileSync(p, "[]", "utf-8");
         } catch {
         }
       }
@@ -335366,7 +335476,7 @@ var WorkspaceManager = class {
   detached;
   loadPcHash() {
     try {
-      const h2 = fs11.readFileSync(path12.join(this.rootPath, "PC_Hash.config"), "utf-8");
+      const h2 = fs12.readFileSync(path13.join(this.rootPath, "PC_Hash.config"), "utf-8");
       return h2.trim();
     } catch {
       return "";
@@ -335381,19 +335491,19 @@ var WorkspaceManager = class {
     if (this.external.length !== before) this.saveExternal();
   }
   scan() {
-    const w = path12.join(this.rootPath, "Work");
-    if (!fs11.existsSync(w)) return;
+    const w = path13.join(this.rootPath, "Work");
+    if (!fs12.existsSync(w)) return;
     let internalChanged = false;
     let externalChanged = false;
     try {
-      const local = JSON.parse(fs11.readFileSync(path12.join(w, "Local.json"), "utf-8"));
+      const local = JSON.parse(fs12.readFileSync(path13.join(w, "Local.json"), "utf-8"));
       this.internal = Array.isArray(local) ? local.map((item) => this.normalizeInternalWorkspace(item, (changed) => {
         internalChanged = internalChanged || changed;
       })) : [];
     } catch {
     }
     try {
-      const ext = JSON.parse(fs11.readFileSync(path12.join(w, "External.json"), "utf-8"));
+      const ext = JSON.parse(fs12.readFileSync(path13.join(w, "External.json"), "utf-8"));
       const normalized = Array.isArray(ext) ? ext.map((item) => this.normalizeExternalWorkspace(item, (changed) => {
         externalChanged = externalChanged || changed;
       })) : [];
@@ -335404,13 +335514,13 @@ var WorkspaceManager = class {
       });
     } catch {
     }
-    for (const entry of fs11.readdirSync(w, { withFileTypes: true })) {
+    for (const entry of fs12.readdirSync(w, { withFileTypes: true })) {
       if (entry.isDirectory() && !["Local.json", "External.json", ".ssh"].includes(entry.name)) {
         if (!this.internal.find((wi) => wi.name === entry.name)) {
           this.internal.push({
-            id: this.stableWorkspaceId("local", path12.join(w, entry.name)),
+            id: this.stableWorkspaceId("local", path13.join(w, entry.name)),
             name: entry.name,
-            path: path12.join(w, entry.name),
+            path: path13.join(w, entry.name),
             isInternal: true,
             hostBinding: "",
             icon: entry.name.charAt(0).toUpperCase()
@@ -335423,9 +335533,9 @@ var WorkspaceManager = class {
     if (externalChanged) this.saveExternal();
   }
   normalizeInternalWorkspace(input2, markChanged) {
-    const rawName = String(input2?.name || path12.basename(String(input2?.path || "")) || "").trim();
+    const rawName = String(input2?.name || path13.basename(String(input2?.path || "")) || "").trim();
     const name50 = rawName || (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "").replace("T", "_").slice(0, 15);
-    const expectedPath = path12.join(this.rootPath, "Work", name50);
+    const expectedPath = path13.join(this.rootPath, "Work", name50);
     const id = this.stableWorkspaceId("local", expectedPath);
     if (normalizeHostWorkspacePath(String(input2?.path || "")) !== normalizeHostWorkspacePath(expectedPath) || input2?.isInternal !== true || input2?.id !== id) markChanged(true);
     return {
@@ -335446,11 +335556,11 @@ var WorkspaceManager = class {
     return {
       ...input2,
       id,
-      name: String(input2?.name || path12.basename(workspacePath) || id),
+      name: String(input2?.name || path13.basename(workspacePath) || id),
       path: workspacePath,
       isInternal: false,
       hostBinding: String(input2?.hostBinding || ""),
-      icon: String(input2?.icon || path12.basename(workspacePath).charAt(0).toUpperCase()),
+      icon: String(input2?.icon || path13.basename(workspacePath).charAt(0).toUpperCase()),
       kind
     };
   }
@@ -335471,11 +335581,11 @@ var WorkspaceManager = class {
     const resolved = normalizeHostWorkspacePath(target);
     let real = resolved;
     try {
-      real = fs11.existsSync(resolved) ? fs11.realpathSync.native(resolved) : resolved;
+      real = fs12.existsSync(resolved) ? fs12.realpathSync.native(resolved) : resolved;
     } catch {
       real = resolved;
     }
-    const normalized = path12.normalize(real).replace(/[\\/]+$/, "");
+    const normalized = path13.normalize(real).replace(/[\\/]+$/, "");
     return process.platform === "win32" ? normalized.toLowerCase() : normalized;
   }
   stableWorkspaceId(kind, workspacePath) {
@@ -335501,8 +335611,8 @@ var WorkspaceManager = class {
   isInsideRoot(target) {
     const root2 = this.canonicalWorkspacePath(this.rootPath);
     const candidate = this.canonicalWorkspacePath(target);
-    const rel = path12.relative(root2, candidate);
-    return rel === "" || !!rel && !rel.startsWith("..") && !path12.isAbsolute(rel);
+    const rel = path13.relative(root2, candidate);
+    return rel === "" || !!rel && !rel.startsWith("..") && !path13.isAbsolute(rel);
   }
   canonicalRemotePath(target) {
     let cleaned = String(target || "").trim().replace(/\\/g, "/").replace(/\/+$/g, "");
@@ -335531,13 +335641,13 @@ var WorkspaceManager = class {
     return deduped;
   }
   statePath() {
-    return path12.join(this.rootPath, "Work", "State.json");
+    return path13.join(this.rootPath, "Work", "State.json");
   }
   readState() {
     const p = this.statePath();
-    if (!fs11.existsSync(p)) return {};
+    if (!fs12.existsSync(p)) return {};
     try {
-      const raw = fs11.readFileSync(p, "utf-8").replace(/^\uFEFF/, "");
+      const raw = fs12.readFileSync(p, "utf-8").replace(/^\uFEFF/, "");
       const parsed = JSON.parse(raw);
       if (parsed && typeof parsed === "object") return parsed;
     } catch {
@@ -335558,8 +335668,8 @@ var WorkspaceManager = class {
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     try {
-      fs11.mkdirSync(path12.dirname(p), { recursive: true });
-      fs11.writeFileSync(p, JSON.stringify(state, null, 2), "utf-8");
+      fs12.mkdirSync(path13.dirname(p), { recursive: true });
+      fs12.writeFileSync(p, JSON.stringify(state, null, 2), "utf-8");
     } catch {
     }
   }
@@ -335618,17 +335728,17 @@ var WorkspaceManager = class {
   }
   saveInternal() {
     if (this.detached) return;
-    const p = path12.join(this.rootPath, "Work", "Local.json");
+    const p = path13.join(this.rootPath, "Work", "Local.json");
     this.internal = this.dedupeByPath(this.internal);
     this.sortWorkspaces();
-    fs11.writeFileSync(p, JSON.stringify(this.internal, null, 2), "utf-8");
+    fs12.writeFileSync(p, JSON.stringify(this.internal, null, 2), "utf-8");
   }
   saveExternal() {
     if (this.detached) return;
-    const p = path12.join(this.rootPath, "Work", "External.json");
+    const p = path13.join(this.rootPath, "Work", "External.json");
     this.external = this.dedupeByPath(this.external);
     this.sortWorkspaces();
-    fs11.writeFileSync(p, JSON.stringify(this.external, null, 2), "utf-8");
+    fs12.writeFileSync(p, JSON.stringify(this.external, null, 2), "utf-8");
   }
   sleepSync(ms) {
     if (ms <= 0) return;
@@ -335636,48 +335746,48 @@ var WorkspaceManager = class {
     Atomics.wait(new Int32Array(buffer), 0, 0, ms);
   }
   isInternalWorkspacePath(target) {
-    const workRoot = path12.resolve(this.rootPath, "Work");
-    const resolved = path12.resolve(target);
-    const rel = path12.relative(workRoot, resolved);
-    return !!rel && !rel.startsWith("..") && !path12.isAbsolute(rel);
+    const workRoot = path13.resolve(this.rootPath, "Work");
+    const resolved = path13.resolve(target);
+    const rel = path13.relative(workRoot, resolved);
+    return !!rel && !rel.startsWith("..") && !path13.isAbsolute(rel);
   }
   clearReadOnlyRecursive(target) {
-    if (!fs11.existsSync(target)) return;
-    const stat = fs11.lstatSync(target);
+    if (!fs12.existsSync(target)) return;
+    const stat = fs12.lstatSync(target);
     try {
-      fs11.chmodSync(target, stat.mode | 448);
+      fs12.chmodSync(target, stat.mode | 448);
     } catch {
     }
     if (!stat.isDirectory()) return;
-    for (const entry of fs11.readdirSync(target)) {
-      this.clearReadOnlyRecursive(path12.join(target, entry));
+    for (const entry of fs12.readdirSync(target)) {
+      this.clearReadOnlyRecursive(path13.join(target, entry));
     }
   }
   removeInternalDirectory(target) {
-    const resolved = path12.resolve(target);
+    const resolved = path13.resolve(target);
     if (!this.isInternalWorkspacePath(resolved)) return false;
-    if (!fs11.existsSync(resolved)) return true;
+    if (!fs12.existsSync(resolved)) return true;
     const delays = [0, 50, 100, 200, 400, 800, 1200];
     for (const delay of delays) {
       this.sleepSync(delay);
       try {
-        fs11.rmSync(resolved, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+        fs12.rmSync(resolved, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
       } catch {
       }
-      if (!fs11.existsSync(resolved)) return true;
+      if (!fs12.existsSync(resolved)) return true;
       try {
         this.clearReadOnlyRecursive(resolved);
-        fs11.rmSync(resolved, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+        fs12.rmSync(resolved, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
       } catch {
       }
-      if (!fs11.existsSync(resolved)) return true;
+      if (!fs12.existsSync(resolved)) return true;
     }
     return false;
   }
   createInternal(name50) {
     const n3 = name50 || (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "").replace("T", "_").slice(0, 15);
-    const d3 = path12.join(this.rootPath, "Work", n3);
-    fs11.mkdirSync(d3, { recursive: true });
+    const d3 = path13.join(this.rootPath, "Work", n3);
+    fs12.mkdirSync(d3, { recursive: true });
     const existing = this.findWorkspaceByPath(d3);
     if (existing) {
       this.current = existing;
@@ -335699,15 +335809,15 @@ var WorkspaceManager = class {
     return ws;
   }
   addExternal(p) {
-    const resolved = path12.resolve(p);
-    if (!fs11.existsSync(resolved) || this.isInsideRoot(resolved)) return null;
+    const resolved = path13.resolve(p);
+    if (!fs12.existsSync(resolved) || this.isInsideRoot(resolved)) return null;
     const existing = this.findWorkspaceByPath(resolved);
     if (existing) {
       this.current = existing;
       this.saveState();
       return existing;
     }
-    const name50 = path12.basename(resolved);
+    const name50 = path13.basename(resolved);
     const ws = {
       id: this.stableWorkspaceId("local", resolved),
       name: name50,
@@ -335725,10 +335835,10 @@ var WorkspaceManager = class {
   addSshExternal(input2) {
     if (!input2.sshConnectionId || !input2.remotePath || !input2.remotePcHash) return null;
     const remotePath = this.canonicalRemotePath(input2.remotePath);
-    const baseName = (input2.name || path12.basename(remotePath.replace(/[\\/]+$/, "")) || input2.sshConnectionId || "ssh-workspace").trim();
+    const baseName = (input2.name || path13.basename(remotePath.replace(/[\\/]+$/, "")) || input2.sshConnectionId || "ssh-workspace").trim();
     const safeName = baseName.replace(/[<>:"/\\|?*\x00-\x1F]/g, "-").replace(/\s+/g, " ").trim() || "ssh-workspace";
-    const shadowRoot = input2.localPath ? path12.resolve(input2.localPath) : path12.join(this.rootPath, "Work", ".ssh", `${input2.sshConnectionId}-${crypto7.createHash("sha256").update(remotePath).digest("hex").slice(0, 16)}`);
-    fs11.mkdirSync(shadowRoot, { recursive: true });
+    const shadowRoot = input2.localPath ? path13.resolve(input2.localPath) : path13.join(this.rootPath, "Work", ".ssh", `${input2.sshConnectionId}-${crypto7.createHash("sha256").update(remotePath).digest("hex").slice(0, 16)}`);
+    fs12.mkdirSync(shadowRoot, { recursive: true });
     const existing = this.findSshWorkspaceByRemotePath(input2.sshConnectionId, remotePath);
     const ws = {
       ...existing || {},
@@ -335810,7 +335920,7 @@ var WorkspaceManager = class {
   currentAgentPrompt() {
     if (!this.current) return null;
     try {
-      return fs11.readFileSync(path12.join(this.current.path, "agent.md"), "utf-8");
+      return fs12.readFileSync(path13.join(this.current.path, "agent.md"), "utf-8");
     } catch {
       return null;
     }
@@ -335819,8 +335929,8 @@ var WorkspaceManager = class {
     const perm = this.config.getStr("workspace", "access_permission");
     if (perm === "full_access") return true;
     if (!this.current) return perm !== "no_outside_access";
-    const rel = path12.relative(path12.resolve(this.current.path), path12.resolve(target));
-    const inside2 = rel === "" || !!rel && !rel.startsWith("..") && !path12.isAbsolute(rel);
+    const rel = path13.relative(path13.resolve(this.current.path), path13.resolve(target));
+    const inside2 = rel === "" || !!rel && !rel.startsWith("..") && !path13.isAbsolute(rel);
     if (inside2) return true;
     return perm !== "no_outside_access";
   }
@@ -335903,6 +336013,7 @@ var PLAN_COMPUTER_USE_ACTIONS = ["observe", "app_list", "app_observe"];
 var PLAN_BROWSER_USE_ACTIONS = ["observe", "navigate", "wait", "extract"];
 var PLAN_COMPUTER_USE_ACTION_SET = new Set(PLAN_COMPUTER_USE_ACTIONS);
 var PLAN_BROWSER_USE_ACTION_SET = new Set(PLAN_BROWSER_USE_ACTIONS);
+var CHAT_WEB_TOOLS = /* @__PURE__ */ new Set(["web_search", "web_fetch"]);
 var CONCURRENCY_SAFE_TOOLS = /* @__PURE__ */ new Set([
   "pwd",
   "read",
@@ -335936,6 +336047,13 @@ function evaluateToolPolicy(request) {
   const availability = toolAvailability(name50);
   const base2 = { availability, settingsVisible: availability === "configurable" };
   if (!name50) return { ...base2, allowed: false, reason: "[permission] Tool name is required." };
+  if (request.mode === "chat" && !CHAT_WEB_TOOLS.has(name50)) {
+    return {
+      ...base2,
+      allowed: false,
+      reason: `[permission] Chat mode only allows web_search and web_fetch. It has no workspace, host, application, memory, task, or other write access. Blocked: ${name50}`
+    };
+  }
   if (request.mode === "plan") {
     if (name50 === "computer_use") {
       const action = String(request.args?.action || "").trim();
@@ -335977,6 +336095,13 @@ function planModePolicyPrompt() {
     "Runtime policy rejects stale or hidden mutating tool calls even if a prompt asks for them."
   ].join(" ");
 }
+function chatModePolicyPrompt() {
+  return [
+    "Chat mode is a narrow web-evidence mode.",
+    "Only web_search and web_fetch are available; every workspace, host, application, memory, task, browser-control, and write capability is denied at runtime.",
+    "Search the web for relevant evidence, fetch primary or authoritative sources when useful, then summarize and answer promptly instead of expanding into a long-running task."
+  ].join(" ");
+}
 var DELETE_VERB_SOURCE = "(?:remove-item|rmdir|unlink|erase|del|rm|rd|ri)";
 var DELETE_VERB_BOUNDARY = new RegExp(`(?:^|[\\s;&|()\\n])${DELETE_VERB_SOURCE}(?:\\s|$)`, "i");
 function hasDeletionVerb(text) {
@@ -336254,7 +336379,7 @@ function requestUtilityHostTool(tool, args, context, timeoutMs = 12e4, signal) {
 }
 
 // src/core/nativeBash.ts
-var path13 = __toESM(require("path"));
+var path14 = __toESM(require("path"));
 var import_module = require("module");
 var MAX_OUTPUT_BYTES = 1024 * 1024;
 var DEFAULT_TIMEOUT_MS = 3e4;
@@ -336342,11 +336467,11 @@ function normalizedTimeout(timeoutMs) {
 }
 function virtualCwd(workspaceRoot, requestedCwd) {
   if (!requestedCwd) return "/";
-  const root2 = path13.resolve(workspaceRoot);
-  const cwd = path13.resolve(requestedCwd);
-  const relative6 = path13.relative(root2, cwd);
-  if (relative6.startsWith("..") || path13.isAbsolute(relative6)) return "/";
-  return relative6 ? `/${relative6.split(path13.sep).join("/")}` : "/";
+  const root2 = path14.resolve(workspaceRoot);
+  const cwd = path14.resolve(requestedCwd);
+  const relative6 = path14.relative(root2, cwd);
+  if (relative6.startsWith("..") || path14.isAbsolute(relative6)) return "/";
+  return relative6 ? `/${relative6.split(path14.sep).join("/")}` : "/";
 }
 function combineAbortSignals(signal, timeoutMs) {
   const controller = new AbortController();
@@ -336372,7 +336497,7 @@ function createBash(workspaceRoot, timeoutMs) {
   const justBash = loadJustBash();
   if (!justBash) throw new Error("Native Bash runtime unavailable");
   const fs27 = new justBash.ReadWriteFs({
-    root: path13.resolve(workspaceRoot),
+    root: path14.resolve(workspaceRoot),
     maxFileReadSize: MAX_OUTPUT_BYTES * 8,
     allowSymlinks: false
   });
@@ -336461,12 +336586,12 @@ async function executeWorkspaceBash(script, workspaceRoot, options = {}) {
 }
 
 // src/core/toolArgumentValidator.ts
-var fs12 = require("fs");
-var path14 = require("path");
+var fs13 = require("fs");
+var path15 = require("path");
 var typeBoxCompilerPath = [
-  path14.join(__dirname, "..", "typebox-compile.bundle.cjs"),
-  path14.join(__dirname, "typebox-compile.bundle.cjs")
-].find((candidate) => fs12.existsSync(candidate));
+  path15.join(__dirname, "..", "typebox-compile.bundle.cjs"),
+  path15.join(__dirname, "typebox-compile.bundle.cjs")
+].find((candidate) => fs13.existsSync(candidate));
 if (!typeBoxCompilerPath) throw new Error("Bundled TypeBox compiler is missing from the Newmark runtime.");
 var { Compile } = require(typeBoxCompilerPath);
 function closeToolArgumentSchema(input2) {
@@ -336556,8 +336681,8 @@ function formatValidationErrors(name50, errors) {
 }
 
 // src/core/localOcr.ts
-var fs13 = __toESM(require("fs"));
-var path15 = __toESM(require("path"));
+var fs14 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
 var AGENT_REPAIR_PROMPT = [
   "The local OCR output is approximate Chinese/English fallback evidence.",
   "Repair likely OCR substitutions, spacing, and line breaks using the visible UI/PDF context and the user task.",
@@ -336590,12 +336715,12 @@ var LocalOcrEngine = class {
     return await this.recognize(dataUrlBuffer(dataUrl), signal, profile);
   }
   async recognizeFile(filePath, signal) {
-    const absolute = path15.resolve(filePath);
-    const extension = path15.extname(absolute).toLowerCase();
+    const absolute = path16.resolve(filePath);
+    const extension = path16.extname(absolute).toLowerCase();
     if (![".png", ".jpg", ".jpeg", ".bmp"].includes(extension)) {
       throw new Error("Local OCR only accepts PNG, JPEG, or BMP images.");
     }
-    const stat = fs13.statSync(absolute);
+    const stat = fs14.statSync(absolute);
     if (!stat.isFile() || stat.size <= 0 || stat.size > 12 * 1024 * 1024) {
       throw new Error("Local OCR image must be a regular file no larger than 12 MB.");
     }
@@ -336649,7 +336774,7 @@ var LocalOcrEngine = class {
     const tesseract = require_src();
     const worker = await tesseract.createWorker("chi_sim+eng", tesseract.OEM.LSTM_ONLY, {
       langPath: tessdataPath,
-      cachePath: path15.join(this.rootPath, "cache", "ocr-runtime"),
+      cachePath: path16.join(this.rootPath, "cache", "ocr-runtime"),
       cacheMethod: "none",
       gzip: true,
       logger: () => void 0
@@ -336657,14 +336782,14 @@ var LocalOcrEngine = class {
     return worker;
   }
   prepareLanguageCache() {
-    const target = path15.join(this.rootPath, "cache", "ocr-tessdata");
-    fs13.mkdirSync(target, { recursive: true });
+    const target = path16.join(this.rootPath, "cache", "ocr-tessdata");
+    fs14.mkdirSync(target, { recursive: true });
     for (const language of ["eng", "chi_sim"]) {
-      const destination = path15.join(target, `${language}.traineddata.gz`);
-      if (fs13.existsSync(destination) && fs13.statSync(destination).size > 0) continue;
-      const packageRoot = path15.dirname(require.resolve(`@tesseract.js-data/${language}/package.json`));
-      const source = path15.join(packageRoot, "4.0.0_best_int", `${language}.traineddata.gz`);
-      fs13.copyFileSync(source, destination);
+      const destination = path16.join(target, `${language}.traineddata.gz`);
+      if (fs14.existsSync(destination) && fs14.statSync(destination).size > 0) continue;
+      const packageRoot = path16.dirname(require.resolve(`@tesseract.js-data/${language}/package.json`));
+      const source = path16.join(packageRoot, "4.0.0_best_int", `${language}.traineddata.gz`);
+      fs14.copyFileSync(source, destination);
     }
     return target;
   }
@@ -336803,8 +336928,8 @@ function normalizeCrossEnvPath(value, wsPath) {
     const posix3 = windowsDrivePathToPosix(raw);
     if (posix3) return posix3;
   }
-  if (path16.isAbsolute(raw)) return raw;
-  return path16.join(wsPath, raw);
+  if (path17.isAbsolute(raw)) return raw;
+  return path17.join(wsPath, raw);
 }
 function translateWindowsPathsForWslBash(script) {
   if (!process.env.NEWMARK_WSL_DISTRO) return script;
@@ -336818,7 +336943,7 @@ function translateWindowsPathsForWslBash(script) {
 function computerUseOwner(context, wsPath) {
   const conversationId = String(context.conversationId || "").trim();
   if (conversationId) return `conversation:${conversationId}`;
-  const resolved = path16.resolve(context.workspacePath || wsPath || process.cwd());
+  const resolved = path17.resolve(context.workspacePath || wsPath || process.cwd());
   const workspaceHash = crypto8.createHash("sha256").update(resolved).digest("hex").slice(0, 12);
   return `direct:${workspaceHash}`;
 }
@@ -336900,7 +337025,7 @@ function computerUseSessionScope(context, wsPath, owner) {
   return {
     runtimeKey: browserUseScope(context, wsPath).runtimeKey,
     ownerLabel: owner,
-    workspacePath: path16.resolve(wsPath || process.cwd())
+    workspacePath: path17.resolve(wsPath || process.cwd())
   };
 }
 function acquireComputerUseLock(action, owner, wsPath, context = {}, dryRun = false) {
@@ -337095,7 +337220,7 @@ var ToolExecutor = class {
       t3("subagent_send", "Persist a mailbox message to a same-conversation peer agent. Target by exact id (preferred) or name.", { id: { type: "string", description: "Exact peer id from subagent_list." }, name: { type: "string", description: "Convenience peer name." }, message: { type: "string" }, prompt: { type: "string", description: "Legacy alias for message." }, kind: { type: "string", enum: ["directive", "question", "result", "handoff"] }, reply_to: { type: "string" }, correlation_id: { type: "string" } }, []),
       t3("subagent_result", "Return the persisted transcript, mailbox summary, status, and latest result for a peer agent. Target by exact id (preferred) or name.", { id: { type: "string", description: "Exact peer id from subagent_list." }, name: { type: "string", description: "Convenience peer name." } }, []),
       t3("subagent_close", "Close a same-conversation peer. Root can close any peer; a peer can close only itself. Target by exact id (preferred) or name.", { id: { type: "string", description: "Exact peer id from subagent_list." }, name: { type: "string", description: "Convenience peer name." } }, []),
-      t3("linked_plan", "Read or update the current conversation linked Markdown plan. Update requires the current expected_revision.", { action: { type: "string", enum: ["get", "update"] }, markdown: { type: "string" }, expected_revision: { type: "number" } }, ["action"]),
+      t3("linked_plan", "Read or incrementally update the current conversation linked Markdown plan. Update requires expected_revision. Prefer append or old_text/new_text for local changes; markdown remains the legacy full replacement path.", { action: { type: "string", enum: ["get", "update"] }, markdown: { type: "string" }, append: { type: "string" }, old_text: { type: "string" }, new_text: { type: "string" }, replace_all: { type: "boolean" }, expected_revision: { type: "number" } }, ["action"]),
       t3("build_history_query", "Read the concrete public work details (tool calls, results, file changes, guides) of one historical Build Block. Call it proactively when the current task continues, fixes, verifies, or depends on earlier work: reuse the returned activity instead of re-investigating from scratch. Do not call it merely to answer completion status already exposed by the prompt. Select by newest-to-oldest history_index, or by run_id returned from an earlier query. Every activity/guide content is bounded to max_chars (default 2000) to keep the read lean and cache-friendly.", { history_index: { type: "number", minimum: 1, description: "1-based historical Build Block index from the request ledger; 1 is the newest previous task." }, run_id: { type: "string", description: "Exact run id returned by an earlier build_history_query result." }, max_events: { type: "number", minimum: 1, maximum: 200, description: "Maximum trailing public work events; defaults to 80." }, max_chars: { type: "number", minimum: 100, maximum: 4e3, description: "Per-event/per-guide content character bound; defaults to 2000." } }, []),
       t3("context_compress", "Actively compress the LLM context history for this conversation. This collapses older history entries into a concise summary while preserving the recent tail, which reduces context tokens and cost. IMPORTANT: it affects only the LLM context (what the model sees); the displayed conversation history shown to the user is never altered. Call this when the conversation is long, token pressure is high, or you judge that older turns are no longer needed in full. Idempotent and safe: repeated calls produce incremental summaries.", { keep_recent: { type: "number", minimum: 2, maximum: 60, description: "Recent message count to keep uncompressed at the tail. Defaults to the configured keep_recent_messages." }, force: { type: "boolean", description: "Compress even if the context is not yet over the automatic threshold. Defaults to false." } }, []),
       t3("context_history_manage", "Manage the LLM context history for this conversation without affecting the displayed conversation history. This is the active context-management surface. The hot cache stays bounded; evicted folded segments remain in a conversation-isolated append-only cold archive and are loaded only by explicit search/read/restore calls. Actions: list returns a bounded index of current context entries; remove declares one long-term entry for unload (see below); summarize folds a contiguous current range; restore reinserts a folded segment when its summary marker is still present; search finds matching hot or archived segments; read returns one bounded segment without injecting the whole archive; status reports budgets, hot cache, cold archive, the protected recent zone, and pending removals. The recent context tail and last user message are protected from remove/summarize unless dangerous is true. For cache-optimization, remove ONLY targets long-term history (never the protected recent tail or last user message) and does NOT unload immediately: the declared entry stays in context for the rest of the current Build Block so the provider prefix cache stays stable, then is physically removed when the Block ends \u2014 applying to subsequent Blocks only.", {
@@ -337125,11 +337250,11 @@ var ToolExecutor = class {
       t3("skill_download", "Download a skill", { name: { type: "string" }, source: { type: "string" } }, ["name", "source"]),
       t3("skill", "Search enabled skill metadata or load one exact skill body on demand. Use query when unsure, then name to load the selected skill.", { query: { type: "string", maxLength: 200 }, name: { type: "string", maxLength: 200 } }, []),
       t3("flow_list", "List available Newmark Flow workflows from the Flow folder so the agent can choose one.", {}, []),
-      t3("flow_save", "Design or update a Newmark Flow workflow. Components must be an array of dialog/logic objects compatible with *.Flow.json.", { name: { type: "string" }, components: { type: "array" } }, ["name", "components"]),
+      t3("flow_save", "Create or incrementally update a Newmark Flow workflow. Use action=upsert with one component or action=delete with component_id and confirm=true for local edits. action=replace plus components remains the legacy full replacement path.", { name: { type: "string" }, action: { type: "string", enum: ["replace", "upsert", "delete"] }, components: { type: "array" }, component: { type: "object" }, component_id: { type: "number" }, confirm: { type: "boolean" } }, ["name"]),
       t3("flow_run", "Trigger an existing Newmark Flow workflow by name with optional input and start component.", { name: { type: "string" }, input: { type: "string" }, start: { type: "number" } }, ["name"]),
       t3("memory_lab_read", "Read Memory Lab index.json, its path, and usage instructions. Optionally pass component/name/slug to read a memory component core markdown.", { component: { type: "string" }, name: { type: "string" }, slug: { type: "string" } }, []),
       t3("memory_lab_query", "Retrieve a bounded task-relevant Memory Lab set with deterministic scoring and adaptive early stopping. Prefer this over loading the complete index when a focused query is sufficient.", { query: { type: "string", minLength: 1 }, limit: { type: "number", minimum: 1, maximum: 12 }, max_chars: { type: "number", minimum: 1e3, maximum: 48e3 } }, ["query"]),
-      t3("memory_lab_update", "ADD or UPDATE a Memory Lab component. Existing memory should include expectedUpdatedAt from the latest read/query so stale writes fail closed. Prior revisions are archived and the Policy decision is logged.", { name: { type: "string" }, description: { type: "string" }, tags: { type: "array", items: { type: "string" } }, tagPaths: { type: "array", items: { type: "array", items: { type: "string" } } }, content: { type: "string" }, kind: { type: "string", enum: ["file", "folder"] }, expectedUpdatedAt: { type: "string" }, reason: { type: "string" }, source: { type: "string" } }, ["name", "tags", "content"]),
+      t3("memory_lab_update", "Create or incrementally patch a Memory Lab component. Create with name/tags/content. For an existing component pass component plus expectedUpdatedAt and only changed fields; prefer contentAppend or oldText/newText for small body edits. Prior revisions are archived and stale writes fail closed.", { component: { type: "string" }, name: { type: "string" }, description: { type: "string" }, tags: { type: "array", items: { type: "string" } }, tagPaths: { type: "array", items: { type: "array", items: { type: "string" } } }, content: { type: "string" }, contentAppend: { type: "string" }, oldText: { type: "string" }, newText: { type: "string" }, replaceAll: { type: "boolean" }, kind: { type: "string", enum: ["file", "folder"] }, expectedUpdatedAt: { type: "string" }, reason: { type: "string" }, source: { type: "string" } }, []),
       t3("memory_lab_delete", "DELETE obsolete durable memory only when the user explicitly asks to forget/remove it. The prior revision is moved to Memory Lab/archive and the Policy decision is logged.", { component: { type: "string" }, name: { type: "string" }, slug: { type: "string" }, expectedUpdatedAt: { type: "string" }, reason: { type: "string" }, source: { type: "string" } }, []),
       t3("memory_lab_reindex", "Rebuild and organize Memory Lab index links. Routed through Agent runtime when invoked by the model.", {}, []),
       t3("automation_list", "List persisted Newmark automations so the agent can inspect scheduled work.", {}, []),
@@ -337451,13 +337576,13 @@ var ToolExecutor = class {
         }
         case "pdf_read": {
           const pdfPath = resolve16(g2("path"));
-          if (path16.extname(pdfPath).toLowerCase() !== ".pdf") return "[pdf_read error] path must end in .pdf.";
-          const stat = fs14.statSync(pdfPath);
+          if (path17.extname(pdfPath).toLowerCase() !== ".pdf") return "[pdf_read error] path must end in .pdf.";
+          const stat = fs15.statSync(pdfPath);
           if (!stat.isFile() || stat.size <= 0 || stat.size > 250 * 1024 * 1024) {
             return "[pdf_read error] PDF must be a regular file no larger than 250 MB.";
           }
           const maxChars = Math.max(500, Math.min(1e5, Number(args.max_chars || 5e4)));
-          const textLayer = extractPdfTextLayer(fs14.readFileSync(pdfPath)).slice(0, maxChars);
+          const textLayer = extractPdfTextLayer(fs15.readFileSync(pdfPath)).slice(0, maxChars);
           const readableCount = (textLayer.match(/[A-Za-z0-9\u3400-\u9fff]/g) || []).length;
           if (readableCount >= 20) {
             return JSON.stringify({
@@ -337676,7 +337801,7 @@ var ToolExecutor = class {
         case "flow_list":
           return this.flowList();
         case "flow_save":
-          return this.flowSave(g2("name"), args.components);
+          return this.flowSave(g2("name"), args);
         case "flow_run":
           return `[flow_run] Routed to Agent runtime: ${g2("name")}`;
         case "memory_lab_read":
@@ -337733,8 +337858,8 @@ var ToolExecutor = class {
     }
   }
   isInside(parent, child) {
-    const rel = path16.relative(path16.resolve(parent), path16.resolve(child));
-    return rel === "" || !!rel && !rel.startsWith("..") && !path16.isAbsolute(rel);
+    const rel = path17.relative(path17.resolve(parent), path17.resolve(child));
+    return rel === "" || !!rel && !rel.startsWith("..") && !path17.isAbsolute(rel);
   }
   hostSupportsTool(name50) {
     if (name50.startsWith("browser_") && !this.hostProfile.electronBrowser) return false;
@@ -337846,7 +337971,7 @@ var ToolExecutor = class {
       if (!token || /^https?:\/\//i.test(token) || token.startsWith("-")) continue;
       if (!this.looksLikePath(token)) continue;
       const withoutWildcard = token.replace(/[\\/][*?][^\\/]*$/g, "");
-      refs.push(path16.resolve(normalizeCrossEnvPath(withoutWildcard, wsPath)));
+      refs.push(path17.resolve(normalizeCrossEnvPath(withoutWildcard, wsPath)));
     }
     return Array.from(new Set(refs));
   }
@@ -337897,7 +338022,7 @@ var ToolExecutor = class {
   }
   fread(p) {
     try {
-      const c3 = fs14.readFileSync(p, "utf-8");
+      const c3 = fs15.readFileSync(p, "utf-8");
       return c3.length > 3e4 ? c3.slice(0, 3e4) + "...\n[truncated]" : c3;
     } catch (e3) {
       return `[read] ${e3}`;
@@ -337905,8 +338030,8 @@ var ToolExecutor = class {
   }
   fwrite(p, content) {
     try {
-      fs14.mkdirSync(path16.dirname(p), { recursive: true });
-      fs14.writeFileSync(p, content, "utf-8");
+      fs15.mkdirSync(path17.dirname(p), { recursive: true });
+      fs15.writeFileSync(p, content, "utf-8");
       return `[write] OK: ${p}`;
     } catch (e3) {
       return `[write] ${e3}`;
@@ -337914,10 +338039,10 @@ var ToolExecutor = class {
   }
   fedit(p, oldStr, newStr) {
     try {
-      const c3 = fs14.readFileSync(p, "utf-8");
+      const c3 = fs15.readFileSync(p, "utf-8");
       if (!c3.includes(oldStr)) return `[edit] String not found in ${p}.`;
       const updated = c3.replace(oldStr, newStr);
-      fs14.writeFileSync(p, updated, "utf-8");
+      fs15.writeFileSync(p, updated, "utf-8");
       return `[edit] OK: ${p}`;
     } catch (e3) {
       return `[edit] ${e3}`;
@@ -337926,12 +338051,12 @@ var ToolExecutor = class {
   fdelete(p) {
     try {
       if (/[*?]/.test(p)) return "[delete_file] Refused: wildcard paths are not allowed. Delete one file per call.";
-      const resolved = path16.resolve(p);
-      const stat = fs14.lstatSync(resolved);
+      const resolved = path17.resolve(p);
+      const stat = fs15.lstatSync(resolved);
       if (stat.isDirectory()) {
         return "[delete_file] Refused: deleting a directory is not allowed. Delete files one by one under Agent supervision.";
       }
-      fs14.unlinkSync(resolved);
+      fs15.unlinkSync(resolved);
       return `[delete_file] OK: ${resolved}`;
     } catch (e3) {
       return `[delete_file] ${e3 instanceof Error ? e3.message : String(e3)}`;
@@ -337955,11 +338080,11 @@ var ToolExecutor = class {
       const results = [];
       const walk4 = (d3, depth) => {
         if (depth > 5 || results.length >= 80) return;
-        for (const entry of fs14.readdirSync(d3, { withFileTypes: true })) {
-          const full = path16.join(d3, entry.name);
+        for (const entry of fs15.readdirSync(d3, { withFileTypes: true })) {
+          const full = path17.join(d3, entry.name);
           if (entry.isFile()) {
             try {
-              const content = fs14.readFileSync(full, "utf-8");
+              const content = fs15.readFileSync(full, "utf-8");
               for (const [i4, line] of content.split("\n").entries()) {
                 if (re.test(line)) {
                   results.push(`${entry.name}:${i4 + 1}:${line.trim()}`);
@@ -338175,29 +338300,53 @@ ${String(result.data)}`);
     try {
       const resp = await this.proxyFetch(src, { signal });
       const content = await resp.text();
-      const dir = path16.join(this.root, "skills", name50);
-      fs14.mkdirSync(dir, { recursive: true });
-      fs14.writeFileSync(path16.join(dir, "SKILL.md"), content, "utf-8");
+      const dir = path17.join(this.root, "skills", name50);
+      fs15.mkdirSync(dir, { recursive: true });
+      fs15.writeFileSync(path17.join(dir, "SKILL.md"), content, "utf-8");
       return `[skill] Downloaded '${name50}'`;
     } catch (e3) {
       return `[skill] ${e3}`;
     }
   }
   flowList() {
-    const dir = path16.join(this.root, "Flow");
+    const dir = path17.join(this.root, "Flow");
     try {
-      const files = fs14.readdirSync(dir).filter((f3) => f3.endsWith(".Flow.json")).sort();
+      const files = fs15.readdirSync(dir).filter((f3) => f3.endsWith(".Flow.json")).sort();
       if (!files.length) return "[flow_list] No workflows found.";
       return files.map((f3) => f3.replace(/\.Flow\.json$/, "")).join("\n");
     } catch (e3) {
       return `[flow_list] ${e3}`;
     }
   }
-  flowSave(name50, componentsRaw) {
+  flowSave(name50, input2) {
     const cleanName = (name50 || "").replace(/[<>:"/\\|?*]/g, "-").trim();
     if (!cleanName) return "[flow_save] Workflow name is required.";
-    if (!Array.isArray(componentsRaw)) return "[flow_save] components must be an array.";
-    const components = componentsRaw.map((raw, idx) => {
+    const dir = path17.join(this.root, "Flow");
+    const target = path17.join(dir, `${cleanName}.Flow.json`);
+    const action = String(input2.action || (Array.isArray(input2.components) ? "replace" : "upsert")).toLowerCase();
+    let componentsRaw = input2.components;
+    if (action === "upsert") {
+      if (!input2.component || typeof input2.component !== "object") return "[flow_save] component is required for action=upsert.";
+      const existing = FlowEngine.load(dir, cleanName)?.components || [];
+      const component = input2.component;
+      const requestedId = Number(component.id);
+      if (!Number.isFinite(requestedId)) return "[flow_save] component.id is required for action=upsert.";
+      componentsRaw = [...existing.filter((item) => item.id !== requestedId), component].sort((a3, b2) => Number(a3.id) - Number(b2.id));
+    } else if (action === "delete") {
+      if (input2.confirm !== true) return "[flow_save] action=delete requires confirm=true.";
+      const componentId = Number(input2.component_id);
+      if (!Number.isFinite(componentId)) return "[flow_save] component_id is required for action=delete.";
+      const existing = FlowEngine.load(dir, cleanName);
+      if (!existing) return `[flow_save] Workflow not found: ${cleanName}`;
+      const remaining = existing.components.filter((item) => item.id !== componentId);
+      if (remaining.length === existing.components.length) return `[flow_save] Component not found: ${componentId}`;
+      componentsRaw = remaining;
+    } else if (action !== "replace") {
+      return `[flow_save] Unknown action: ${action}`;
+    }
+    if (!Array.isArray(componentsRaw)) return "[flow_save] components must be an array for action=replace.";
+    const componentInputs = componentsRaw;
+    const components = componentInputs.map((raw, idx) => {
       const c3 = raw;
       const type = c3.type === "logic" ? "logic" : "dialog";
       if (type === "logic") {
@@ -338218,10 +338367,9 @@ ${String(result.data)}`);
       };
     });
     const workflow = { name: cleanName, components };
-    const dir = path16.join(this.root, "Flow");
-    fs14.mkdirSync(dir, { recursive: true });
-    fs14.writeFileSync(path16.join(dir, `${cleanName}.Flow.json`), JSON.stringify(workflow, null, 2), "utf-8");
-    return `[flow_save] OK: ${cleanName}.Flow.json`;
+    fs15.mkdirSync(dir, { recursive: true });
+    fs15.writeFileSync(target, JSON.stringify(workflow, null, 2), "utf-8");
+    return `[flow_save] OK (${action}): ${cleanName}.Flow.json`;
   }
   memoryLabRead(selector2) {
     const lab2 = new MemoryLabManager(this.root);
@@ -338281,10 +338429,10 @@ ${String(result.data)}`);
     return this.gh(args, ws, signal);
   }
   async fileAudit(target, ws, includeRemote, baseRef, signal) {
-    const resolvedTarget = path16.resolve(target || ws);
-    const exists = fs14.existsSync(resolvedTarget);
-    const stat = exists ? fs14.statSync(resolvedTarget) : null;
-    const repoRoot = await this.findGitRoot(exists && stat?.isDirectory() ? resolvedTarget : path16.dirname(resolvedTarget), ws, signal);
+    const resolvedTarget = path17.resolve(target || ws);
+    const exists = fs15.existsSync(resolvedTarget);
+    const stat = exists ? fs15.statSync(resolvedTarget) : null;
+    const repoRoot = await this.findGitRoot(exists && stat?.isDirectory() ? resolvedTarget : path17.dirname(resolvedTarget), ws, signal);
     const audit = {
       ok: true,
       target: resolvedTarget,
@@ -338311,11 +338459,11 @@ ${String(result.data)}`);
     };
     if (stat.isFile()) {
       const hash = crypto8.createHash("sha256");
-      hash.update(fs14.readFileSync(target));
+      hash.update(fs15.readFileSync(target));
       base2.sha256 = hash.digest("hex").toUpperCase();
     }
     if (stat.isDirectory()) {
-      base2.entries = fs14.readdirSync(target).slice(0, 200).sort();
+      base2.entries = fs15.readdirSync(target).slice(0, 200).sort();
     }
     return base2;
   }
@@ -338324,14 +338472,14 @@ ${String(result.data)}`);
       const out = await this.gitExecAt(candidate, ["rev-parse", "--show-toplevel"], signal);
       if (!out.startsWith("[git]") && !out.includes("not a git repository")) {
         const root2 = out.split(/\r?\n/)[0].trim();
-        if (root2 && fs14.existsSync(root2)) return path16.resolve(root2);
+        if (root2 && fs15.existsSync(root2)) return path17.resolve(root2);
       }
     }
     return null;
   }
   async gitFileAudit(repoRoot, target, baseRef, signal) {
-    const rel = path16.relative(repoRoot, target).replace(/\\/g, "/");
-    const inside2 = rel === "" || !!rel && !rel.startsWith("..") && !path16.isAbsolute(rel);
+    const rel = path17.relative(repoRoot, target).replace(/\\/g, "/");
+    const inside2 = rel === "" || !!rel && !rel.startsWith("..") && !path17.isAbsolute(rel);
     if (!inside2) return { repository: repoRoot, tracked: false, note: "Path is outside the detected repository." };
     const branch = await this.gitExecAt(repoRoot, ["branch", "--show-current"], signal);
     const status = rel === "" ? await this.gitExecAt(repoRoot, ["status", "--short"], signal) : await this.gitExecAt(repoRoot, ["status", "--short", "--", rel], signal);
@@ -338389,7 +338537,7 @@ ${String(result.data)}`);
   }
   async githubFileAudit(repoRoot, target, remote, signal) {
     const repo = `${remote.owner}/${remote.name}`;
-    const rel = path16.relative(repoRoot, target).replace(/\\/g, "/");
+    const rel = path17.relative(repoRoot, target).replace(/\\/g, "/");
     const branch = (await this.gitExecAt(repoRoot, ["branch", "--show-current"], signal)).trim();
     const encodedPath = rel && rel !== "." ? rel.split("/").map((part) => encodeURIComponent(part)).join("/") : "";
     const repoInfo = await this.ghJson(["api", `repos/${repo}`, "--jq", "{name: .full_name, private: .private, default_branch: .default_branch, fork: .fork, html_url: .html_url}"], repoRoot, signal);
@@ -338413,8 +338561,8 @@ ${String(result.data)}`);
     };
   }
   async repoSecurityAudit(target, ws, baseRef, signal) {
-    const resolvedTarget = path16.resolve(target || ws);
-    const repoRoot = await this.findGitRoot(fs14.existsSync(resolvedTarget) && fs14.statSync(resolvedTarget).isDirectory() ? resolvedTarget : path16.dirname(resolvedTarget), ws, signal);
+    const resolvedTarget = path17.resolve(target || ws);
+    const repoRoot = await this.findGitRoot(fs15.existsSync(resolvedTarget) && fs15.statSync(resolvedTarget).isDirectory() ? resolvedTarget : path17.dirname(resolvedTarget), ws, signal);
     if (!repoRoot) {
       return JSON.stringify({
         ok: true,
@@ -338512,12 +338660,12 @@ ${String(result.data)}`);
     const findings = [];
     for (const rel of Array.from(files).sort()) {
       if (findings.length >= 40) break;
-      const full = path16.join(repoRoot, rel);
-      if (!fs14.existsSync(full) || !fs14.statSync(full).isFile()) continue;
-      if (fs14.statSync(full).size > 512 * 1024) continue;
+      const full = path17.join(repoRoot, rel);
+      if (!fs15.existsSync(full) || !fs15.statSync(full).isFile()) continue;
+      if (fs15.statSync(full).size > 512 * 1024) continue;
       let text = "";
       try {
-        text = fs14.readFileSync(full, "utf-8");
+        text = fs15.readFileSync(full, "utf-8");
       } catch {
         continue;
       }
@@ -338547,12 +338695,12 @@ ${String(result.data)}`);
     const findings = [];
     for (const rel of Array.from(files).sort()) {
       if (findings.length >= 40) break;
-      const full = path16.join(repoRoot, rel);
-      if (!fs14.existsSync(full) || !fs14.statSync(full).isFile()) continue;
-      if (fs14.statSync(full).size > 512 * 1024) continue;
+      const full = path17.join(repoRoot, rel);
+      if (!fs15.existsSync(full) || !fs15.statSync(full).isFile()) continue;
+      if (fs15.statSync(full).size > 512 * 1024) continue;
       let text = "";
       try {
-        text = fs14.readFileSync(full, "utf-8");
+        text = fs15.readFileSync(full, "utf-8");
       } catch {
         continue;
       }
@@ -338569,7 +338717,7 @@ ${String(result.data)}`);
   releaseExcludedPathFindings(repoRoot, ignoredFilesRaw) {
     const sensitive = /^(config\.json|agent\.md|PC_Hash\.config|Work\/|archive\/|skills\/|Memory Lab\/|Design\.md|release\/|_local\/|_ref\/|vendor\/)/i;
     const fromIgnored = String(ignoredFilesRaw || "").split(/\r?\n/).map((line) => line.trim().replace(/\\/g, "/")).filter((line) => line && sensitive.test(line));
-    const direct = ["config.json", "agent.md", "PC_Hash.config", "Work", "archive", "skills", "Memory Lab", "Design.md", "release", "_local", "_ref", "vendor"].filter((rel) => fs14.existsSync(path16.join(repoRoot, rel))).map((rel) => rel.replace(/\\/g, "/"));
+    const direct = ["config.json", "agent.md", "PC_Hash.config", "Work", "archive", "skills", "Memory Lab", "Design.md", "release", "_local", "_ref", "vendor"].filter((rel) => fs15.existsSync(path17.join(repoRoot, rel))).map((rel) => rel.replace(/\\/g, "/"));
     return Array.from(/* @__PURE__ */ new Set([...fromIgnored, ...direct])).slice(0, 80);
   }
   async ghJson(args, ws, signal) {
@@ -339373,8 +339521,8 @@ function sharedSubagentManager(key3, options) {
 }
 
 // src/core/skills.ts
-var fs15 = __toESM(require("fs"));
-var path17 = __toESM(require("path"));
+var fs16 = __toESM(require("fs"));
+var path18 = __toESM(require("path"));
 var os4 = __toESM(require("os"));
 var import_crypto9 = require("crypto");
 var SkillsManager = class {
@@ -339383,13 +339531,13 @@ var SkillsManager = class {
   marketSourcesPath;
   metadataCache = /* @__PURE__ */ new Map();
   constructor(root2) {
-    this.skillsDir = path17.join(root2, "skills");
-    this.metaPath = path17.join(this.skillsDir, ".skills.json");
-    this.marketSourcesPath = path17.join(this.skillsDir, ".market-sources.json");
-    fs15.mkdirSync(this.skillsDir, { recursive: true });
+    this.skillsDir = path18.join(root2, "skills");
+    this.metaPath = path18.join(this.skillsDir, ".skills.json");
+    this.marketSourcesPath = path18.join(this.skillsDir, ".market-sources.json");
+    fs16.mkdirSync(this.skillsDir, { recursive: true });
   }
   list() {
-    return fs15.readdirSync(this.skillsDir, { withFileTypes: true }).filter((e3) => e3.isDirectory() && !e3.name.startsWith(".")).map((e3) => e3.name);
+    return fs16.readdirSync(this.skillsDir, { withFileTypes: true }).filter((e3) => e3.isDirectory() && !e3.name.startsWith(".")).map((e3) => e3.name);
   }
   listDetailed() {
     return this.list().map((name50) => this.infoFor(name50, this.getPath(name50), "project", true));
@@ -339410,48 +339558,48 @@ var SkillsManager = class {
   }
   load(name50) {
     const reference = String(name50 || "").trim().toLowerCase();
-    const skill = this.active().find((item) => item.name.toLowerCase() === reference || path17.basename(item.path).toLowerCase() === reference);
+    const skill = this.active().find((item) => item.name.toLowerCase() === reference || path18.basename(item.path).toLowerCase() === reference);
     if (!skill) return null;
-    const skillPath = path17.join(skill.path, "SKILL.md");
-    const content = fs15.readFileSync(skillPath, "utf-8");
+    const skillPath = path18.join(skill.path, "SKILL.md");
+    const content = fs16.readFileSync(skillPath, "utf-8");
     const files = this.sampleSkillFiles(skill.path, 10);
     return { skill, content, files };
   }
   has(name50) {
-    return fs15.existsSync(path17.join(this.skillsDir, name50, "SKILL.md"));
+    return fs16.existsSync(path18.join(this.skillsDir, name50, "SKILL.md"));
   }
   getPath(name50) {
-    return path17.join(this.skillsDir, name50);
+    return path18.join(this.skillsDir, name50);
   }
   async download(name50, url) {
-    const dir = path17.join(this.skillsDir, name50);
-    fs15.mkdirSync(dir, { recursive: true });
+    const dir = path18.join(this.skillsDir, name50);
+    fs16.mkdirSync(dir, { recursive: true });
     if (!url.startsWith("http")) return `[skill] Not a URL: ${url}`;
     try {
       const resp = await fetch(url);
       const content = await resp.text();
-      fs15.writeFileSync(path17.join(dir, "SKILL.md"), content, "utf-8");
+      fs16.writeFileSync(path18.join(dir, "SKILL.md"), content, "utf-8");
       return `[skill] Downloaded '${name50}'`;
     } catch (e3) {
       return `[skill] ${e3}`;
     }
   }
   installFromLocal(sourceDir, targetName) {
-    const skillPath = path17.join(sourceDir, "SKILL.md");
-    if (!fs15.existsSync(skillPath)) return false;
+    const skillPath = path18.join(sourceDir, "SKILL.md");
+    if (!fs16.existsSync(skillPath)) return false;
     const info = this.parseSkillInfo(sourceDir);
-    const cleanName = this.cleanName(targetName || info.name || path17.basename(sourceDir));
+    const cleanName = this.cleanName(targetName || info.name || path18.basename(sourceDir));
     if (!cleanName) return false;
-    const dest = path17.join(this.skillsDir, cleanName);
-    fs15.rmSync(dest, { recursive: true, force: true });
-    fs15.cpSync(sourceDir, dest, { recursive: true });
+    const dest = path18.join(this.skillsDir, cleanName);
+    fs16.rmSync(dest, { recursive: true, force: true });
+    fs16.cpSync(sourceDir, dest, { recursive: true });
     this.setEnabled(cleanName, true);
     return true;
   }
   remove(name50) {
-    const dir = path17.join(this.skillsDir, name50);
-    if (fs15.existsSync(dir)) {
-      fs15.rmSync(dir, { recursive: true, force: true });
+    const dir = path18.join(this.skillsDir, name50);
+    if (fs16.existsSync(dir)) {
+      fs16.rmSync(dir, { recursive: true, force: true });
       const meta = this.loadMeta();
       meta.disabled = meta.disabled.filter((n3) => n3 !== name50);
       this.saveMeta(meta);
@@ -339500,7 +339648,7 @@ var SkillsManager = class {
       type,
       enabled: input2.enabled !== false,
       url: url || void 0,
-      path: sourcePath ? path17.resolve(sourcePath) : void 0,
+      path: sourcePath ? path18.resolve(sourcePath) : void 0,
       addedAt: existing?.addedAt || now2,
       updatedAt: now2
     };
@@ -339538,17 +339686,17 @@ var SkillsManager = class {
     const items = [];
     for (const info of this.listDetailed()) items.push(info);
     const roots = [
-      { root: path17.join(this.skillsDir, "..", ".agents", "skills"), source: "codex" },
-      { root: path17.join(this.skillsDir, "..", ".claude", "skills"), source: "claude" },
-      { root: path17.join(os4.homedir(), ".agents", "skills"), source: "user" },
-      { root: path17.join(os4.homedir(), ".codex", "skills"), source: "codex" },
-      { root: path17.join(os4.homedir(), ".claude", "skills"), source: "claude" },
-      { root: path17.join(os4.homedir(), ".config", "opencode", "skills"), source: "opencode" }
+      { root: path18.join(this.skillsDir, "..", ".agents", "skills"), source: "codex" },
+      { root: path18.join(this.skillsDir, "..", ".claude", "skills"), source: "claude" },
+      { root: path18.join(os4.homedir(), ".agents", "skills"), source: "user" },
+      { root: path18.join(os4.homedir(), ".codex", "skills"), source: "codex" },
+      { root: path18.join(os4.homedir(), ".claude", "skills"), source: "claude" },
+      { root: path18.join(os4.homedir(), ".config", "opencode", "skills"), source: "opencode" }
     ];
     for (const entry of roots) {
       for (const dir of this.findSkillDirs(entry.root, 4, 240)) {
         const parsed = this.parseSkillInfo(dir);
-        const name50 = this.cleanName(parsed.name || path17.basename(dir));
+        const name50 = this.cleanName(parsed.name || path18.basename(dir));
         if (!name50 || items.some((i4) => i4.name === name50 && i4.source !== "remote")) continue;
         items.push({
           name: name50,
@@ -339565,9 +339713,9 @@ var SkillsManager = class {
         });
       }
     }
-    for (const dir of this.findPluginSkillDirs(path17.join(this.skillsDir, ".."), 5, 240)) {
+    for (const dir of this.findPluginSkillDirs(path18.join(this.skillsDir, ".."), 5, 240)) {
       const parsed = this.parseSkillInfo(dir);
-      const name50 = this.cleanName(parsed.name || path17.basename(dir));
+      const name50 = this.cleanName(parsed.name || path18.basename(dir));
       if (!name50 || items.some((i4) => i4.name === name50 && i4.source !== "remote")) continue;
       items.push({
         name: name50,
@@ -339624,8 +339772,8 @@ var SkillsManager = class {
   }
   loadMeta() {
     try {
-      if (fs15.existsSync(this.metaPath)) {
-        const raw = JSON.parse(fs15.readFileSync(this.metaPath, "utf-8"));
+      if (fs16.existsSync(this.metaPath)) {
+        const raw = JSON.parse(fs16.readFileSync(this.metaPath, "utf-8"));
         return { disabled: Array.isArray(raw.disabled) ? raw.disabled.map(String) : [] };
       }
     } catch {
@@ -339633,7 +339781,7 @@ var SkillsManager = class {
     return { disabled: [] };
   }
   saveMeta(meta) {
-    fs15.writeFileSync(this.metaPath, JSON.stringify({ disabled: meta.disabled }, null, 2), "utf-8");
+    fs16.writeFileSync(this.metaPath, JSON.stringify({ disabled: meta.disabled }, null, 2), "utf-8");
   }
   builtinMarketSources() {
     return [{
@@ -339647,8 +339795,8 @@ var SkillsManager = class {
   }
   loadMarketSources() {
     try {
-      if (!fs15.existsSync(this.marketSourcesPath)) return [];
-      const raw = JSON.parse(fs15.readFileSync(this.marketSourcesPath, "utf-8"));
+      if (!fs16.existsSync(this.marketSourcesPath)) return [];
+      const raw = JSON.parse(fs16.readFileSync(this.marketSourcesPath, "utf-8"));
       if (!Array.isArray(raw.sources)) return [];
       return raw.sources.map((source) => this.normalizeMarketSource(source)).filter((source) => !!source);
     } catch {
@@ -339657,7 +339805,7 @@ var SkillsManager = class {
   }
   saveMarketSources(sources) {
     const normalized = sources.filter((s3) => !s3.builtin).map((s3) => this.normalizeMarketSource(s3)).filter((source) => !!source);
-    fs15.writeFileSync(this.marketSourcesPath, JSON.stringify({ sources: normalized }, null, 2), "utf-8");
+    fs16.writeFileSync(this.marketSourcesPath, JSON.stringify({ sources: normalized }, null, 2), "utf-8");
   }
   normalizeMarketSource(raw) {
     if (!raw || typeof raw !== "object") return null;
@@ -339677,7 +339825,7 @@ var SkillsManager = class {
       type,
       enabled: source.enabled !== false,
       url: url || void 0,
-      path: sourcePath ? path17.resolve(sourcePath) : void 0,
+      path: sourcePath ? path18.resolve(sourcePath) : void 0,
       builtin: source.builtin === true,
       addedAt: source.addedAt ? String(source.addedAt) : void 0,
       updatedAt: source.updatedAt ? String(source.updatedAt) : void 0
@@ -339728,11 +339876,11 @@ var SkillsManager = class {
     return rawItems.slice(0, 1e3).map((entry) => this.marketInfoFromCatalogEntry(entry, source, installed)).filter((item) => !!item);
   }
   readCatalogText(source) {
-    const catalogPath = source.path ? path17.resolve(source.path) : "";
-    if (catalogPath && fs15.existsSync(catalogPath)) return fs15.readFileSync(catalogPath, "utf-8");
+    const catalogPath = source.path ? path18.resolve(source.path) : "";
+    if (catalogPath && fs16.existsSync(catalogPath)) return fs16.readFileSync(catalogPath, "utf-8");
     const url = source.url || "";
-    if (url.startsWith("file://")) return fs15.readFileSync(new URL(url), "utf-8");
-    if (url && !url.startsWith("http")) return fs15.readFileSync(path17.resolve(url), "utf-8");
+    if (url.startsWith("file://")) return fs16.readFileSync(new URL(url), "utf-8");
+    if (url && !url.startsWith("http")) return fs16.readFileSync(path18.resolve(url), "utf-8");
     return "";
   }
   async discoverJsonMarketSourceAsync(source, installed) {
@@ -339792,7 +339940,7 @@ var SkillsManager = class {
   }
   marketInfoFromLocalDir(dir, source, installed) {
     const parsed = this.parseSkillInfo(dir);
-    const name50 = this.cleanName(parsed.name || path17.basename(dir));
+    const name50 = this.cleanName(parsed.name || path18.basename(dir));
     if (!name50) return null;
     return {
       name: name50,
@@ -339817,9 +339965,9 @@ var SkillsManager = class {
   }
   parseSkillInfo(dir) {
     try {
-      const skillPath = path17.join(dir, "SKILL.md");
-      const stat = fs15.statSync(skillPath);
-      const content = fs15.readFileSync(skillPath, "utf-8");
+      const skillPath = path18.join(dir, "SKILL.md");
+      const stat = fs16.statSync(skillPath);
+      const content = fs16.readFileSync(skillPath, "utf-8");
       const digest = (0, import_crypto9.createHash)("sha256").update(content).digest("hex");
       const fingerprint2 = `${stat.mtimeMs}:${stat.size}:${digest}`;
       const cached = this.metadataCache.get(skillPath);
@@ -339852,7 +340000,7 @@ var SkillsManager = class {
       };
       this.metadataCache.set(skillPath, {
         fingerprint: fingerprint2,
-        info: { ...parsed, path: dir, enabled: this.isEnabled(path17.basename(dir)), installed: true, source: "project" }
+        info: { ...parsed, path: dir, enabled: this.isEnabled(path18.basename(dir)), installed: true, source: "project" }
       });
       return parsed;
     } catch {
@@ -339869,13 +340017,13 @@ var SkillsManager = class {
       if (files.length >= limit || depth > 2) return;
       let entries = [];
       try {
-        entries = fs15.readdirSync(dir, { withFileTypes: true });
+        entries = fs16.readdirSync(dir, { withFileTypes: true });
       } catch {
         return;
       }
       for (const entry of entries) {
         if (files.length >= limit || entry.name === "SKILL.md" || entry.name.startsWith(".")) continue;
-        const target = path17.join(dir, entry.name);
+        const target = path18.join(dir, entry.name);
         if (entry.isDirectory()) walk4(target, depth + 1);
         else if (entry.isFile()) files.push(target);
       }
@@ -339889,7 +340037,7 @@ var SkillsManager = class {
       if (results.length >= maxItems || depth > maxDepth) return;
       let entries;
       try {
-        entries = fs15.readdirSync(dir, { withFileTypes: true });
+        entries = fs16.readdirSync(dir, { withFileTypes: true });
       } catch {
         return;
       }
@@ -339899,7 +340047,7 @@ var SkillsManager = class {
       }
       for (const e3 of entries) {
         if (!e3.isDirectory() || e3.name.startsWith(".git") || e3.name === "node_modules") continue;
-        walk4(path17.join(dir, e3.name), depth + 1);
+        walk4(path18.join(dir, e3.name), depth + 1);
       }
     };
     walk4(root2, 0);
@@ -339911,19 +340059,19 @@ var SkillsManager = class {
       if (results.length >= maxItems || depth > maxDepth) return;
       let entries;
       try {
-        entries = fs15.readdirSync(dir, { withFileTypes: true });
+        entries = fs16.readdirSync(dir, { withFileTypes: true });
       } catch {
         return;
       }
       const hasPluginManifest = entries.some((e3) => e3.isDirectory() && (e3.name === ".codex-plugin" || e3.name === ".claude-plugin"));
       if (hasPluginManifest) {
         for (const skillsDir of ["skills", "Skills"]) {
-          results.push(...this.findSkillDirs(path17.join(dir, skillsDir), 3, maxItems - results.length));
+          results.push(...this.findSkillDirs(path18.join(dir, skillsDir), 3, maxItems - results.length));
         }
       }
       for (const e3 of entries) {
         if (!e3.isDirectory() || e3.name.startsWith(".git") || e3.name === "node_modules" || e3.name === "release" || e3.name.startsWith("release.locked-")) continue;
-        walk4(path17.join(dir, e3.name), depth + 1);
+        walk4(path18.join(dir, e3.name), depth + 1);
       }
     };
     walk4(root2, 0);
@@ -339951,25 +340099,25 @@ var SkillsManager = class {
     if (!description) warnings.push("Missing required frontmatter field: description.");
     if (name50 && !/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,119}$/.test(name50)) warnings.push("Skill name contains characters outside the portable Agent Skills subset.");
     if (description && description.length > 1e3) warnings.push("Description is longer than recommended for skill discovery.");
-    const folderName = path17.basename(dir);
+    const folderName = path18.basename(dir);
     if (name50 && folderName && this.cleanName(name50) !== this.cleanName(folderName)) warnings.push("Skill name does not match containing folder name.");
     return warnings;
   }
   pluginIdForSkill(dir) {
-    let current = path17.resolve(dir);
+    let current = path18.resolve(dir);
     for (let i4 = 0; i4 < 6; i4++) {
-      const codex = path17.join(current, ".codex-plugin", "plugin.json");
-      const claude = path17.join(current, ".claude-plugin", "plugin.json");
+      const codex = path18.join(current, ".codex-plugin", "plugin.json");
+      const claude = path18.join(current, ".claude-plugin", "plugin.json");
       for (const filePath of [codex, claude]) {
         try {
-          if (fs15.existsSync(filePath)) {
-            const raw = JSON.parse(fs15.readFileSync(filePath, "utf-8"));
+          if (fs16.existsSync(filePath)) {
+            const raw = JSON.parse(fs16.readFileSync(filePath, "utf-8"));
             if (raw?.name) return String(raw.name);
           }
         } catch {
         }
       }
-      const parent = path17.dirname(current);
+      const parent = path18.dirname(current);
       if (parent === current) break;
       current = parent;
     }
@@ -340515,6 +340663,22 @@ function createToolchainCore() {
   return { registry: new ToolRegistry(), catalog: new CapabilityCatalog() };
 }
 
+// src/core/emptyResponseRetry.ts
+var EMPTY_RESPONSE_RETRY_DELAYS_MS = [200, 800, 2e3, 1e4, 6e4];
+var MAX_EMPTY_RESPONSE_RETRIES = EMPTY_RESPONSE_RETRY_DELAYS_MS.length;
+var MAX_CONSECUTIVE_EMPTY_RESPONSES = MAX_EMPTY_RESPONSE_RETRIES + 1;
+function emptyResponseRetryDelayMs(consecutiveEmptyResponses) {
+  return EMPTY_RESPONSE_RETRY_DELAYS_MS[Math.max(0, consecutiveEmptyResponses - 1)] ?? 0;
+}
+function observeEmptyResponseOutcome(consecutiveEmptyResponses, emptyResponse) {
+  const nextCount = emptyResponse ? consecutiveEmptyResponses + 1 : 0;
+  return {
+    consecutiveEmptyResponses: nextCount,
+    retry: emptyResponse && nextCount <= MAX_EMPTY_RESPONSE_RETRIES,
+    terminate: emptyResponse && nextCount > MAX_EMPTY_RESPONSE_RETRIES
+  };
+}
+
 // src/core/agentKernelRunner.ts
 var publicStreamFilters = /* @__PURE__ */ new WeakMap();
 var brokerOnlyAssistantBuffers = /* @__PURE__ */ new WeakMap();
@@ -340666,7 +340830,7 @@ function kernelTurnFailed(agent, turn) {
   return turn.stopReason === "error" || agent.isLlmErrorText(turn.text);
 }
 function providerTurnIsEmpty(turn) {
-  return /provider returned an empty response/i.test(`${turn.errorMessage}
+  return !turn.activity && /provider returned an empty response/i.test(`${turn.errorMessage}
 ${turn.text}`);
 }
 function removeTrailingFailedAssistant(agent, messages) {
@@ -340675,6 +340839,12 @@ function removeTrailingFailedAssistant(agent, messages) {
   const text = KernelMessageText(last);
   if (last.stopReason === "error" || agent.isLlmErrorText(text)) messages.pop();
 }
+function removeTrailingThoughtOnlyAssistant(messages) {
+  const last = messages[messages.length - 1];
+  if (last?.role !== "assistant") return;
+  const hasToolCall = last.content.some((content) => content.type === "toolCall");
+  if (!KernelMessageText(last).trim() && !hasToolCall) messages.pop();
+}
 function normalizePublicProviderError(error, secrets = []) {
   let raw = "";
   if (error instanceof Error) {
@@ -340800,8 +340970,17 @@ async function runAgentKernel(agent) {
   const tokens = [];
   const runOnce = async (promptMessages, appendPromptToAgentHistory) => {
     let lastAssistant = null;
+    let observedActivity = false;
+    let observedThought = false;
     const unsubscribe = kernel2.subscribe(async (event) => {
       await handleKernelEvent(agent, event, tokens);
+      if (event.type === "message_update") {
+        const delta = event.assistantMessageEvent;
+        const deltaText = typeof delta.delta === "string" ? delta.delta : "";
+        const thoughtDelta = delta.type === "thinking_delta" && !!deltaText.trim();
+        observedThought = observedThought || thoughtDelta;
+        observedActivity = observedActivity || thoughtDelta || delta.type === "text_delta" && !!deltaText.trim() || delta.type === "toolcall_end";
+      }
       if (event.type === "message_end" && event.message.role === "assistant") {
         lastAssistant = event.message;
       }
@@ -340819,11 +340998,13 @@ async function runAgentKernel(agent) {
       const assistant = lastAssistant;
       const text = assistant ? KernelMessageText(assistant) : "";
       const hasToolCall = !!assistant?.content?.some((content) => content.type === "toolCall");
-      const emptyResponse = !assistant || !text.trim() && !hasToolCall && String(assistant?.stopReason || "") !== "aborted";
+      const emptyResponse = !assistant || !text.trim() && !hasToolCall && !observedActivity && String(assistant?.stopReason || "") !== "aborted";
       return {
         text: emptyResponse ? "[Error] Provider returned an empty response." : text,
         stopReason: String(assistant?.stopReason || ""),
-        errorMessage: String(assistant?.errorMessage || (emptyResponse ? "Provider returned an empty response." : ""))
+        errorMessage: String(assistant?.errorMessage || (emptyResponse ? "Provider returned an empty response." : "")),
+        activity: observedActivity || !!text.trim() || hasToolCall,
+        thoughtOnly: observedThought && !text.trim() && !hasToolCall && !["error", "aborted"].includes(String(assistant?.stopReason || ""))
       };
     } finally {
       unsubscribe();
@@ -340869,14 +341050,22 @@ async function runAgentKernel(agent) {
         fallback: { from: modelBeforeKernelRun, to: agent.model, providerId: agent.activeDeployment()?.providerId }
       });
     }
-    let emptyResponseRetries = 0;
-    while (providerTurnIsEmpty(lastTurn) && emptyResponseRetries < 2) {
+    let consecutiveEmptyResponses = 0;
+    for (; ; ) {
+      const emptyResponseState = observeEmptyResponseOutcome(consecutiveEmptyResponses, providerTurnIsEmpty(lastTurn));
+      consecutiveEmptyResponses = emptyResponseState.consecutiveEmptyResponses;
+      if (lastTurn.thoughtOnly) {
+        removeTrailingThoughtOnlyAssistant(kernel2.state.messages);
+        lastTurn = await runWithCompressionResume([], false);
+        continue;
+      }
+      if (!emptyResponseState.retry) break;
       removeTrailingFailedAssistant(agent, kernel2.state.messages);
-      emptyResponseRetries += 1;
-      const notice = `[Model retry] Provider returned an empty response; retrying the same deployment (${emptyResponseRetries}/2).`;
+      const retryNumber = consecutiveEmptyResponses;
+      const notice = `[Model retry] Provider returned an empty response; retrying the same deployment (${retryNumber}/${MAX_EMPTY_RESPONSE_RETRIES}) after ${emptyResponseRetryDelayMs(consecutiveEmptyResponses)}ms.`;
       tokens.push({ type: "text", text: notice });
       agent.recordWorkStatus(notice);
-      await agent.waitForPlannedRouteRetry();
+      await agent.waitForPlannedRouteRetry(emptyResponseRetryDelayMs(consecutiveEmptyResponses));
       lastTurn = await runWithCompressionResume([], false);
     }
     let routeRetries = 0;
@@ -341072,7 +341261,7 @@ async function runAgentKernel(agent) {
             return;
           }
           if (textStarted) finalContent.push({ type: "text", text });
-          if (!finalContent.length) {
+          if (!finalContent.length && !thinking.trim()) {
             text = "[Error] Provider returned an empty response.";
             finalContent.push({ type: "text", text });
           }
@@ -344956,7 +345145,7 @@ var Agent4 = class _Agent {
       this.config.set("skills", "auto_download", "disabled");
     }
     const modeStr = this.config.getStr("agent", "default_mode");
-    this.mode = ["plan", "goal", "flow"].includes(modeStr) ? modeStr : "build";
+    this.mode = ["plan", "chat", "goal", "flow"].includes(modeStr) ? modeStr : "build";
     const inputStr = this.config.getStr("general", "default_input");
     this.inputMode = inputStr === "next" ? "next" : "guide";
     const configuredModel = this.config.getStr("models", "default_model");
@@ -345124,6 +345313,7 @@ var Agent4 = class _Agent {
     return this.toolchainCore;
   }
   setMode(m2) {
+    if (!["build", "plan", "chat", "goal", "flow"].includes(m2)) m2 = "build";
     if (m2 === "goal" && !this.goal) {
       this.goal = new GoalStateImpl("Set your objective");
     }
@@ -345656,7 +345846,12 @@ var Agent4 = class _Agent {
   beginRouteAttempt() {
     this.routeAttemptStartedAt = Date.now();
   }
-  async waitForPlannedRouteRetry() {
+  async waitForPlannedRouteRetry(explicitDelayMs) {
+    if (explicitDelayMs !== void 0) {
+      if (explicitDelayMs <= 0) return;
+      await new Promise((resolve16) => setTimeout(resolve16, explicitDelayMs));
+      return;
+    }
     const waitBudgetMs = Math.max(0, Math.min(15e3, this.lastRouteDecision?.retryBudgetMs ?? 5e3));
     const delay = Math.max(0, Math.min(waitBudgetMs, this.lastRouteRetryDelayMs));
     this.lastRouteRetryDelayMs = 0;
@@ -349486,7 +349681,20 @@ ${summary}`, segment, "local-summarize", true);
       if (action === "get") return JSON.stringify({ ok: true, linkedPlan: this.getLinkedPlan() }, null, 2);
       if (action !== "update") return JSON.stringify({ ok: false, error: `Unknown linked_plan action: ${action}` });
       const expectedRevision = Number(input2.expected_revision ?? input2.expectedRevision);
-      return JSON.stringify({ ok: true, linkedPlan: this.updateLinkedPlan(String(input2.markdown || ""), expectedRevision) }, null, 2);
+      const current = this.getLinkedPlan();
+      let markdown = input2.markdown === void 0 ? current.markdown : String(input2.markdown);
+      if (input2.append !== void 0) markdown = `${current.markdown}${String(input2.append)}`;
+      if (input2.old_text !== void 0 || input2.oldText !== void 0) {
+        const oldText = String(input2.old_text ?? input2.oldText ?? "");
+        if (!oldText) throw new Error("linked_plan old_text must not be empty.");
+        const matches = current.markdown.split(oldText).length - 1;
+        if (!matches) throw new Error("linked_plan old_text was not found.");
+        const replaceAll = input2.replace_all === true || input2.replaceAll === true;
+        if (matches > 1 && !replaceAll) throw new Error(`linked_plan old_text matched ${matches} places; pass replace_all=true or a unique fragment.`);
+        const newText = String(input2.new_text ?? input2.newText ?? "");
+        markdown = replaceAll ? current.markdown.split(oldText).join(newText) : current.markdown.replace(oldText, newText);
+      }
+      return JSON.stringify({ ok: true, linkedPlan: this.updateLinkedPlan(markdown, expectedRevision) }, null, 2);
     } catch (error) {
       return JSON.stringify({ ok: false, error: error instanceof Error ? error.message : String(error) });
     }
@@ -351788,7 +351996,24 @@ ${this.formatAutomation(item)}` : `[automation_toggle] Not found: ${id}`;
           }));
         }
         case "memory_lab_update": {
-          const result = await this.updateMemoryLab({
+          const selector2 = String(params.component || params.slug || "").trim();
+          const prepared = selector2 ? this.memoryLab.preparePatch({
+            component: selector2,
+            name: params.name === void 0 ? void 0 : String(params.name),
+            description: params.description === void 0 ? void 0 : String(params.description),
+            tags: params.tags === void 0 ? void 0 : Array.isArray(params.tags) ? params.tags.map(String) : String(params.tags).split(/[,，\n]+/),
+            tagPaths: params.tagPaths === void 0 ? void 0 : Array.isArray(params.tagPaths) ? params.tagPaths.filter(Array.isArray).map((pathValue) => pathValue.map(String)) : [],
+            content: params.content === void 0 ? void 0 : String(params.content),
+            contentAppend: params.contentAppend === void 0 && params.content_append === void 0 ? void 0 : String(params.contentAppend ?? params.content_append),
+            oldText: params.oldText === void 0 && params.old_text === void 0 ? void 0 : String(params.oldText ?? params.old_text),
+            newText: String(params.newText ?? params.new_text ?? ""),
+            replaceAll: params.replaceAll === true || params.replace_all === true,
+            kind: params.kind === void 0 ? void 0 : params.kind === "folder" ? "folder" : "file",
+            expectedUpdatedAt: String(params.expectedUpdatedAt || params.expected_updated_at || ""),
+            reason: String(params.reason || ""),
+            source: String(params.source || "")
+          }) : void 0;
+          const result = await this.updateMemoryLab(prepared || {
             name: String(params.name || ""),
             description: String(params.description || ""),
             tags: Array.isArray(params.tags) ? params.tags.map(String) : String(params.tags || "").split(/[,，\n]+/),
@@ -352791,6 +353016,8 @@ When using file tools (read, write, edit, glob), use ABSOLUTE paths rooted at th
     parts.push(this.buildFeatureDisclosurePrompt());
     if (this.mode === "plan") parts.push(`[Plan Tool Policy]
 ${planModePolicyPrompt()}`);
+    if (this.mode === "chat") parts.push(`[Chat Tool Policy]
+${chatModePolicyPrompt()}`);
     const pm = this.config.getStr("workspace", "prompt_mode") || "both";
     const injectedPrompts = /* @__PURE__ */ new Set();
     if ((pm === "global_only" || pm === "both") && globalPrompt) {
@@ -352912,7 +353139,7 @@ ${custom}`);
       `- Language policy: general.language=${language}; the UI can switch this at runtime and each turn must obey the current value. auto follows the user's dominant input language, en replies in English, zh replies in Simplified Chinese. Keep code, commands, file paths, JSON keys, model/provider names, tool names, quoted source text, and user-provided literals exactly as required by their source language.`,
       `- Workspace permissions: access_permission=${permission}; file tools are checked before execution and blocked when they exceed the configured workspace boundary.`,
       `- Remote repository safety: when the active workspace or any target path is inside a GitHub/remote-backed repository, proactively use repo_security_audit and file_audit before git_push, gh_pr_create, release packaging, public reporting, or cloud-side audit. Treat public remotes as public disclosure surfaces and keep private URLs, secrets, privacy addresses (credential URLs, private network addresses, local user paths), local runtime state, archives, Memory Lab, Work, config, and release outputs out of commits and summaries. git_push/gh_pr_create hard-block on detected high-risk findings until a second review resolves them and the action is retried with security_review_confirmed=true.`,
-      `- Mode engine: current mode=${this.modeName()}; Build works autonomously, Plan is fully read-only with no file modifications, Goal continues until completion unless paused, Flow follows saved workflow components.`,
+      `- Mode engine: current mode=${this.modeName()}; Build works autonomously, Plan is fully read-only, Chat only performs web search/fetch evidence gathering and prompt synthesis, Goal continues until completion unless paused, Flow follows saved workflow components.`,
       `- Input mode: ${input2}; Guide injects immediately, Next queues user intent for the following build turn.`,
       `- Option feedback: ${this.buildQuestionPolicyPrompt(optionFeedback)}`,
       `- Model policy: current model=${this.model || "(unset)"}, intelligence=${this.intelligence}, auto-switch=${modelSwitch}.`,
@@ -352978,6 +353205,14 @@ ${custom}`);
           'Only after the durable linked plan has actually been updated and the plan is complete, expose the fixed mode handoff asking whether execution should begin. Offer exactly these two choices in the user language: "\u662F\uFF0C\u6267\u884C\u6B64\u8BA1\u5212" / "\u5426\uFF0C\u8BF7\u8865\u5145____" (or "Yes, execute this plan" / "No, please supplement _____"). This fixed handoff remains required when discretionary questions are disabled.',
           "A positive choice starts a new Build-mode input. A negative choice remains in Plan mode so the user can supply the missing details."
         ]).join("\n");
+      case "chat":
+        return withLanguage([
+          "CHAT MODE.",
+          "Use only web_search and web_fetch. You have no workspace, host, application, memory, task, browser-control, or write permissions.",
+          "Perform an online search to gather evidence before answering. Fetch primary or authoritative pages when the search snippets are insufficient.",
+          "After sufficient evidence is collected, summarize and answer the user as soon as possible. Stay concise and do not turn the request into a long-running Build, Plan, Goal, or Flow task.",
+          "Distinguish sourced facts from uncertainty and include useful source links in the final answer."
+        ]).join("\n");
       case "goal": {
         const g2 = this.goal?.history() || "";
         const paused = this.goal?.paused ? "\n[GOAL PAUSED by user. Wait for resume.]" : "\n[Continue working until the goal is achieved.]";