magpie-agent-console 1.2.0 → 1.3.1

package/daemon/dist/main.js

@@ -146,6 +146,9 @@ var init_i18n = __esm({
         "notice.daemonRestart": "\u540E\u53F0\u5DF2\u91CD\u542F\uFF0C\u672C\u8F6E\u5DF2\u4E2D\u65AD",
         "notice.sessionStartFailed": "\u4F1A\u8BDD\u542F\u52A8\u5931\u8D25\uFF1A{detail}",
         "notice.sendFailed": "\u53D1\u9001\u5931\u8D25\uFF1A{detail}",
+        "notice.bashMissing": "\u6CA1\u6709\u627E\u5230 Git Bash\u3002\u8FD9\u4E2A Agent \u5728 Windows \u4E0A\u8981\u7528 Git Bash \u8FD0\u884C\u547D\u4EE4\uFF08C:\\Windows\\System32\\bash.exe \u662F WSL \u542F\u52A8\u5668\uFF0C\u4E0D\u80FD\u7528\uFF09\u3002\u8BF7\u5B89\u88C5 Git for Windows\uFF1Ahttps://git-scm.com/download/win \uFF0C\u6216\u5728\u300C\u8BBE\u7F6E \u2192 Bash \u8DEF\u5F84\u300D\u91CC\u624B\u52A8\u6307\u5B9A bash.exe\u3002",
+        "notice.autoApproveUpgrade": "1.3 \u65B0\u589E\u300C\u5168\u90E8\u81EA\u52A8\u540C\u610F\u300D\uFF1A\u73B0\u5728\u5BF9 Cursor\u3001OpenCode\u3001dsh \u4E5F\u4F1A\u771F\u6B63\u81EA\u52A8\u540C\u610F\uFF081.2 \u7684\u300C\u5168\u90E8\u653E\u884C\u300D\u5BF9\u5B83\u4EEC\u4E0D\u751F\u6548\uFF0C\u4ECD\u4F1A\u8BE2\u95EE\uFF09\u3002\u4F60\u4E4B\u524D\u628A\u9ED8\u8BA4\u6743\u9650\u6A21\u5F0F\u8BBE\u6210\u4E86\u5B83\uFF0C\u4E3A\u5B89\u5168\u8D77\u89C1\u8FD9\u4E2A\u5BF9\u8BDD\u4ECD\u4ECE\u300C\u6BCF\u6B21\u8BE2\u95EE\u300D\u5F00\u59CB\uFF1B\u9700\u8981\u65F6\u8BF7\u5728\u4E0B\u65B9\u6743\u9650\u83DC\u5355\u91CC\u624B\u52A8\u5F00\u542F\uFF0C\u6216\u5728\u8BBE\u7F6E\u91CC\u91CD\u65B0\u9009\u62E9\u9ED8\u8BA4\u6743\u9650\u6A21\u5F0F\u3002",
+        "notice.autoApproveMigrated": "\u8FD9\u4E2A\u5BF9\u8BDD\u5728 1.2 \u91CC\u8BBE\u6210\u4E86\u300C\u5168\u90E8\u653E\u884C\u300D\uFF0C\u5F53\u65F6\u8FD9\u4E2A Agent \u5B9E\u9645\u4ECD\u4F1A\u8BE2\u95EE\u30021.3 \u8D77\u300C\u5168\u90E8\u81EA\u52A8\u540C\u610F\u300D\u4F1A\u771F\u6B63\u81EA\u52A8\u540C\u610F\uFF0C\u6240\u4EE5\u5DF2\u6539\u56DE\u300C\u6BCF\u6B21\u8BE2\u95EE\u300D\uFF1B\u9700\u8981\u65F6\u8BF7\u5728\u4E0B\u65B9\u6743\u9650\u83DC\u5355\u91CC\u624B\u52A8\u5F00\u542F\u3002",
         "notice.effortNextTurn": "\u601D\u8003\u5F3A\u5EA6\u5DF2\u4FDD\u5B58\uFF0C\u5C06\u5728\u4E0B\u4E00\u8F6E\u751F\u6548",
         "notice.effortResetOnModel": "\u5F53\u524D\u6A21\u578B\u4E0D\u652F\u6301\u8BE5\u601D\u8003\u5F3A\u5EA6\uFF0C\u5DF2\u6062\u590D\u4E3A Default",
         "turn.agentExit": "Agent \u8FDB\u7A0B\u610F\u5916\u9000\u51FA",
@@ -256,6 +259,9 @@ var init_i18n = __esm({
         "notice.daemonRestart": "Daemon restarted \u2014 this turn was interrupted",
         "notice.sessionStartFailed": "Session start failed: {detail}",
         "notice.sendFailed": "Send failed: {detail}",
+        "notice.bashMissing": "Git Bash was not found. On Windows this agent runs its commands with Git Bash (C:\\Windows\\System32\\bash.exe is the WSL launcher and won't work). Install Git for Windows: https://git-scm.com/download/win , or set bash.exe under Settings \u2192 Bash path.",
+        "notice.autoApproveUpgrade": "New in 1.3: Auto-approve all now really auto-approves for Cursor, OpenCode and dsh too (1.2's bypass mode did nothing for them; they still asked). Your default permission mode was set to it, so to be safe this conversation starts in Always Ask; switch it on in the permission menu below if you want it, or pick the default permission mode again in Settings.",
+        "notice.autoApproveMigrated": "This conversation was set to bypass permissions in 1.2, where this agent still asked anyway. From 1.3 Auto-approve all really auto-approves, so it was put back to Always Ask; switch it on in the permission menu below if you want it.",
         "notice.effortNextTurn": "Reasoning effort saved \u2014 takes effect on the next turn",
         "notice.effortResetOnModel": "This model does not support that effort level; reset to Default",
         "turn.agentExit": "Agent process exited unexpectedly",
@@ -711,12 +717,7 @@ async function scriptPlan(ctx) {
   emit({
     type: "plan",
     itemId: "plan1",
-    markdown: "## \u5B9E\u65BD\u8BA1\u5212\n\n1. \u6539 `src/index.ts` \u5165\u53E3\n2. \u66F4\u65B0\u6D4B\u8BD5\n3. \u8DD1\u4E00\u904D e2e",
-    entries: [
-      { step: "\u6539 src/index.ts \u5165\u53E3", status: "pending" },
-      { step: "\u66F4\u65B0\u6D4B\u8BD5", status: "pending" },
-      { step: "\u8DD1\u4E00\u904D e2e", status: "pending" }
-    ]
+    markdown: "## \u5B9E\u65BD\u8BA1\u5212\n\n1. \u6539 `src/index.ts` \u5165\u53E3\n2. \u66F4\u65B0\u6D4B\u8BD5\n3. \u8DD1\u4E00\u904D e2e"
   });
   const requestId = "perm-" + rid();
   emit({
@@ -808,6 +809,10 @@ function pickScript(text) {
   if (t.startsWith("/long")) return scriptLong;
   if (t.startsWith("/exit")) return scriptExit;
   if (t.startsWith("/serve")) return scriptServe;
+  if (t.startsWith("/tools")) return scriptTools;
+  if (t.startsWith("/bashhint")) return scriptBashHint;
+  if (t.startsWith("/winrun")) return scriptWinRun;
+  if (t.startsWith("/tasks")) return scriptTasks;
   return scriptDefault;
 }
 async function sleepAbortable(ms, ctx) {
@@ -823,6 +828,166 @@ function chunkText(s, n) {
   for (let i = 0; i < s.length; i += n) out.push(s.slice(i, i + n));
   return out;
 }
+async function scriptTools(ctx) {
+  const { emit } = ctx;
+  const sleepA = (ms) => sleepAbortable(ms, ctx);
+  const tool = async (id2, kind, title, input, end, ms = 150) => {
+    emit({ type: "tool_call", itemId: id2, kind, title, status: "running", input });
+    if (await sleepA(ms)) return true;
+    emit({ type: "tool_call", itemId: id2, kind, title, status: "ok", durationMs: ms, ...end });
+    return false;
+  };
+  emit({ type: "reasoning", itemId: "tr1", text: "\u5148\u770B\u4E00\u4E0B\u6D4B\u8BD5\u548C\u914D\u7F6E\u3002" });
+  if (await tool("x1", "read", "\u8BFB\u53D6 package.json", { file_path: "package.json" }, { output: "{\u2026}" })) return;
+  if (await tool("x2", "search", '\u641C\u7D22 "describe("', { pattern: "describe(" }, { output: "12 \u5904\u5339\u914D" })) return;
+  emit({ type: "reasoning", itemId: "tr2", text: "" });
+  if (await tool("x3", "read", "\u8BFB\u53D6 test/app.test.ts", { file_path: "test/app.test.ts" }, { output: "\u2026" })) return;
+  if (await tool("x3b", "read", "\u8BFB\u53D6 test/server.test.ts", { file_path: "test/server.test.ts" }, { output: "\u2026" })) return;
+  if (await tool("x3c", "search", '\u641C\u7D22 "createServer"', { pattern: "createServer" }, { output: "3 \u5904\u5339\u914D" })) return;
+  emit({ type: "tool_call", itemId: "x4", kind: "bash", title: "\u8FD0\u884C npm run lint", status: "running", input: { command: "npm run lint" } });
+  if (await sleepA(200)) return;
+  emit({
+    type: "tool_call",
+    itemId: "x4",
+    kind: "bash",
+    title: "\u8FD0\u884C npm run lint",
+    status: "failed",
+    exitCode: 1,
+    durationMs: 200,
+    output: "src/app.ts:12:7  error  'unused' is assigned a value but never used  no-unused-vars\n\n\u2716 1 problem (1 error, 0 warnings)"
+  });
+  const oldStr = "const unused = 1;\nexport const app = 2;";
+  const newStr = "export const app = 2;";
+  if (await tool(
+    "x5",
+    "edit",
+    "\u7F16\u8F91 src/app.ts",
+    { file_path: "src/app.ts", old_string: oldStr, new_string: newStr },
+    { detail: editDetail({ path: "src/app.ts", old: oldStr, new: newStr }) }
+  )) return;
+  emit({ type: "reasoning", itemId: "tr3", text: "lint \u4FEE\u597D\u4E86\uFF0C\u518D\u8DD1\u4E00\u904D\u5B8C\u6574\u6D4B\u8BD5\u3002" });
+  const cmd = "npm test -- --reporter=verbose --coverage --run test/app.test.ts test/server.test.ts test/client.test.ts";
+  emit({ type: "tool_call", itemId: "x6", kind: "bash", title: `\u8FD0\u884C ${cmd}`, status: "running", input: { command: cmd } });
+  const slow = Number(process.env.AGENT_CONSOLE_MOCK_TOOLS_MS) || 2500;
+  if (await sleepA(slow)) return;
+  emit({ type: "tool_call", itemId: "x6", kind: "bash", title: `\u8FD0\u884C ${cmd}`, status: "ok", output: "\u2713 3 \u4E2A\u6D4B\u8BD5\u6587\u4EF6\u901A\u8FC7", exitCode: 0, durationMs: slow });
+  const reply = ctx.replyPrefix() + "lint \u62A5\u9519\u5DF2\u4FEE\u590D\uFF0C\u6D4B\u8BD5\u5168\u90E8\u901A\u8FC7\u3002";
+  emit({ type: "assistant_message", itemId: "tm1", text: reply });
+}
+async function scriptWinRun(ctx) {
+  const { emit } = ctx;
+  const sleepA = (ms) => sleepAbortable(ms, ctx);
+  const step = Number(process.env.AGENT_CONSOLE_MOCK_STEP_MS) || 250;
+  const think = async (id2, text) => {
+    for (const ch of chunkText(text, 6)) {
+      emit({ type: "reasoning_delta", itemId: id2, text: ch });
+      if (await sleepA(40)) return true;
+    }
+    emit({ type: "reasoning", itemId: id2, text });
+    return false;
+  };
+  const tool = async (id2, kind, title, input, ms = step) => {
+    emit({ type: "tool_call", itemId: id2, kind, title, status: "running", input });
+    if (await sleepA(ms)) return true;
+    emit({ type: "tool_call", itemId: id2, kind, title, status: "ok", durationMs: ms, output: "ok" });
+    return false;
+  };
+  const dir = "D:\\workwork\\\u6296\u97F3\u5FEB\u624B\u81EA\u52A8\u4E0A\u4F20";
+  const start = `Set-Location "${dir}"; if (Test-Path ".venv\\Scripts\\pythonw.exe") { Start-Process -FilePath ".venv\\Scripts\\pythonw.exe" -ArgumentList "-m","app.main" -WorkingDirectory "${dir}"; Write-Host "\u5DF2\u542F\u52A8\uFF08\u6E90\u7801\u6A21\u5F0F\uFF09" } else { Write-Host "venv \u4E0D\u5B58\u5728\uFF0C\u5C1D\u8BD5 exe"; Start-Process -FilePath "\u98CE\u666F\u89C6\u9891\u5DE5\u5177.exe" -WorkingDirectory "${dir}"; Write-Host "\u5DF2\u542F\u52A8\uFF08exe\uFF09" }`;
+  const ps = `Get-Process pythonw -ErrorAction SilentlyContinue | Where-Object { $_.Path -like "*\u6296\u97F3\u5FEB\u624B\u81EA\u52A8\u4E0A\u4F20*" } | Select-Object Id, Path, StartTime | Format-Table -AutoSize`;
+  if (await think("w1", "\u5148\u68C0\u67E5\u662F\u5426\u5DF2\u6709\u5B9E\u4F8B\u5728\u8DD1\u3002")) return;
+  emit({ type: "assistant_message", itemId: "wm1", text: "\u5148\u68C0\u67E5\u662F\u5426\u5DF2\u6709\u5B9E\u4F8B\u5728\u8DD1\uFF0C\u518D\u542F\u52A8\u5E94\u7528\u3002" });
+  if (await tool("s1", "search", "\u641C\u7D22 pythonw", { pattern: "pythonw" })) return;
+  if (await tool("s2", "search", "\u641C\u7D22 app.main", { pattern: "app.main" })) return;
+  if (await think("w2", "\u770B\u4E0B\u542F\u52A8\u811A\u672C\u3002")) return;
+  if (await tool("s3", "search", "\u641C\u7D22 \u542F\u52A8.bat", { pattern: "\u542F\u52A8.bat" })) return;
+  if (await tool("r1", "read", "\u8BFB\u53D6 \u542F\u52A8.bat", { file_path: `${dir}\\\u542F\u52A8.bat` })) return;
+  if (await think("w3", "")) return;
+  if (await tool("b0", "bash", `\u8FD0\u884C ${ps}`, { command: ps }, step * 2)) return;
+  if (await think("w4", "\u6CA1\u6709\u5B9E\u4F8B\u5728\u8DD1\uFF0C\u76F4\u63A5\u542F\u52A8\u3002")) return;
+  emit({ type: "tool_call", itemId: "b1", kind: "bash", title: `\u8FD0\u884C ${start}`, status: "running", input: { command: start } });
+  if (await sleepA(step)) return;
+  const requestId = "perm-" + rid();
+  emit({
+    type: "permission_request",
+    requestId,
+    title: start,
+    kind: "tool",
+    detail: { command: start, cwd: dir },
+    options: [
+      { id: "allow-once", label: "Allow once", kind: "allow_once" },
+      { id: "allow-always", label: "Allow always", kind: "allow_always" },
+      { id: "reject-once", label: "Reject", kind: "reject_once" }
+    ]
+  });
+  const ans = await ctx.waitFor(requestId);
+  if (ans.cancelled || ans.optionId === "reject-once") {
+    emit({ type: "tool_call", itemId: "b1", kind: "bash", title: `\u8FD0\u884C ${start}`, status: "failed", output: "Rejected", exitCode: 1 });
+    return;
+  }
+  emit({ type: "tool_call", itemId: "b1", kind: "bash", title: `\u8FD0\u884C ${start}`, status: "ok", output: "\u5DF2\u542F\u52A8\uFF08\u6E90\u7801\u6A21\u5F0F\uFF09", exitCode: 0, durationMs: step });
+  if (await think("w5", "\u6539\u4E09\u4E2A\u914D\u7F6E\u3002")) return;
+  for (const n of [1, 2, 3]) if (await tool(`e${n}`, "edit", `\u7F16\u8F91 config/${n}.json`, { file_path: `${dir}\\config\\${n}.json` })) return;
+  if (await think("w6", "\u786E\u8BA4\u8FDB\u7A0B\u8D77\u6765\u4E86\u3002")) return;
+  if (await tool("r2", "read", "\u8BFB\u53D6 logs/selftest.txt", { file_path: `${dir}\\logs\\selftest.txt` })) return;
+  if (await tool("b2", "bash", `\u8FD0\u884C ${ps}`, { command: ps }, Number(process.env.AGENT_CONSOLE_MOCK_TOOLS_MS) || step * 6)) return;
+  emit({ type: "assistant_message", itemId: "wm2", text: ctx.replyPrefix() + "\u5DF2\u542F\u52A8\uFF0C\u8FDB\u7A0B\u5728\u8DD1\u3002" });
+}
+async function scriptTasks(ctx) {
+  const { emit } = ctx;
+  const sleepA = (ms) => sleepAbortable(ms, ctx);
+  const steps = ["\u590D\u73B0\u5076\u53D1\u5931\u8D25", "\u627E\u5230\u7ADE\u6001", "\u4FEE\u590D\u5E76\u52A0\u56FA\u6D4B\u8BD5"];
+  const plan = (done, running) => emit({
+    type: "plan",
+    itemId: "tk-plan",
+    markdown: steps.map((s) => `- ${s}`).join("\n"),
+    entries: steps.map((step, i) => ({ step, status: i < done ? "completed" : i === done && running ? "in_progress" : "pending" }))
+  });
+  const tool = async (id2, kind, title, input, end = {}, ms = 120) => {
+    emit({ type: "tool_call", itemId: id2, kind, title, status: "running", input });
+    if (await sleepA(ms)) return true;
+    emit({ type: "tool_call", itemId: id2, kind, title, status: "ok", durationMs: ms, output: "ok", ...end });
+    return false;
+  };
+  plan(0, true);
+  if (await tool("k1", "bash", "\u8FD0\u884C npx vitest run src/checkout --repeat 50", { command: "npx vitest run src/checkout --repeat 50" })) return;
+  if (await tool("k2", "read", "\u8BFB\u53D6 src/checkout/useCheckout.ts", { file_path: "src/checkout/useCheckout.ts" })) return;
+  plan(1, true);
+  emit({ type: "reasoning", itemId: "k-th", text: "submit() \u6CA1\u6709\u7B49 confirmOrder\u3002" });
+  const oldStr = '  setStatus("pending");\n  void confirmOrder(order.id).then(setStatus);';
+  const newStr = '  setStatus("pending");\n  try {\n    setStatus(await confirmOrder(order.id));\n  } catch (error) {\n    setStatus("failed");\n    throw error;\n  }';
+  if (await tool(
+    "k3",
+    "edit",
+    "\u7F16\u8F91 src/checkout/useCheckout.ts",
+    { file_path: "src/checkout/useCheckout.ts", old_string: oldStr, new_string: newStr },
+    { detail: editDetail({ path: "src/checkout/useCheckout.ts", old: oldStr, new: newStr }) }
+  )) return;
+  plan(2, true);
+  if (await tool("k4", "search", '\u641C\u7D22 "confirmOrder"', { pattern: "confirmOrder" })) return;
+  const hold = Number(process.env.AGENT_CONSOLE_MOCK_TASKS_HOLD_MS) || 0;
+  if (await tool("k5", "bash", "\u8FD0\u884C npx tsc --noEmit", { command: "npx tsc --noEmit" }, {}, Math.max(120, hold))) return;
+  plan(3, false);
+  const reply = ctx.replyPrefix() + [
+    "**\u6839\u56E0\uFF1A** `submit()` \u4E22\u6389\u4E86\u786E\u8BA4\u8BF7\u6C42\u7684 Promise\uFF0C\u8BA2\u5355\u786E\u8BA4\u524D\u5C31\u8FD4\u56DE\u4E86\u3002",
+    "",
+    "```ts",
+    "async function submit() {",
+    '  setStatus("pending");',
+    "  const order = await createOrder(cart);",
+    "  setStatus(await confirmOrder(order.id));",
+    "}",
+    "```",
+    "",
+    "\u91CD\u590D\u8DD1 50 \u6B21\u90FD\u901A\u8FC7\u4E86\u3002"
+  ].join("\n");
+  emit({ type: "assistant_message", itemId: "k-msg", text: reply });
+}
+async function scriptBashHint(ctx) {
+  ctx.emit({ type: "notice", level: "warn", code: "bash_missing", message: tr("notice.bashMissing") });
+  await sleepAbortable(100, ctx);
+  ctx.emit({ type: "assistant_message", itemId: "bh1", text: ctx.replyPrefix() + "\uFF08\u6A21\u62DF\uFF09" });
+}
 async function scriptServe(ctx) {
   const emit = (e) => ctx.emit(e);
   const reply = [
@@ -871,6 +1036,8 @@ function createMockProvider() {
     name: "Mock\uFF08\u6F14\u793A\uFF09",
     capabilities: mockCapabilities,
     async detect() {
+      const d = Number(process.env.AGENT_CONSOLE_MOCK_DETECT_MS) || 0;
+      if (d > 0) await sleep(d);
       return { available: true, bin: "mock", version: "demo" };
     },
     async listModels() {
@@ -881,6 +1048,8 @@ function createMockProvider() {
     },
     async createSession(o) {
       mockProviderMetrics.createSessionCalls++;
+      const d = Number(process.env.AGENT_CONSOLE_MOCK_START_MS) || 0;
+      if (d > 0) await sleep(d);
       return new MockSession(o);
     }
   };
@@ -1141,11 +1310,251 @@ var init_pathscan = __esm({
   }
 });
 
+// daemon/src/util/gitBash.ts
+import path2 from "node:path";
+import { statSync as statSync3 } from "node:fs";
+import { spawn } from "node:child_process";
+function envGet2(env, name) {
+  if (env[name] !== void 0) return env[name];
+  const lower = name.toLowerCase();
+  for (const k of Object.keys(env)) if (k.toLowerCase() === lower) return env[k];
+  return void 0;
+}
+function syncIsFile(p) {
+  try {
+    return statSync3(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function withTimeout(p, ms) {
+  return new Promise((resolve4) => {
+    const t = setTimeout(() => resolve4(false), ms);
+    t.unref?.();
+    p.then((v) => {
+      clearTimeout(t);
+      resolve4(v);
+    }, () => {
+      clearTimeout(t);
+      resolve4(false);
+    });
+  });
+}
+function isWslBash(p, env = {}) {
+  const n = norm(p);
+  if (/\\windowsapps\\/.test(n + "\\")) return true;
+  if (/^[a-z]:\\windows\\(system32|syswow64|sysnative)\\/.test(n)) return true;
+  const root = envGet2(env, "SystemRoot") || envGet2(env, "windir");
+  if (root) {
+    const r = norm(root);
+    for (const sub of ["system32", "syswow64", "sysnative"]) if (n.startsWith(`${r}\\${sub}\\`)) return true;
+  }
+  return false;
+}
+function cleanPath(raw) {
+  return raw.trim().replace(/^"(.*)"$/, "$1").replace(/^'(.*)'$/, "$1").trim();
+}
+function checkBashPath(raw, deps = {}) {
+  const p = cleanPath(String(raw ?? ""));
+  if (!p) return { ok: false, reason: "empty" };
+  if (!/^[A-Za-z]:[\\/]/.test(p)) return { ok: false, reason: "relative" };
+  const base = W.basename(p).toLowerCase();
+  if (base !== "bash.exe" && base !== "sh.exe") return { ok: false, reason: "notBash" };
+  const env = deps.env ?? process.env;
+  if (isWslBash(p, env)) return { ok: false, reason: "wsl" };
+  const full = W.normalize(p);
+  if (!(deps.isFile ?? syncIsFile)(full)) return { ok: false, reason: "missing" };
+  return { ok: true, path: full };
+}
+function bashForGitDir(dir) {
+  const d = W.normalize(dir).replace(/[\\/]+$/, "");
+  const base = W.basename(d).toLowerCase();
+  const parent = W.dirname(d);
+  const out = [];
+  if (base === "bin" || base === "cmd") {
+    const pb = W.basename(parent).toLowerCase();
+    if (["mingw64", "mingw32", "clangarm64", "ucrt64", "usr"].includes(pb)) out.push(W.join(W.dirname(parent), "bin", "bash.exe"));
+    out.push(W.join(parent, "bin", "bash.exe"));
+  }
+  out.push(W.join(d, "bash.exe"));
+  return [...new Set(out)];
+}
+function knownBashCandidates(env, home) {
+  const out = [];
+  for (const v of ["ProgramFiles", "ProgramW6432", "ProgramFiles(x86)"]) {
+    const d = envGet2(env, v);
+    if (d) out.push(W.join(d, "Git", "bin", "bash.exe"));
+  }
+  out.push("C:\\Program Files\\Git\\bin\\bash.exe", "C:\\Program Files (x86)\\Git\\bin\\bash.exe");
+  const local = envGet2(env, "LOCALAPPDATA");
+  if (local) out.push(W.join(local, "Programs", "Git", "bin", "bash.exe"));
+  const scoop = envGet2(env, "SCOOP") || (home ? W.join(home, "scoop") : "");
+  if (scoop) out.push(W.join(scoop, "apps", "git", "current", "bin", "bash.exe"));
+  const seen = /* @__PURE__ */ new Set();
+  return out.filter((p) => seen.has(norm(p)) ? false : (seen.add(norm(p)), true));
+}
+function driveBashCandidates(drives) {
+  const out = [];
+  for (const raw of drives) {
+    const L = raw.replace(/[:\\/]/g, "").toUpperCase();
+    if (!/^[A-Z]$/.test(L)) continue;
+    out.push(`${L}:\\Git\\bin\\bash.exe`, `${L}:\\Program Files\\Git\\bin\\bash.exe`);
+  }
+  return out;
+}
+async function findGitBash(manual, deps = {}) {
+  const env = deps.env ?? process.env;
+  const isFile = deps.isFile ?? syncIsFile;
+  const ok = (p) => !isWslBash(p, env) && isFile(p);
+  let manualError;
+  if (manual && cleanPath(manual)) {
+    const c = checkBashPath(manual, { ...deps, env });
+    if (c.ok) return { found: { path: c.path, source: "manual" } };
+    manualError = c;
+  }
+  for (const v of ["CLAUDE_CODE_GIT_BASH_PATH", "OPENCODE_GIT_BASH_PATH"]) {
+    const c = checkBashPath(envGet2(env, v), { ...deps, env });
+    if (c.ok) return { found: { path: c.path, source: "env" }, manualError };
+  }
+  for (const git of findOnPath("git.exe", { platform: "win32", env, extra: false, exists: isFile })) {
+    for (const b of bashForGitDir(W.dirname(git))) if (ok(b)) return { found: { path: b, source: "git" }, manualError };
+  }
+  for (const b of knownBashCandidates(env, deps.home)) if (ok(b)) return { found: { path: b, source: "known" }, manualError };
+  const drives = driveBashCandidates(deps.drives ?? ALL_DRIVES);
+  const ms = deps.probeTimeoutMs ?? 1500;
+  const list = drives.filter((p) => !isWslBash(p, env));
+  const hit = deps.isFileAsync ? await Promise.all(list.map((p) => withTimeout(deps.isFileAsync(p), ms))).then((h) => list[h.indexOf(true)] ?? null) : await probeInChild(list, ms);
+  if (hit) return { found: { path: hit, source: "drive" }, manualError };
+  for (const b of findOnPath("bash.exe", { platform: "win32", env, extra: false, exists: isFile })) {
+    if (!isWslBash(b, env)) return { found: { path: b, source: "path" }, manualError };
+  }
+  return { found: null, manualError };
+}
+function probeInChild(paths, ms) {
+  if (!paths.length) return Promise.resolve(null);
+  const script = "const fs=require('fs');const p=JSON.parse(process.argv[1]);p.forEach((x,i)=>fs.stat(x,(e,s)=>{if(!e&&s.isFile())process.stdout.write(i+'\\n')}));";
+  return new Promise((resolve4) => {
+    const hits = /* @__PURE__ */ new Set();
+    let out = "";
+    let done = false;
+    const finish = () => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      try {
+        child.kill();
+      } catch {
+      }
+      const first = [...hits].sort((a, b) => a - b)[0];
+      resolve4(first === void 0 ? null : paths[first] ?? null);
+    };
+    const child = spawn(process.execPath, ["-e", script, JSON.stringify(paths)], { stdio: ["ignore", "pipe", "ignore"], windowsHide: true });
+    const timer = setTimeout(finish, ms);
+    child.stdout?.setEncoding("utf8");
+    child.stdout?.on("data", (d) => {
+      out += d;
+      for (const line of out.split("\n").slice(0, -1)) if (/^\d+$/.test(line)) hits.add(Number(line));
+      out = out.slice(out.lastIndexOf("\n") + 1);
+      if (hits.has(0)) finish();
+    });
+    child.on("error", finish);
+    child.on("close", finish);
+  });
+}
+function bashPathDir(bash, isFile = syncIsFile) {
+  const dir = W.dirname(W.normalize(bash));
+  if (/\\usr\\bin$/i.test(dir)) {
+    const top = W.join(W.dirname(W.dirname(dir)), "bin");
+    if (isFile(W.join(top, "bash.exe"))) return top;
+  }
+  return dir;
+}
+function bashEnv(found, env, isFile = syncIsFile) {
+  if (!found) return {};
+  const out = {
+    CLAUDE_CODE_GIT_BASH_PATH: found.path,
+    OPENCODE_GIT_BASH_PATH: found.path
+  };
+  const dir = bashPathDir(found.path, isFile);
+  const first = findOnPath("bash.exe", { platform: "win32", env, extra: false, exists: isFile })[0];
+  if (!first || norm(first) !== norm(W.join(dir, "bash.exe"))) {
+    const key = Object.keys(env).find((k) => k.toUpperCase() === "PATH") ?? "PATH";
+    const rest = String(env[key] ?? "").split(";").filter((d) => d && norm(d.replace(/^"(.*)"$/, "$1")) !== norm(dir));
+    out[key] = [dir, ...rest].join(";");
+  }
+  return out;
+}
+var W, GIT_FOR_WINDOWS_URL, norm, ALL_DRIVES;
+var init_gitBash = __esm({
+  "daemon/src/util/gitBash.ts"() {
+    init_pathscan();
+    W = path2.win32;
+    GIT_FOR_WINDOWS_URL = "https://git-scm.com/download/win";
+    norm = (p) => W.normalize(p).replace(/[\\/]+$/, "").toLowerCase();
+    ALL_DRIVES = "CDEFGHIJKLMNOPQRSTUVWXYZ".split("");
+  }
+});
+
+// daemon/src/util/agentShell.ts
+import { homedir as homedir3 } from "node:os";
+function refreshAgentShell(manual, o = {}) {
+  const platform = o.platform ?? process.platform;
+  const my = ++generation;
+  const m = typeof manual === "string" ? manual : "";
+  if (platform !== "win32") {
+    status = { needed: false, found: null, manual: m };
+    ready = Promise.resolve();
+    return ready;
+  }
+  const env = o.deps?.env ?? process.env;
+  ready = findGitBash(m, { home: homedir3(), ...o.deps, env }).then(({ found, manualError }) => {
+    if (my !== generation) return;
+    status = { needed: true, found, manual: m, ...manualError && !manualError.ok ? { manualError: manualError.reason } : {} };
+    isFileDep = o.deps?.isFile;
+    if (found) log("info", `Git Bash: ${found.path} (${found.source})`);
+    else log("warn", "Git Bash not found; agents that need bash (Claude Code, Pi, dsh) will show a hint");
+  }).catch((e) => {
+    log("warn", "Git Bash detection failed", { err: String(e) });
+  });
+  return ready;
+}
+function agentShellReady(ms = 3e3) {
+  return Promise.race([ready, new Promise((r) => setTimeout(r, ms).unref?.())]);
+}
+function agentShellStatus() {
+  return status;
+}
+function bashMissingFor(providerId) {
+  return status.needed && !status.found && BASH_AGENTS.has(providerId);
+}
+function withAgentShell(env) {
+  if (!status.needed || !status.found) return env;
+  const overrides = bashEnv(status.found, env, isFileDep);
+  const out = { ...env };
+  for (const [k, v] of Object.entries(overrides)) {
+    const same = Object.keys(out).find((x) => x.toUpperCase() === k.toUpperCase() && x !== k);
+    if (same && k.toUpperCase() === "PATH") delete out[same];
+    out[k] = v;
+  }
+  return out;
+}
+var status, isFileDep, ready, generation, BASH_AGENTS;
+var init_agentShell = __esm({
+  "daemon/src/util/agentShell.ts"() {
+    init_gitBash();
+    init_log();
+    status = { needed: process.platform === "win32", found: null, manual: "" };
+    ready = Promise.resolve();
+    generation = 0;
+    BASH_AGENTS = /* @__PURE__ */ new Set(["claude", "pi", "dsh"]);
+  }
+});
+
 // daemon/src/util/bin.ts
-import { execFileSync, spawn } from "node:child_process";
+import { execFileSync, spawn as spawn2 } from "node:child_process";
 import { readFile as readFile3 } from "node:fs/promises";
 import { existsSync as existsSync4 } from "node:fs";
-import path2 from "node:path";
+import path3 from "node:path";
 function which(name) {
   return findOnPath(name);
 }
@@ -1191,9 +1600,11 @@ function trackTree(child) {
 function spawnBin(r, args, opts = {}) {
   const a = argvFor(r, args);
   const { group, ...rest } = opts;
-  const child = spawn(a.cmd, a.args, {
+  const child = spawn2(a.cmd, a.args, {
     windowsHide: true,
     ...rest,
+    // Windows: Git Bash for the agent (CLAUDE_CODE_GIT_BASH_PATH, OPENCODE_GIT_BASH_PATH, PATH); unchanged elsewhere
+    env: withAgentShell(rest.env ?? process.env),
     ...a.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {},
     ...group && !IS_WIN ? { detached: true } : {}
   });
@@ -1202,7 +1613,7 @@ function spawnBin(r, args, opts = {}) {
 }
 function shimTarget(cmdText, cmdDir, deps = {}) {
   const exists = deps.exists ?? existsSync4;
-  const P = deps.win ?? IS_WIN ? path2.win32 : path2;
+  const P = deps.win ?? IS_WIN ? path3.win32 : path3;
   const cands = [];
   const re = /"([^"]+?\.(?:js|mjs|cjs|exe|cmd|bat))"/gi;
   let m;
@@ -1253,7 +1664,7 @@ function resolveBinUncached(name) {
 async function resolveBinWith(name, deps = {}) {
   const platform = deps.platform ?? process.platform;
   const win = platform === "win32";
-  const P = win ? path2.win32 : path2.posix;
+  const P = win ? path3.win32 : path3.posix;
   const exists = deps.exists ?? existsSync4;
   const hits = (deps.find ?? which)(name);
   if (!hits.length) return { ok: false, reason: tr("bin.notOnPath", { name }) };
@@ -1294,7 +1705,7 @@ function killTree(child, { graceMs = 3e3 } = {}) {
   const pid = child.pid;
   if (IS_WIN) {
     return new Promise((resolvePromise) => {
-      const tk = spawn("taskkill", ["/pid", String(pid), "/T", "/F"], { windowsHide: true });
+      const tk = spawn2("taskkill", ["/pid", String(pid), "/T", "/F"], { windowsHide: true });
       tk.on("error", () => {
         try {
           child.kill();
@@ -1349,6 +1760,7 @@ var init_bin = __esm({
   "daemon/src/util/bin.ts"() {
     init_pathscan();
     init_i18n();
+    init_agentShell();
     IS_WIN = process.platform === "win32";
     cache = /* @__PURE__ */ new Map();
     CACHE_MS = 60 * 1e3;
@@ -1365,9 +1777,9 @@ function relPath(p, cwd) {
   if (!p) return "";
   const s = String(p);
   if (!cwd) return s;
-  const norm = (x) => x.replace(/\\/g, "/").replace(/\/+$/, "");
-  const a = norm(s);
-  const b = norm(cwd);
+  const norm2 = (x) => x.replace(/\\/g, "/").replace(/\/+$/, "");
+  const a = norm2(s);
+  const b = norm2(cwd);
   if (a.toLowerCase().startsWith(b.toLowerCase() + "/")) return a.slice(b.length + 1);
   if (a.toLowerCase() === b.toLowerCase()) return ".";
   return s;
@@ -1780,6 +2192,162 @@ var init_launch = __esm({
   }
 });
 
+// daemon/src/util/decode.ts
+import { spawnSync } from "node:child_process";
+function codePageLabel(cp3) {
+  const label = CP[cp3];
+  if (!label) return null;
+  try {
+    new TextDecoder(label);
+    return label;
+  } catch {
+    return null;
+  }
+}
+function labelForLocale(locale2) {
+  const l = locale2.toLowerCase();
+  if (/^zh[-_](tw|hk|mo|hant)/.test(l)) return codePageLabel(950);
+  if (l.startsWith("zh")) return codePageLabel(936);
+  if (l.startsWith("ja")) return codePageLabel(932);
+  if (l.startsWith("ko")) return codePageLabel(949);
+  return null;
+}
+function parseCodePage(out) {
+  const m = /ACP\s+REG_SZ\s+(\d{3,5})/i.exec(out) ?? /:\s*(\d{3,5})\s*$/m.exec(out.trim());
+  return m ? Number(m[1]) : null;
+}
+function systemLegacyEncoding(platform = process.platform) {
+  if (systemLabel !== void 0) return systemLabel;
+  if (platform !== "win32") return null;
+  let cp3 = null;
+  try {
+    const r = spawnSync("reg", ["query", "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Nls\\CodePage", "/v", "ACP"], { encoding: "latin1", timeout: 2e3, windowsHide: true });
+    cp3 = parseCodePage(String(r.stdout ?? ""));
+  } catch {
+  }
+  if (cp3 === 65001) return systemLabel = null;
+  systemLabel = cp3 && codePageLabel(cp3) || labelForLocale(Intl.DateTimeFormat().resolvedOptions().locale);
+  return systemLabel;
+}
+function utf8Tail(b) {
+  for (let k = 1; k <= Math.min(3, b.length); k++) {
+    const c = b[b.length - k];
+    if ((c & 192) === 128) continue;
+    const need = c >= 240 ? 4 : c >= 224 ? 3 : c >= 192 ? 2 : 1;
+    return need > k ? k : 0;
+  }
+  return 0;
+}
+function legacyTail(b, label) {
+  const dbcs = label === "gbk" || label === "gb18030" || label === "big5" || label === "euc-kr" || label === "shift_jis";
+  if (!dbcs) return 0;
+  const gb = label === "gbk" || label === "gb18030";
+  let i = 0;
+  while (i < b.length) {
+    const c = b[i];
+    let n = 1;
+    if (label === "shift_jis") n = c >= 129 && c <= 159 || c >= 224 && c <= 252 ? 2 : 1;
+    else if (c >= 129 && c <= 254) n = gb && i + 1 < b.length && b[i + 1] >= 48 && b[i + 1] <= 57 ? 4 : 2;
+    if (i + n > b.length) return b.length - i;
+    i += n;
+  }
+  return 0;
+}
+function hasLongUtf8(b) {
+  for (const c of b) if (c >= 224) return true;
+  return false;
+}
+function isAscii(b) {
+  for (const c of b) if (c >= 128) return false;
+  return true;
+}
+function decodeOutput(buf, legacy) {
+  const d = new OutputDecoder(legacy === void 0 ? systemLegacyEncoding() : legacy);
+  return d.write(buf) + d.end();
+}
+var CP, systemLabel, OutputDecoder;
+var init_decode = __esm({
+  "daemon/src/util/decode.ts"() {
+    CP = {
+      936: "gbk",
+      54936: "gb18030",
+      950: "big5",
+      932: "shift_jis",
+      949: "euc-kr",
+      866: "ibm866",
+      874: "windows-874",
+      1250: "windows-1250",
+      1251: "windows-1251",
+      1252: "windows-1252",
+      1253: "windows-1253",
+      1254: "windows-1254",
+      1255: "windows-1255",
+      1256: "windows-1256",
+      1257: "windows-1257",
+      1258: "windows-1258"
+      // 437/850 (OEM, Western) have no WHATWG decoder; output there is almost always ASCII or already UTF-8
+    };
+    OutputDecoder = class {
+      pending = new Uint8Array(0);
+      legacyLast = false;
+      utf8 = new TextDecoder("utf-8", { fatal: true });
+      lenient = new TextDecoder("utf-8");
+      legacy;
+      /** legacy: encoding label for non-UTF-8 chunks; default = the system code page on Windows, none elsewhere */
+      constructor(legacy = systemLegacyEncoding()) {
+        let d = null;
+        if (legacy) try {
+          d = new TextDecoder(legacy);
+        } catch {
+        }
+        this.legacy = d;
+      }
+      write(chunk) {
+        if (typeof chunk === "string") return chunk;
+        let b = chunk;
+        if (this.pending.length) {
+          const m = new Uint8Array(this.pending.length + chunk.length);
+          m.set(this.pending);
+          m.set(chunk, this.pending.length);
+          b = m;
+          this.pending = new Uint8Array(0);
+        }
+        if (!b.length) return "";
+        const ut = utf8Tail(b);
+        const head = b.subarray(0, b.length - ut);
+        let text = null;
+        try {
+          text = this.utf8.decode(head);
+        } catch {
+        }
+        if (text !== null) {
+          const ascii = isAscii(head);
+          if (!(this.legacy && this.legacyLast && !ascii && !hasLongUtf8(head))) {
+            if (!ascii) this.legacyLast = false;
+            this.pending = b.slice(b.length - ut);
+            return text;
+          }
+        }
+        if (!this.legacy) {
+          this.pending = b.slice(b.length - ut);
+          return this.lenient.decode(head);
+        }
+        this.legacyLast = true;
+        const lt = legacyTail(b, this.legacy.encoding);
+        this.pending = b.slice(b.length - lt);
+        return this.legacy.decode(b.subarray(0, b.length - lt));
+      }
+      /** Flush whatever is held back (a truncated character at the very end becomes U+FFFD) */
+      end() {
+        const b = this.pending;
+        this.pending = new Uint8Array(0);
+        if (!b.length) return "";
+        return (this.legacyLast && this.legacy ? this.legacy : this.lenient).decode(b);
+      }
+    };
+  }
+});
+
 // daemon/src/providers/claude/cli.ts
 function claudeArgs(o) {
   const args = [
@@ -1813,6 +2381,7 @@ var init_cli = __esm({
     init_launch();
     init_bin();
     init_queue();
+    init_decode();
     SAFE_ARG = /^[A-Za-z0-9][A-Za-z0-9._:\[\]\/@+-]{0,199}$/;
     ClaudeCli = class {
       constructor(o, canUseTool) {
@@ -1827,8 +2396,9 @@ var init_cli = __esm({
         });
         this.child.stdout?.setEncoding("utf8");
         this.child.stdout?.on("data", (d) => this.onData(d));
+        const errDec = new OutputDecoder();
         this.child.stderr?.on("data", (d) => {
-          this.stderrTail = (this.stderrTail + d.toString()).slice(-4096);
+          this.stderrTail = (this.stderrTail + errDec.write(d)).slice(-4096);
         });
         this.child.stdin?.on("error", () => {
         });
@@ -2331,7 +2901,7 @@ var init_models = __esm({
 import { readdir, readFile as readFile5, stat as stat4 } from "node:fs/promises";
 import { existsSync as existsSync7 } from "node:fs";
 import { join as join6 } from "node:path";
-import { homedir as homedir3 } from "node:os";
+import { homedir as homedir4 } from "node:os";
 function parseLine(line) {
   let r;
   try {
@@ -2351,8 +2921,8 @@ function parseLine(line) {
   }
   return { cwd, userText };
 }
-async function* linesOf(path3) {
-  const text = await readFile5(path3, "utf8").catch(() => "");
+async function* linesOf(path4) {
+  const text = await readFile5(path4, "utf8").catch(() => "");
   for (const line of text.split("\n")) {
     if (line.trim()) yield line;
   }
@@ -2364,11 +2934,11 @@ async function listClaudeHistory(cwd) {
     const dirPath = join6(CLAUDE_ROOT, d);
     const files = (await readdir(dirPath).catch(() => [])).filter((f) => f.endsWith(".jsonl"));
     for (const f of files) {
-      const path3 = join6(dirPath, f);
+      const path4 = join6(dirPath, f);
       let match = false;
       let title = "";
       let count = 0;
-      for await (const line of linesOf(path3)) {
+      for await (const line of linesOf(path4)) {
         const p = parseLine(line);
         if (!p) continue;
         if (!match) {
@@ -2380,7 +2950,7 @@ async function listClaudeHistory(cwd) {
         if (p.userText) count++;
       }
       if (!match) continue;
-      const s = await stat4(path3).catch(() => null);
+      const s = await stat4(path4).catch(() => null);
       out.push({
         sessionId: f.replace(/\.jsonl$/, ""),
         title: title || tr("history.untitled"),
@@ -2395,11 +2965,11 @@ async function listClaudeHistory(cwd) {
 async function readClaudeHistory(sessionId, cwd) {
   const dirs = await readdir(CLAUDE_ROOT).catch(() => []);
   for (const d of dirs) {
-    const path3 = join6(CLAUDE_ROOT, d, `${sessionId}.jsonl`);
-    if (!existsSync7(path3)) continue;
+    const path4 = join6(CLAUDE_ROOT, d, `${sessionId}.jsonl`);
+    if (!existsSync7(path4)) continue;
     const msgs = [];
     let matched = false;
-    for await (const line of linesOf(path3)) {
+    for await (const line of linesOf(path4)) {
       const p = parseLine(line);
       if (!matched) {
         if (p?.cwd && samePath(p.cwd, cwd)) matched = true;
@@ -2422,7 +2992,7 @@ var init_import = __esm({
   "daemon/src/history/import.ts"() {
     init_paths();
     init_i18n();
-    CLAUDE_ROOT = join6(homedir3(), ".claude", "projects");
+    CLAUDE_ROOT = join6(homedir4(), ".claude", "projects");
     rec2 = (v) => v && typeof v === "object" ? v : {};
     str2 = (v) => typeof v === "string" ? v : void 0;
   }
@@ -2440,8 +3010,9 @@ function runVersion(r, args, timeoutMs = 5e3) {
       }
       reject(new Error("timeout"));
     }, timeoutMs);
-    p.stdout?.on("data", (c) => out += c.toString());
-    p.stderr?.on("data", (c) => out += c.toString());
+    const od = new OutputDecoder(), ed = new OutputDecoder();
+    p.stdout?.on("data", (c) => out += od.write(c));
+    p.stderr?.on("data", (c) => out += ed.write(c));
     p.on("error", reject);
     p.on("close", (code) => {
       clearTimeout(t);
@@ -2519,6 +3090,7 @@ var init_provider = __esm({
     init_map();
     init_i18n();
     init_launch();
+    init_decode();
     INSTALL_HINT = "npm i -g @anthropic-ai/claude-code";
     claudeCapabilities = {
       resume: true,
@@ -2538,7 +3110,7 @@ var init_provider = __esm({
 // daemon/src/history/codex.ts
 import { readdir as readdir2, readFile as readFile6, stat as stat5 } from "node:fs/promises";
 import { join as join7 } from "node:path";
-import { homedir as homedir4 } from "node:os";
+import { homedir as homedir5 } from "node:os";
 function textOf(content, kind) {
   if (!Array.isArray(content)) return "";
   return content.filter((p) => p.type === kind || p.type === "input_text" || p.type === "output_text").map((p) => str3(p.text) ?? "").join("\n").trim();
@@ -2555,11 +3127,11 @@ async function* walk(dir, depth = 0) {
 }
 async function listCodexHistory(cwd) {
   const out = [];
-  for await (const path3 of walk(CODEX_ROOT)) {
-    const m = /rollout-.*-([0-9a-f-]{36})\.jsonl$/i.exec(path3);
+  for await (const path4 of walk(CODEX_ROOT)) {
+    const m = /rollout-.*-([0-9a-f-]{36})\.jsonl$/i.exec(path4);
     const sessionId = m?.[1];
     if (!sessionId) continue;
-    const text = await readFile6(path3, "utf8").catch(() => "");
+    const text = await readFile6(path4, "utf8").catch(() => "");
     let match = false;
     let title = "";
     let count = 0;
@@ -2590,7 +3162,7 @@ async function listCodexHistory(cwd) {
       }
     }
     if (!match) continue;
-    const s = await stat5(path3).catch(() => null);
+    const s = await stat5(path4).catch(() => null);
     out.push({ sessionId, title: title || tr("history.untitled"), updatedAt: s ? Math.round(s.mtimeMs) : 0, messageCount: count });
   }
   out.sort((a, b) => b.updatedAt - a.updatedAt);
@@ -2679,7 +3251,7 @@ var init_codex = __esm({
   "daemon/src/history/codex.ts"() {
     init_paths();
     init_i18n();
-    CODEX_ROOT = join7(homedir4(), ".codex", "sessions");
+    CODEX_ROOT = join7(homedir5(), ".codex", "sessions");
     rec3 = (v) => v && typeof v === "object" ? v : {};
     str3 = (v) => typeof v === "string" ? v : void 0;
     WRAPPERS = /^\s*<(environment_context|user_instructions|skills_instructions|permissions instructions)>/i;
@@ -2687,12 +3259,14 @@ var init_codex = __esm({
 });
 
 // daemon/src/providers/codex/rpc.ts
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 var CodexRpcError, CodexProcessExitedError, CodexRpc;
 var init_rpc = __esm({
   "daemon/src/providers/codex/rpc.ts"() {
     init_log();
     init_bin();
+    init_decode();
+    init_agentShell();
     CodexRpcError = class extends Error {
       code;
       constructor(message, code) {
@@ -2715,9 +3289,9 @@ var init_rpc = __esm({
       onNotification;
       onExit;
       constructor(argv, opts = {}) {
-        this.proc = spawn2(argv.cmd, argv.args, {
+        this.proc = spawn3(argv.cmd, argv.args, {
           cwd: opts.cwd,
-          env: opts.env ?? process.env,
+          env: withAgentShell(opts.env ?? process.env),
           stdio: ["pipe", "pipe", "pipe"],
           windowsHide: true,
           ...argv.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {},
@@ -2727,9 +3301,9 @@ var init_rpc = __esm({
         trackTree(this.proc);
         this.proc.stdout.setEncoding("utf8");
         this.proc.stdout.on("data", (chunk) => this.onData(chunk));
-        this.proc.stderr.setEncoding("utf8");
+        const errDec = new OutputDecoder();
         this.proc.stderr.on("data", (chunk) => {
-          this.stderrTail = (this.stderrTail + chunk).slice(-4096);
+          this.stderrTail = (this.stderrTail + errDec.write(chunk)).slice(-4096);
         });
         this.proc.on("error", () => this.failAll());
         this.proc.on("close", (code) => {
@@ -3051,10 +3625,10 @@ function mapNotification(method, params, st) {
       const steps = Array.isArray(params.plan) ? params.plan : [];
       const items = steps.map((s) => {
         const step = rec4(s);
-        const status = str4(step.status) ?? "pending";
+        const status2 = str4(step.status) ?? "pending";
         return {
           text: str4(step.step) ?? "",
-          status: status === "completed" ? "done" : status === "inProgress" || status === "in_progress" ? "in_progress" : "pending"
+          status: status2 === "completed" ? "done" : status2 === "inProgress" || status2 === "in_progress" ? "in_progress" : "pending"
         };
       });
       if (items.length) out.push({ type: "todo", items });
@@ -3082,12 +3656,12 @@ function mapNotification(method, params, st) {
     }
     case "turn/completed": {
       const turn = rec4(params.turn);
-      const status = str4(turn.status) ?? "completed";
+      const status2 = str4(turn.status) ?? "completed";
       const error = rec4(turn.error);
       out.push({
         type: "turn_ended",
         turnId: str4(turn.id) ?? turnId ?? st.currentTurnId ?? "",
-        status: status === "completed" ? "completed" : status === "interrupted" ? "interrupted" : "failed",
+        status: status2 === "completed" ? "completed" : status2 === "interrupted" ? "interrupted" : "failed",
         durationMs: typeof turn.durationMs === "number" ? turn.durationMs : void 0,
         error: str4(error.message),
         filesChanged: st.filesChanged || void 0
@@ -3117,7 +3691,7 @@ var init_map2 = __esm({
 
 // daemon/src/providers/codex/commands.ts
 import { readdir as readdir3, readFile as readFile7, stat as stat6 } from "node:fs/promises";
-import { homedir as homedir5 } from "node:os";
+import { homedir as homedir6 } from "node:os";
 import { basename as basename3, join as join8 } from "node:path";
 function parseFrontMatter(raw) {
   if (!raw.startsWith("---\n")) return { meta: {}, body: raw };
@@ -3148,11 +3722,11 @@ async function readPromptFiles(dir) {
   }
   for (const f of names) {
     if (!f.endsWith(".md")) continue;
-    const path3 = join8(dir, f);
+    const path4 = join8(dir, f);
     try {
-      const st = await stat6(path3);
+      const st = await stat6(path4);
       if (!st.isFile()) continue;
-      const raw = await readFile7(path3, "utf8");
+      const raw = await readFile7(path4, "utf8");
       const { meta, body } = parseFrontMatter(raw);
       const name = basename3(f, ".md");
       out.push({
@@ -3196,7 +3770,7 @@ async function readSkillDirs(root) {
   return out;
 }
 async function loadCodexSlashEntries(cwd, opts) {
-  const home = homedir5();
+  const home = homedir6();
   const parts = await Promise.all([
     opts?.skipHome ? Promise.resolve([]) : readPromptFiles(join8(home, ".codex", "prompts")),
     readPromptFiles(join8(cwd, ".codex", "prompts")),
@@ -3536,7 +4110,7 @@ var init_types = __esm({
 });
 
 // daemon/src/providers/codex/provider.ts
-import { homedir as homedir6 } from "node:os";
+import { homedir as homedir7 } from "node:os";
 import { join as join9 } from "node:path";
 import { readFile as readFile8 } from "node:fs/promises";
 function runVersion2(r, args, timeoutMs = 5e3) {
@@ -3550,8 +4124,9 @@ function runVersion2(r, args, timeoutMs = 5e3) {
       }
       reject(new Error("timeout"));
     }, timeoutMs);
-    p.stdout?.on("data", (c) => out += c.toString());
-    p.stderr?.on("data", (c) => out += c.toString());
+    const od = new OutputDecoder(), ed = new OutputDecoder();
+    p.stdout?.on("data", (c) => out += od.write(c));
+    p.stderr?.on("data", (c) => out += ed.write(c));
     p.on("error", reject);
     p.on("close", (code) => {
       clearTimeout(t);
@@ -3637,7 +4212,7 @@ function parseCodexConfig(text) {
   return { modelProvider: provider, model: typeof model === "string" ? model : null, providerModels: [...models2] };
 }
 async function readCodexConfig() {
-  const home = process.env.CODEX_HOME?.trim() || join9(homedir6(), ".codex");
+  const home = process.env.CODEX_HOME?.trim() || join9(homedir7(), ".codex");
   const file = home.toLowerCase().endsWith(".toml") ? home : join9(home, "config.toml");
   try {
     return parseCodexConfig(await readFile8(file, "utf8"));
@@ -3722,6 +4297,7 @@ var init_provider2 = __esm({
     init_i18n();
     init_launch();
     init_types();
+    init_decode();
     INSTALL_HINT2 = "npm i -g @openai/codex";
     codexCapabilities = {
       resume: true,
@@ -3747,8 +4323,8 @@ var init_provider2 = __esm({
 function catalogById(id2) {
   return PROVIDER_CATALOG.find((p) => p.id === id2);
 }
-function providerCreatable(status) {
-  return status !== "planned";
+function providerCreatable(status2) {
+  return status2 !== "planned";
 }
 var PROVIDER_CATALOG;
 var init_catalog = __esm({
@@ -4104,6 +4680,7 @@ var init_session3 = __esm({
     init_prompt();
     init_i18n();
     init_log();
+    init_decode();
     AcpSession = class {
       constructor(o) {
         this.o = o;
@@ -4149,8 +4726,9 @@ var init_session3 = __esm({
         if (!bin.ok) throw new Error(bin.reason);
         try {
           this.child = spawnResolved(bin, launchArgv(this.o.acpArgs, this.o.launch), { cwd: this.o.cwd });
+          const errDec = new OutputDecoder();
           this.child.stderr?.on("data", (d) => {
-            const t = d.toString().trim();
+            const t = errDec.write(d).trim();
             if (t) log("info", `[${this.o.binName} acp] ${t.slice(0, 500)}`);
           });
           this.child.on("error", (e) => this.failInit(e));
@@ -4297,7 +4875,7 @@ var init_session3 = __esm({
           return hit?.id ?? want;
         }
         if (this.o.flavor === "cursor") {
-          const map = { default: "agent", plan: "plan", ask: "ask" };
+          const map = { default: "agent", bypassPermissions: "agent", plan: "plan", ask: "ask" };
           const want = map[mode2] ?? "agent";
           const avail = this.active?.modes?.availableModes ?? [];
           const hit = avail.find((m) => m.id === want || m.name.toLowerCase() === want);
@@ -4547,8 +5125,9 @@ function runVersion3(r, args, timeoutMs = 8e3) {
       }
       reject(new Error("timeout"));
     }, timeoutMs);
-    p.stdout?.on("data", (c) => out += c.toString());
-    p.stderr?.on("data", (c) => out += c.toString());
+    const od = new OutputDecoder(), ed = new OutputDecoder();
+    p.stdout?.on("data", (c) => out += od.write(c));
+    p.stderr?.on("data", (c) => out += ed.write(c));
     p.on("error", reject);
     p.on("close", (code) => {
       clearTimeout(t);
@@ -4563,7 +5142,7 @@ async function resolveProviderBin(cfg2) {
 }
 function createAcpProvider(cfg2) {
   const base = cfg2.capabilities ?? acpCapabilities;
-  const ORDER = ["plan", "default", "acceptEdits", "bypassPermissions"];
+  const ORDER = ["plan", "default", "acceptEdits", "bypassPermissions", "ask"];
   const caps = cfg2.modeMap ? { ...base, modes: ORDER.filter((m) => cfg2.modeMap[m] !== void 0), modeLabels: cfg2.modeLabels } : base;
   return {
     id: cfg2.id,
@@ -4628,6 +5207,7 @@ var init_provider3 = __esm({
     init_types();
     init_session3();
     init_promptCaps();
+    init_decode();
     acpCapabilities = {
       resume: true,
       interrupt: true,
@@ -4643,7 +5223,9 @@ var init_provider3 = __esm({
     cursorAcpCapabilities = {
       ...acpCapabilities,
       questions: true,
-      modes: ["default", "plan", "ask"]
+      // 1.3: bypassPermissions = 全部自动同意: Cursor's agent mode, every approval answered "allow once" by the daemon
+      // (Cursor's own --force only exists at spawn, and Auto-review is not applied over ACP)
+      modes: ["default", "bypassPermissions", "plan", "ask"]
     };
   }
 });
@@ -4752,8 +5334,9 @@ function probeAcpRaw(r, acpArgs, timeoutMs = 3e4, extMethod) {
     child.on("close", () => finish(new Error("ACP \u8FDB\u7A0B\u63D0\u524D\u9000\u51FA")));
     child.stderr?.on("data", () => {
     });
+    child.stdout?.setEncoding("utf8");
     child.stdout?.on("data", (d) => {
-      buf += d.toString();
+      buf += d;
       let n;
       while ((n = buf.indexOf("\n")) >= 0) {
         const line = buf.slice(0, n).trim();
@@ -4910,8 +5493,9 @@ function acpConfigForEntry(entry, appVersion) {
         ...base,
         acpArgs: ["acp"],
         fetchModels: acpProbeModels(["acp"], entry.id),
-        modeMap: { plan: "plan", default: "build" },
-        modeLabels: { plan: "Plan", default: "Build" }
+        // 1.3: 全部自动同意 = build + the daemon answers each approval "allow once" (OPENCODE_PERMISSION only applies at spawn)
+        modeMap: { plan: "plan", default: "build", bypassPermissions: "build" },
+        modeLabels: { plan: "Plan", default: "Build", bypassPermissions: "Build" }
       };
     case "copilot":
       return {
@@ -5033,13 +5617,13 @@ var init_pickFolderWin = __esm({
 
 // daemon/src/util/pickFolder.ts
 import { execFile as execFile2 } from "node:child_process";
-import { existsSync as existsSync8, statSync as statSync3 } from "node:fs";
+import { existsSync as existsSync8, statSync as statSync4 } from "node:fs";
 function appleScriptString(s) {
   return '"' + s.replace(/\\/g, "\\\\").replace(/"/g, '\\"') + '"';
 }
 function isDir(p) {
   try {
-    return !!p && existsSync8(p) && statSync3(p).isDirectory();
+    return !!p && existsSync8(p) && statSync4(p).isDirectory();
   } catch {
     return false;
   }
@@ -5088,20 +5672,20 @@ var init_pickFolder = __esm({
 
 // daemon/src/providers/magpieGateway.ts
 import { readFile as readFile11 } from "node:fs/promises";
-import { homedir as homedir7 } from "node:os";
+import { homedir as homedir8 } from "node:os";
 import { join as join11 } from "node:path";
-async function readJson(path3) {
+async function readJson(path4) {
   try {
-    return JSON.parse(await readFile11(path3, "utf8"));
+    return JSON.parse(await readFile11(path4, "utf8"));
   } catch {
     return null;
   }
 }
 async function readApplied() {
-  return await readJson(join11(homedir7(), ".config", "magpie", "applied.json")) ?? {};
+  return await readJson(join11(homedir8(), ".config", "magpie", "applied.json")) ?? {};
 }
 async function readClaudeEnv() {
-  const s = await readJson(join11(homedir7(), ".claude", "settings.json"));
+  const s = await readJson(join11(homedir8(), ".claude", "settings.json"));
   return s?.env ?? {};
 }
 async function gatewayBase() {
@@ -5202,7 +5786,7 @@ var init_magpieGateway = __esm({
 });
 
 // daemon/src/providers/infoCache.ts
-function withTimeout(p, ms, fb) {
+function withTimeout2(p, ms, fb) {
   return Promise.race([p, new Promise((r) => setTimeout(() => r(fb), ms))]);
 }
 function fresh(e, ttl) {
@@ -5218,7 +5802,7 @@ async function cachedDetect(p, launch) {
   let job = inflightDetect.get(key);
   if (!job) {
     const timedOut = { available: false, reason: tr("provider.timeout") };
-    job = withTimeout(
+    job = withTimeout2(
       p.detect(launch).catch((e) => ({ available: false, reason: String(e?.message ?? e) })),
       STEP_TIMEOUT_MS,
       timedOut
@@ -5236,7 +5820,7 @@ async function cachedModels(p, launch) {
   if (fresh(hit, MODELS_MS)) return hit.value;
   let job = inflightModels.get(key);
   if (!job) {
-    job = withTimeout(p.listModels(launch).catch(() => []), MODELS_TIMEOUT_MS, null).then(async (v) => {
+    job = withTimeout2(p.listModels(launch).catch(() => []), MODELS_TIMEOUT_MS, null).then(async (v) => {
       if (v === null) return models.get(key)?.value ?? [];
       const list = await withMagpie(p.id, dropPlaceholder(v)).catch(() => dropPlaceholder(v));
       models.set(key, { at: Date.now(), value: list });
@@ -5289,13 +5873,113 @@ var init_modes = __esm({
   }
 });
 
+// daemon/src/providers/autoApprove.ts
+function pickAllowOnce(options) {
+  const once = options.find((o) => o.kind === "allow_once");
+  if (once) return once;
+  const plain = options.find((o) => {
+    const s = `${o.id} ${o.label ?? ""}`;
+    return !o.kind?.startsWith("reject") && !REJECT.test(s) && ALLOW.test(s) && !/always|session|总是|始终/i.test(s);
+  });
+  return plain ?? null;
+}
+function autoApproveOption(mode2, providerId, req) {
+  if (mode2 !== FULL_AUTO) return null;
+  if (FULL_AUTO_NATIVE[providerId]?.daemonAnswers === false) return null;
+  if (req.kind === "plan" || req.kind === "switch_mode") return null;
+  return pickAllowOnce(req.options);
+}
+var FULL_AUTO, FULL_AUTO_NATIVE, REJECT, ALLOW;
+var init_autoApprove = __esm({
+  "daemon/src/providers/autoApprove.ts"() {
+    FULL_AUTO = "bypassPermissions";
+    FULL_AUTO_NATIVE = {
+      claude: { native: "--permission-mode bypassPermissions (+ --allow-dangerously-skip-permissions)", live: "nextTurn", daemonAnswers: true },
+      codex: { native: "approvalPolicy never + sandbox danger-full-access (turn/start)", live: "nextTurn", daemonAnswers: true },
+      cursor: { native: "none over ACP (--force is spawn-only); ACP mode agent", live: "live", daemonAnswers: true },
+      copilot: { native: "ACP config allow_all = on (agent mode)", live: "live", daemonAnswers: true },
+      opencode: { native: "none over ACP (OPENCODE_PERMISSION is spawn-only); ACP mode build", live: "live", daemonAnswers: true },
+      devin: { native: "ACP mode bypass", live: "live", daemonAnswers: true },
+      dsh: { native: "none known; ACP default mode", live: "live", daemonAnswers: true },
+      // pi never asks before its own tools; requestPermission only carries Pi extensions' own dialogs, which stay with the user
+      pi: { native: "always (Pi has no tool approvals)", live: "live", daemonAnswers: false },
+      mock: { native: "mock", live: "live", daemonAnswers: true }
+    };
+    REJECT = /reject|deny|decline|cancel|never|拒绝/i;
+    ALLOW = /allow|accept|approve|yes|允许|同意/i;
+  }
+});
+
+// daemon/src/migrate/autoApprove13.ts
+var autoApprove13_exports = {};
+__export(autoApprove13_exports, {
+  LEGACY_NO_AUTO: () => LEGACY_NO_AUTO,
+  MIGRATED_NOTICE_CODE: () => MIGRATED_NOTICE_CODE,
+  UPGRADE_NOTICE_CODE: () => UPGRADE_NOTICE_CODE,
+  endLegacyDefault: () => endLegacyDefault,
+  guardLegacyMode: () => guardLegacyMode,
+  migrateAutoApprove13: () => migrateAutoApprove13,
+  upgradeNotice: () => upgradeNotice
+});
+function state(s) {
+  const v = s[KEY];
+  return v && typeof v === "object" && v.done === true ? { done: true, legacyDefault: v.legacyDefault === true, noticed: v.noticed === true } : null;
+}
+async function migrateAutoApprove13(stores) {
+  const s = await stores.settings.get();
+  if (state(s)) return { threads: [], legacyDefault: false, skipped: true };
+  const moved = [];
+  for (const t of await stores.threads.list()) {
+    if (t.mode !== FULL_AUTO || !LEGACY_NO_AUTO.has(t.provider)) continue;
+    try {
+      await stores.threads.patch(t.id, { mode: "default" });
+      await stores.threads.appendEvent(t.id, { type: "notice", level: "warn", code: MIGRATED_NOTICE_CODE, message: tr("notice.autoApproveMigrated") });
+      moved.push(t.id);
+    } catch (e) {
+      log("warn", `\u5168\u90E8\u81EA\u52A8\u540C\u610F\u8FC1\u79FB\uFF1A\u5BF9\u8BDD ${t.id} \u5931\u8D25\uFF1A${String(e)}`);
+    }
+  }
+  const legacyDefault = s.defaultMode === FULL_AUTO;
+  await stores.settings.set({ [KEY]: { done: true, legacyDefault, noticed: false } });
+  if (moved.length || legacyDefault) log("info", `\u5168\u90E8\u81EA\u52A8\u540C\u610F\u8FC1\u79FB\uFF1A${moved.length} \u4E2A\u5BF9\u8BDD\u6539\u56DE\u6BCF\u6B21\u8BE2\u95EE\uFF1B\u65E7\u7684\u9ED8\u8BA4\u5168\u90E8\u653E\u884C=${legacyDefault}`);
+  return { threads: moved, legacyDefault, skipped: false };
+}
+async function guardLegacyMode(settings, providerId, mode2) {
+  if (mode2 !== FULL_AUTO || !LEGACY_NO_AUTO.has(providerId)) return { mode: mode2, notice: false };
+  const s = await settings.get();
+  const st = state(s);
+  if (!st?.legacyDefault) return { mode: mode2, notice: false };
+  if (st.noticed) return { mode: "default", notice: false };
+  await settings.set({ [KEY]: { ...st, noticed: true } });
+  return { mode: "default", notice: true };
+}
+async function endLegacyDefault(settings) {
+  const st = state(await settings.get());
+  if (st?.legacyDefault) await settings.set({ [KEY]: { ...st, legacyDefault: false } });
+}
+function upgradeNotice() {
+  return { type: "notice", level: "info", code: UPGRADE_NOTICE_CODE, message: tr("notice.autoApproveUpgrade") };
+}
+var LEGACY_NO_AUTO, UPGRADE_NOTICE_CODE, MIGRATED_NOTICE_CODE, KEY;
+var init_autoApprove13 = __esm({
+  "daemon/src/migrate/autoApprove13.ts"() {
+    init_autoApprove();
+    init_i18n();
+    init_log();
+    LEGACY_NO_AUTO = /* @__PURE__ */ new Set(["cursor", "opencode", "dsh"]);
+    UPGRADE_NOTICE_CODE = "auto_approve_upgrade";
+    MIGRATED_NOTICE_CODE = "auto_approve_migrated";
+    KEY = "autoApproveUpgrade";
+  }
+});
+
 // daemon/src/util/mentions.ts
 import { realpath, stat as stat8 } from "node:fs/promises";
 import { isAbsolute as isAbsolute2, resolve as resolve3, sep as sep2, win32 as win322, posix as posix2 } from "node:path";
 function insideRoot(root, child, platform = process.platform) {
   const p = platform === "win32" ? win322 : posix2;
-  const norm = (s) => platform === "win32" ? p.resolve(s).toLowerCase() : p.resolve(s);
-  const r = p.relative(norm(root), norm(child));
+  const norm2 = (s) => platform === "win32" ? p.resolve(s).toLowerCase() : p.resolve(s);
+  const r = p.relative(norm2(root), norm2(child));
   return r === "" || !r.startsWith("..") && !p.isAbsolute(r);
 }
 async function resolveMentions(projectPath, refs) {
@@ -5894,8 +6578,8 @@ var init_proxy = __esm({
           return;
         }
         l.lastUsed = this.now();
-        const path3 = (req.url ?? "/").split("?")[0];
-        if (path3 === PREVIEW_PING_PATH) {
+        const path4 = (req.url ?? "/").split("?")[0];
+        if (path4 === PREVIEW_PING_PATH) {
           const body = g.role === "canary" ? l.canaryNonce : l.nonce;
           res.writeHead(200, { "content-type": "text/plain; charset=utf-8", "cache-control": "no-store", "access-control-allow-origin": "null", "referrer-policy": "no-referrer" });
           res.end(req.method === "HEAD" ? void 0 : body);
@@ -5910,7 +6594,7 @@ var init_proxy = __esm({
           this.refuse(res, req, 403, "magpie");
           return;
         }
-        if (path3 === PREVIEW_SCRIPT_PATH) {
+        if (path4 === PREVIEW_SCRIPT_PATH) {
           res.writeHead(200, {
             "content-type": "text/javascript; charset=utf-8",
             "cache-control": "no-store",
@@ -6030,12 +6714,12 @@ var init_proxy = __esm({
           return;
         }
         const h = rewriteResponseHeaders(ur.headers, l.target, l.proxyOrigin);
-        const status = ur.statusCode ?? 502;
+        const status2 = ur.statusCode ?? 502;
         const ctype = String(ur.headers["content-type"] ?? "").toLowerCase();
         const encoded = !!ur.headers["content-encoding"] && ur.headers["content-encoding"] !== "identity";
-        const html = ctype.includes("text/html") && !encoded && req.method !== "HEAD" && status !== 204 && status !== 304;
+        const html = ctype.includes("text/html") && !encoded && req.method !== "HEAD" && status2 !== 204 && status2 !== 304;
         if (!html) {
-          res.writeHead(status, h);
+          res.writeHead(status2, h);
           ur.pipe(res);
           return;
         }
@@ -6048,7 +6732,7 @@ var init_proxy = __esm({
           chunks.push(c);
           if (size > this.maxHtml) {
             passthrough = true;
-            res.writeHead(status, h);
+            res.writeHead(status2, h);
             for (const x of chunks) res.write(x);
             ur.removeAllListeners("data");
             ur.removeAllListeners("end");
@@ -6059,7 +6743,7 @@ var init_proxy = __esm({
           if (passthrough) return;
           const out = Buffer.from(injectScriptTag(Buffer.concat(chunks).toString("latin1")), "latin1");
           h["content-length"] = String(out.length);
-          res.writeHead(status, h);
+          res.writeHead(status2, h);
           res.end(out);
         });
         ur.on("error", () => res.destroy());
@@ -6096,7 +6780,7 @@ connection: close\r
             return;
           }
           const up = l.target.secure ? tlsConnect({ host: addr, port: l.target.port, rejectUnauthorized: false, servername: this.servername(l) }) : netConnect({ host: addr, port: l.target.port });
-          const ready = l.target.secure ? "secureConnect" : "connect";
+          const ready2 = l.target.secure ? "secureConnect" : "connect";
           l.tunnels++;
           let counted = true;
           const done = () => {
@@ -6108,7 +6792,7 @@ connection: close\r
             up.destroy();
             socket.destroy();
           };
-          up.once(ready, () => {
+          up.once(ready2, () => {
             const lines = [`${req.method ?? "GET"} ${req.url ?? "/"} HTTP/1.1`];
             const hs = rewriteRequestHeaders(req.headers, l.target, l.proxyOrigin, true);
             for (const [k, v] of Object.entries(hs)) {
@@ -6147,9 +6831,9 @@ var init_host = __esm({
 
 // daemon/src/ws/methods.ts
 import { z } from "zod";
-import { existsSync as existsSync9, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync9, statSync as statSync5 } from "node:fs";
 import { mkdir as mkdir3, writeFile as writeFile4 } from "node:fs/promises";
-import { homedir as homedir8 } from "node:os";
+import { homedir as homedir9 } from "node:os";
 import { dirname as dirname3, join as join12, win32 as win32Path } from "node:path";
 import { execFile as execFile4 } from "node:child_process";
 function wrap(schema, fn) {
@@ -6173,6 +6857,14 @@ function registerMethods(gw, svc) {
     pid: process.pid,
     port: svc.cfg.port
   })));
+  gw.method("shell.status", wrap(zEmpty, async () => {
+    const st = agentShellStatus();
+    return { ...st, platform: process.platform, downloadUrl: GIT_FOR_WINDOWS_URL };
+  }));
+  gw.method("shell.check", wrap(z.object({ path: z.string().max(1024) }), (p) => {
+    if (process.platform !== "win32") return { ok: false, reason: "notWindows" };
+    return checkBashPath(p.path);
+  }));
   gw.method("app.shutdown", wrap(zEmpty, () => {
     setTimeout(() => process.exit(0), 100);
     return { ok: true };
@@ -6210,6 +6902,10 @@ function registerMethods(gw, svc) {
     if (!checked.ok) throw new ApiError("bad_params", `Invalid setting: ${checked.error}`);
     const before = await svc.settings.get();
     const next = await svc.settings.set(checked.patch);
+    if ("defaultMode" in checked.patch) await endLegacyDefault(svc.settings);
+    if ("bashPath" in checked.patch && (before.bashPath ?? "") !== (next.bashPath ?? "")) {
+      await refreshAgentShell(typeof next.bashPath === "string" ? next.bashPath : "");
+    }
     for (const id2 of Object.keys(checked.patch.providerCommand ?? {})) {
       if (JSON.stringify(before.providerCommand?.[id2] ?? null) !== JSON.stringify(next.providerCommand?.[id2] ?? null)) {
         clearProviderCache(id2);
@@ -6319,7 +7015,7 @@ function registerMethods(gw, svc) {
     let isDir2 = false;
     try {
       exists = existsSync9(p.path);
-      isDir2 = exists && statSync4(p.path).isDirectory();
+      isDir2 = exists && statSync5(p.path).isDirectory();
     } catch {
     }
     return { exists, isDir: isDir2 };
@@ -6356,8 +7052,10 @@ function registerMethods(gw, svc) {
         throw new ApiError("bad_params", tr("provider.plannedNamed", { name: cat.name }));
       }
       const provider = getProvider(p.provider);
-      const mode2 = clampMode(provider?.capabilities.modes ?? [], p.mode);
+      const guard = await guardLegacyMode(svc.settings, p.provider, clampMode(provider?.capabilities.modes ?? [], p.mode));
+      const mode2 = guard.mode;
       const meta = await svc.threads.create({ ...p, mode: mode2 });
+      if (guard.notice) await svc.threads.appendEvent(meta.id, upgradeNotice());
       gw.publish("sidebar", { type: "thread.upsert", thread: meta });
       return meta;
     }
@@ -6501,8 +7199,8 @@ function registerMethods(gw, svc) {
   gw.method("terminal.create", wrap(
     z.object({ projectId: z.string(), cols: z.number().int().min(20).max(500).default(80), rows: z.number().int().min(5).max(200).default(24) }),
     async (p) => {
-      const path3 = await projectPath(p.projectId);
-      const r = await svc.terminals.create(p.projectId, path3, p.cols, p.rows);
+      const path4 = await projectPath(p.projectId);
+      const r = await svc.terminals.create(p.projectId, path4, p.cols, p.rows);
       if ("error" in r) throw new ApiError("bad_params", r.error);
       return r;
     }
@@ -6529,10 +7227,12 @@ function registerMethods(gw, svc) {
       attachments: z.array(z.object({ path: z.string(), mime: z.string(), name: z.string().optional() })).optional(),
       // 1.2: paths dragged from the Files panel, relative to the project (the daemon resolves and checks them)
       mentions: z.array(z.object({ rel: z.string().min(1).max(4096), isDir: z.boolean().optional() })).max(MAX_MENTIONS).optional(),
-      behavior: z.enum(["queue", "steer"]).optional()
+      behavior: z.enum(["queue", "steer"]).optional(),
+      // 1.3: the page's id for its optimistic bubble, echoed on the user_message event (dedupe, no jump)
+      clientId: z.string().regex(/^[A-Za-z0-9_-]{1,64}$/).optional()
     }),
     async (p) => {
-      const delivered = await needManager().send(p.id, { text: p.text, attachments: p.attachments, mentions: p.mentions }, p.behavior ?? "queue");
+      const delivered = await needManager().send(p.id, { text: p.text, attachments: p.attachments, mentions: p.mentions, clientId: p.clientId }, p.behavior ?? "queue");
       return { ok: true, delivered: delivered ?? "started" };
     }
   ));
@@ -6650,7 +7350,7 @@ ${e.text}
     const markdown = L.join("\n");
     const safe = meta.title.replace(/[\\/:*?"<>|\s]+/g, "_").slice(0, 60) || "thread";
     const filename = `${safe}.md`;
-    let dir = join12(homedir8(), "Downloads");
+    let dir = join12(homedir9(), "Downloads");
     try {
       await mkdir3(dir, { recursive: true });
     } catch {
@@ -6696,9 +7396,12 @@ var init_methods = __esm({
     init_infoCache();
     init_launch();
     init_modes();
+    init_autoApprove13();
     init_i18n();
     init_mentions();
     init_openExternal();
+    init_agentShell();
+    init_gitBash();
     init_proxy();
     init_url();
     init_host();
@@ -6814,7 +7517,8 @@ var init_settings = __esm({
         z2.string().max(64),
         z2.object({ executable: z2.string().max(4096).optional(), args: z2.array(z2.string().max(4096)).max(64).optional() }).strict()
       ),
-      v1Migrated: z2.boolean()
+      v1Migrated: z2.boolean(),
+      bashPath: z2.string().max(1024)
     }).partial().strict();
     SettingsStore = class {
       file;
@@ -7177,8 +7881,8 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 function resolveDaemonMainJs() {
   const self = fileURLToPath(import.meta.url);
-  const norm = self.replace(/\\/g, "/");
-  if (norm.endsWith("/daemon/dist/main.js") || norm.endsWith("/dist/main.js")) return self;
+  const norm2 = self.replace(/\\/g, "/");
+  if (norm2.endsWith("/daemon/dist/main.js") || norm2.endsWith("/dist/main.js")) return self;
   const here = dirname(self);
   const candidates = [
     join(here, "..", "..", "dist", "main.js"),
@@ -7516,13 +8220,14 @@ var AttachmentStore = class {
 
 // daemon/src/main.ts
 init_settings();
+init_agentShell();
 
 // daemon/src/store/projects.ts
 init_atomic();
 init_paths();
 init_methods();
 import { readFile as readFile13 } from "node:fs/promises";
-import { existsSync as existsSync10, statSync as statSync5 } from "node:fs";
+import { existsSync as existsSync10, statSync as statSync6 } from "node:fs";
 import { join as join14 } from "node:path";
 import { randomBytes as randomBytes4 } from "node:crypto";
 function newId() {
@@ -7555,19 +8260,19 @@ var ProjectsStore = class {
     this.writing = this.writing.then(() => writeJsonAtomic(this.file, snap));
     await this.writing;
   }
-  async create(path3, name) {
-    if (!path3 || typeof path3 !== "string") throw new ApiError("bad_params", "\u8DEF\u5F84\u4E0D\u80FD\u4E3A\u7A7A");
-    if (!existsSync10(path3) || !statSync5(path3).isDirectory()) {
+  async create(path4, name) {
+    if (!path4 || typeof path4 !== "string") throw new ApiError("bad_params", "\u8DEF\u5F84\u4E0D\u80FD\u4E3A\u7A7A");
+    if (!existsSync10(path4) || !statSync6(path4).isDirectory()) {
       throw new ApiError("bad_path", "\u76EE\u5F55\u4E0D\u5B58\u5728\u6216\u4E0D\u662F\u6587\u4EF6\u5939");
     }
-    const np = normPath(path3);
+    const np = normPath(path4);
     const list = await this.list();
     const dup = list.find((p) => normPath(p.path) === np);
     if (dup) return dup;
     const proj = {
       id: newId(),
-      name: name?.trim() || path3.replace(/[\\/]+$/, "").split(/[\\/]/).pop() || path3,
-      path: path3,
+      name: name?.trim() || path4.replace(/[\\/]+$/, "").split(/[\\/]/).pop() || path4,
+      path: path4,
       createdAt: Date.now()
     };
     list.push(proj);
@@ -7616,6 +8321,15 @@ var ThreadsStore = class {
     });
     return p;
   }
+  /** Resolves once no meta / timeline write is queued or in flight (tests remove the data dir only after this) */
+  async idle() {
+    for (; ; ) {
+      const q = this.writeQ;
+      await q;
+      await new Promise((r) => setTimeout(r, 0));
+      if (q === this.writeQ) return;
+    }
+  }
   constructor(dataDir) {
     this.dir = join15(dataDir, "threads");
     this.trashDir = join15(dataDir, "trash", "threads");
@@ -7958,6 +8672,8 @@ init_registry();
 // daemon/src/agents/manager.ts
 init_launch();
 init_modes();
+init_autoApprove13();
+init_autoApprove();
 init_attachmentRefs();
 init_registry();
 init_catalog();
@@ -8007,8 +8723,16 @@ var Coalescer = class {
 init_methods();
 init_log();
 init_i18n();
+init_agentShell();
 init_mentions();
 init_commands();
+function titleText(text) {
+  const blocks = text.trim().split(/\n{2,}/);
+  let i = 0;
+  while (i < blocks.length && blocks[i].split("\n").every((l) => l === ">" || l.startsWith("> "))) i++;
+  const rest = blocks.slice(i).join(" ").trim();
+  return (rest || text.trim().replace(/^>\s?/gm, "")).replace(/\s+/g, " ").trim();
+}
 var SLASH_CACHE_TTL_MS = 10 * 60 * 1e3;
 var MAX_WARM_IDLE = 3;
 var DELTA_TYPES = ["assistant_delta", "reasoning_delta", "tool_output_delta"];
@@ -8115,6 +8839,8 @@ var AgentManager = class {
     if (!rt) return null;
     return {
       status: rt.status,
+      // true while startTurn runs (until session.send has returned): a "steer" sent then is queued instead
+      starting: rt.starting,
       queue: rt.queue,
       pending: [...rt.pending.values()].map((p) => ({
         requestId: p.requestId,
@@ -8159,6 +8885,8 @@ var AgentManager = class {
     for (const t of DELTA_TYPES) rt.coalescer.flushItem(deltaKey(t, itemId));
   }
   // ---- send ----
+  /** clientId: the page's id for its optimistic bubble; it rides on the user_message event so the page can swap the
+   *  bubble for the real one without a duplicate or a jump */
   async send(threadId, input, behavior = "queue") {
     const meta = await this.mustThread(threadId);
     const mentions = await this.resolveMentionRefs(threadId, meta.projectId, input.mentions);
@@ -8191,56 +8919,66 @@ var AgentManager = class {
             text: input.text,
             steered: true,
             attachments: this.attachmentLabels(attachmentRefs),
-            ...mentions.length ? { mentions } : {}
+            ...mentions.length ? { mentions } : {},
+            ...input.clientId ? { clientId: input.clientId } : {}
           });
           return "steered";
         } catch (e) {
           log("info", `thread ${threadId} \u63D2\u8BDD\u5931\u8D25\uFF0C\u6539\u4E3A\u6392\u961F\uFF1A${String(e)}`);
         }
       }
-      const q = { id: "q" + Date.now().toString(36) + Math.random().toString(36).slice(2, 6), text: input.text, attachments: attachmentRefs, ...mentions.length ? { mentions } : {} };
+      const q = { id: "q" + Date.now().toString(36) + Math.random().toString(36).slice(2, 6), text: input.text, attachments: attachmentRefs, ...mentions.length ? { mentions } : {}, ...input.clientId ? { clientId: input.clientId } : {} };
       rt.queue.push(q);
       this.gw.publish(`thread:${threadId}`, { type: "queue", queue: rt.queue });
       return "queued";
     }
-    await this.startTurn(threadId, input.text, attachmentRefs, mentions);
+    await this.startTurn(threadId, input.text, attachmentRefs, mentions, input.clientId);
     return "started";
   }
-  async startTurn(threadId, text, attachmentRefs, mentions = []) {
+  async startTurn(threadId, text, attachmentRefs, mentions = [], clientId) {
     const rt = this.rt(threadId);
     rt.starting = true;
     try {
-      await this.startTurnInner(threadId, text, attachmentRefs, mentions);
+      await this.startTurnInner(threadId, text, attachmentRefs, mentions, clientId);
     } finally {
       rt.starting = false;
     }
   }
-  async startTurnInner(threadId, text, attachmentRefs, mentions) {
+  async startTurnInner(threadId, text, attachmentRefs, mentions, clientId) {
     const meta = await this.mustThread(threadId);
     const rt = this.rt(threadId);
-    const provider = await this.assertProviderUsable(meta.provider, { allowDisabled: !!meta.providerSessionId });
+    const allowDisabled = !!meta.providerSessionId;
+    this.assertProviderAllowed(meta.provider, await this.settings.get(), { allowDisabled });
+    await this.appendRaw(threadId, {
+      type: "user_message",
+      text,
+      attachments: this.attachmentLabels(attachmentRefs),
+      ...mentions.length ? { mentions } : {},
+      ...clientId ? { clientId } : {}
+    });
+    const trimmed = titleText(text);
+    if (meta.titleAuto && trimmed) {
+      await this.threads.patch(threadId, { title: trimmed.slice(0, 40), titleAuto: true });
+      this.gw.publish("sidebar", { type: "thread.upsert", thread: await this.threads.get(threadId) });
+    }
     if (!rt.session) {
       await this.setStatus(threadId, "initializing");
       try {
+        await this.assertProviderUsable(meta.provider, { allowDisabled });
         await this.createSessionIfNeeded(threadId, { updateStatus: true });
       } catch (e) {
         await this.appendRaw(threadId, { type: "notice", level: "error", message: tr("notice.sessionStartFailed", { detail: String(e?.message ?? e) }) });
         await this.appendRaw(threadId, { type: "turn_ended", status: "failed", error: String(e?.message ?? e) });
+        await this.threads.patch(threadId, { lastTurnStatus: "failed" });
         await this.setStatus(threadId, "error");
         throw e;
       }
     }
-    const trimmed = text.trim();
-    if (meta.titleAuto && trimmed) {
-      await this.threads.patch(threadId, { title: trimmed.slice(0, 40), titleAuto: true });
-      this.gw.publish("sidebar", { type: "thread.upsert", thread: await this.threads.get(threadId) });
+    await agentShellReady();
+    if (!rt.bashHinted && bashMissingFor(meta.provider)) {
+      rt.bashHinted = true;
+      await this.appendRaw(threadId, { type: "notice", level: "warn", code: "bash_missing", message: tr("notice.bashMissing") });
     }
-    await this.appendRaw(threadId, {
-      type: "user_message",
-      text,
-      attachments: this.attachmentLabels(attachmentRefs),
-      ...mentions.length ? { mentions } : {}
-    });
     await this.setStatus(threadId, "running");
     try {
       const images = await this.resolveAttachments(attachmentRefs);
@@ -8342,9 +9080,21 @@ var AgentManager = class {
         },
         event: ev
       };
+      if (ev.type === "permission_request") {
+        const meta = await this.threads.get(threadId);
+        const auto = meta ? autoApproveOption(meta.mode, meta.provider, ev) : null;
+        if (auto) {
+          log("info", `thread ${threadId} \u81EA\u52A8\u540C\u610F ${ev.title.slice(0, 80)} \u2192 ${auto.id}`);
+          await this.appendRaw(threadId, { ...ev, auto: true });
+          await this.appendRaw(threadId, { type: "permission_resolved", requestId: ev.requestId, optionId: auto.id, auto: true });
+          rt.session?.respond(ev.requestId, { optionId: auto.id });
+          return;
+        }
+      }
       const toolName = ev.detail?.toolName;
       if (toolName && rt.allowAlways.has(toolName)) {
-        rt.session?.respond(ev.requestId, { optionId: "accept" });
+        const allow = options.find((o) => o.kind === "allow_once") ?? options.find((o) => o.kind === "allow_always");
+        rt.session?.respond(ev.requestId, { optionId: allow?.id ?? "accept" });
         return;
       }
       rt.pending.set(ev.requestId, pending);
@@ -8375,7 +9125,7 @@ var AgentManager = class {
       });
       if (next) {
         this.gw.publish(`thread:${threadId}`, { type: "queue", queue: rt.queue });
-        await this.startTurn(threadId, next.text, next.attachments, next.mentions ?? []).catch((e) => {
+        await this.startTurn(threadId, next.text, next.attachments, next.mentions ?? [], next.clientId).catch((e) => {
           log("warn", `thread ${threadId} \u6392\u961F\u6D88\u606F\u542F\u52A8\u5931\u8D25\uFF1A${String(e)}`);
         });
       }
@@ -8426,6 +9176,22 @@ var AgentManager = class {
     }
     rt.session?.respond(requestId, answer);
   }
+  /** Answer every waiting tool approval with its allow-once option (full-auto just turned on). Returns how many. */
+  async autoApprovePending(threadId, providerId, mode2) {
+    const rt = this.rt(threadId);
+    let n = 0;
+    for (const p of [...rt.pending.values()]) {
+      if (p.kind !== "permission") continue;
+      const ev = p.event;
+      const opt = autoApproveOption(mode2, providerId, { kind: ev.kind, options: p.options });
+      if (!opt) continue;
+      rt.pending.delete(p.requestId);
+      await this.appendRaw(threadId, { type: "permission_resolved", requestId: p.requestId, optionId: opt.id, auto: true });
+      rt.session?.respond(p.requestId, { optionId: opt.id });
+      n++;
+    }
+    return n;
+  }
   // ---- interrupt ----
   async interrupt(threadId) {
     const rt = this.rt(threadId);
@@ -8470,8 +9236,9 @@ var AgentManager = class {
     this.gw.publish("sidebar", { type: "thread.upsert", thread: await this.threads.get(threadId) });
   }
   async setMode(threadId, mode2) {
-    await this.threads.patch(threadId, { mode: mode2 });
+    const meta = await this.threads.patch(threadId, { mode: mode2 });
     const rt = this.rt(threadId);
+    if (mode2 === FULL_AUTO) await this.autoApprovePending(threadId, meta.provider, mode2);
     if (rt.session) await rt.session.setMode(mode2);
     this.gw.publish("sidebar", { type: "thread.upsert", thread: await this.threads.get(threadId) });
   }
@@ -8510,7 +9277,8 @@ var AgentManager = class {
       throw new ApiError("busy", tr("err.busySwitch"));
     }
     const events = await this.threads.readEvents(threadId, 0, 5e3);
-    if (events.some((e) => e.type === "user_message")) {
+    const neverRan = !meta.providerSessionId && !events.some((e) => e.type === "turn_started" || e.type === "assistant_message" || e.type === "tool_call");
+    if (events.some((e) => e.type === "user_message") && !neverRan) {
       throw new ApiError("bad_params", tr("err.hasMessages"));
     }
     const p = await this.assertProviderUsable(providerId);
@@ -8523,14 +9291,16 @@ var AgentManager = class {
       rt.commands = [];
     }
     rt.status = "idle";
+    const guard = await guardLegacyMode(this.settings, providerId, clampMode(p.capabilities.modes, meta.mode));
     await this.threads.patch(threadId, {
       provider: providerId,
       model: null,
-      mode: clampMode(p.capabilities.modes, meta.mode),
+      mode: guard.mode,
       effort: null,
       providerSessionId: null,
       status: "idle"
     });
+    if (guard.notice) await this.appendRaw(threadId, upgradeNotice());
     this.gw.publish("sidebar", { type: "thread.upsert", thread: await this.threads.get(threadId) });
   }
   async close(threadId) {
@@ -8647,6 +9417,7 @@ var AgentManager = class {
     const settings = await this.settings.get();
     const launch = launchFromSettings(settings, meta.provider);
     rt.deltasOnly = !!provider.capabilities.deltasOnly;
+    await agentShellReady();
     rt.session = await provider.createSession({
       threadId,
       cwd: proj.path,
@@ -8675,10 +9446,10 @@ var AgentManager = class {
   providerOf(meta) {
     return getProvider(meta.provider);
   }
-  async assertProviderUsable(providerId, opts = {}) {
+  /** The checks that start nothing: a known Agent, enabled (unless allowDisabled), not a planned one */
+  assertProviderAllowed(providerId, s, opts = {}) {
     const p = getProvider(providerId);
     if (!p) throw new ApiError("bad_params", tr("provider.unknown", { id: providerId }));
-    const s = await this.settings.get();
     if (!opts.allowDisabled && !isProviderEnabled(s, providerId)) {
       throw new ApiError("bad_params", tr("provider.disabledNamed", { name: p.name }));
     }
@@ -8686,16 +9457,21 @@ var AgentManager = class {
     if (entry && !providerCreatable(entry.status)) {
       throw new ApiError("bad_params", tr("provider.plannedNamed", { name: p.name }));
     }
+    return p;
+  }
+  async assertProviderUsable(providerId, opts = {}) {
+    const s = await this.settings.get();
+    const p = this.assertProviderAllowed(providerId, s, opts);
     const det = await cachedDetect(p, launchFromSettings(s, providerId));
     if (!det.available) throw new ApiError("bad_params", det.reason ?? tr("provider.unavailable", { name: p.name }));
     return p;
   }
-  async setStatus(threadId, status) {
+  async setStatus(threadId, status2) {
     const rt = this.rt(threadId);
-    rt.status = status;
-    const meta = await this.threads.patch(threadId, { status });
+    rt.status = status2;
+    const meta = await this.threads.patch(threadId, { status: status2 });
     this.gw.publish("sidebar", { type: "thread.upsert", thread: meta });
-    this.gw.publish(`thread:${threadId}`, { type: "status", status });
+    this.gw.publish(`thread:${threadId}`, { type: "status", status: status2 });
   }
   // Append an event: seq is assigned in the store's serialized section, persisted, then pushed to thread:<id>
   async appendRaw(threadId, ev) {
@@ -8740,6 +9516,7 @@ var AgentManager = class {
 
 // daemon/src/git/service.ts
 init_i18n();
+init_decode();
 import { execFile as execFile5 } from "node:child_process";
 import { existsSync as existsSync11 } from "node:fs";
 import { cp, mkdir as mkdir7, readFile as readFile16, rename as rename4, rm, stat as stat10 } from "node:fs/promises";
@@ -8748,10 +9525,11 @@ var TIMEOUT2 = 15e3;
 var DIFF_LIMIT = 1024 * 1024;
 function runGit(cwd, args) {
   return new Promise((res) => {
-    execFile5("git", ["-c", "core.quotepath=false", ...args], { cwd, timeout: TIMEOUT2, maxBuffer: 8 * 1024 * 1024, windowsHide: true }, (e, stdout, stderr) => {
+    execFile5("git", ["-c", "core.quotepath=false", ...args], { cwd, timeout: TIMEOUT2, maxBuffer: 8 * 1024 * 1024, windowsHide: true, encoding: "buffer" }, (e, stdout, stderr) => {
       const code = e && typeof e.code === "number" ? e.code : e ? 1 : 0;
       const missing = e?.code === "ENOENT";
-      res({ code, out: String(stdout ?? ""), err: missing ? tr("git.missing") : String(stderr || (e?.message ?? "")) });
+      const errText = stderr?.length ? decodeOutput(stderr) : "";
+      res({ code, out: stdout ? stdout.toString("utf8") : "", err: missing ? tr("git.missing") : errText || (e?.message ?? "") });
     });
   });
 }
@@ -8788,7 +9566,7 @@ var GitService = class {
       if (!rec5 || rec5.length < 4) continue;
       const index = rec5[0];
       const worktree = rec5[1];
-      let path3 = rec5.slice(3);
+      let path4 = rec5.slice(3);
       let kind = "modified";
       if (index === "?" && worktree === "?") kind = "untracked";
       else if (index === "R" || worktree === "R") {
@@ -8796,7 +9574,7 @@ var GitService = class {
         i++;
       } else if (index === "A" || worktree === "A") kind = "added";
       else if (index === "D" || worktree === "D") kind = "deleted";
-      files.push({ path: path3, index, worktree, kind });
+      files.push({ path: path4, index, worktree, kind });
     }
     return { isRepo: true, branch: br.out.trim() || void 0, files };
   }
@@ -8998,19 +9776,19 @@ var FileService = class {
 init_pathscan();
 init_log();
 init_i18n();
-import { spawn as spawn3, execFileSync as execFileSync2 } from "node:child_process";
-import { accessSync as accessSync2, chmodSync, constants as fsc, existsSync as existsSync12, statSync as statSync6 } from "node:fs";
+init_decode();
+import { spawn as spawn4, execFileSync as execFileSync2 } from "node:child_process";
+import { accessSync as accessSync2, chmodSync, constants as fsc, existsSync as existsSync12, statSync as statSync7 } from "node:fs";
 import { createRequire as moduleRequire } from "node:module";
 import { release } from "node:os";
 import { dirname as dirname6, join as join18 } from "node:path";
-import { StringDecoder } from "node:string_decoder";
 var MAX_TERMS_PER_PROJECT = 8;
 var BUF_MAX = 2 * 1024 * 1024;
 var SNAP_LINES = 5e3;
 function isExecFile(file) {
   try {
     accessSync2(file, fsc.X_OK);
-    return statSync6(file).isFile();
+    return statSync7(file).isFile();
   } catch {
     return false;
   }
@@ -9127,7 +9905,7 @@ var TerminalService = class {
     if (!term.pty) {
       term.simple = true;
       const args = simpleShellArgs(shell);
-      const proc = spawn3(shell, args, {
+      const proc = spawn4(shell, args, {
         cwd,
         stdio: "pipe",
         windowsHide: true,
@@ -9135,8 +9913,8 @@ var TerminalService = class {
         detached: process.platform !== "win32"
       });
       term.proc = proc;
-      const outDec = new StringDecoder("utf8");
-      const errDec = new StringDecoder("utf8");
+      const outDec = new OutputDecoder();
+      const errDec = new OutputDecoder();
       proc.stdout.on("data", (d) => this.onData(term, outDec.write(d)));
       proc.stderr.on("data", (d) => this.onData(term, errDec.write(d)));
       proc.on("exit", () => this.onExit(term));
@@ -9195,7 +9973,7 @@ var TerminalService = class {
     const args = ["/pid", String(pid), "/T", "/F"];
     try {
       if (sync) execFileSync2("taskkill", args, { windowsHide: true, stdio: "ignore", timeout: 5e3 });
-      else spawn3("taskkill", args, { windowsHide: true, stdio: "ignore" }).on("error", () => {
+      else spawn4("taskkill", args, { windowsHide: true, stdio: "ignore" }).on("error", () => {
       });
     } catch {
     }
@@ -9284,12 +10062,12 @@ function augmentPath(env, nodeDir, platform = process.platform, home) {
   const sep5 = win ? ";" : platform === process.platform ? delimiter : ":";
   const key = Object.keys(env).find((k) => k.toUpperCase() === "PATH") ?? "PATH";
   const cur = (env[key] ?? "").split(sep5).filter(Boolean);
-  const norm = (d) => win ? d.replace(/[\\/]+$/, "").toLowerCase() : d.replace(/\/+$/, "");
-  const seen = new Set(cur.map(norm));
+  const norm2 = (d) => win ? d.replace(/[\\/]+$/, "").toLowerCase() : d.replace(/\/+$/, "");
+  const seen = new Set(cur.map(norm2));
   const out = [...cur];
   for (const d of [nodeDir, ...extraBinDirs({ platform, env, home })]) {
-    if (!d || seen.has(norm(d))) continue;
-    seen.add(norm(d));
+    if (!d || seen.has(norm2(d))) continue;
+    seen.add(norm2(d));
     out.push(d);
   }
   return out.join(sep5);
@@ -9300,7 +10078,7 @@ init_proxy();
 
 // daemon/src/preview/ports.ts
 import { readFileSync as readFileSync2 } from "node:fs";
-import { homedir as homedir9 } from "node:os";
+import { homedir as homedir10 } from "node:os";
 import { basename as basename5, dirname as dirname7, isAbsolute as isAbsolute3, join as join19 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var MAGPIE_DEFAULT_PORTS = [3425, 3430];
@@ -9312,8 +10090,8 @@ function portOf(addr) {
   return Number.isInteger(n) && n > 0 && n <= 65535 ? n : null;
 }
 function magpieDirFromInstall(p) {
-  const norm = p.replace(/\\/g, "/");
-  const i = norm.lastIndexOf("/plugins/node_modules/");
+  const norm2 = p.replace(/\\/g, "/");
+  const i = norm2.lastIndexOf("/plugins/node_modules/");
   if (i <= 0) return null;
   return p.slice(0, i);
 }
@@ -9336,7 +10114,7 @@ function magpieConfigDirs(env = process.env, where = {}) {
   const x = env.XDG_CONFIG_HOME;
   if (x && isAbsolute3(x)) add(join19(x, "magpie"));
   const platform = where.platform ?? process.platform;
-  const home = where.home ?? (env === process.env ? homedir9() : platform === "win32" ? env.USERPROFILE : env.HOME);
+  const home = where.home ?? (env === process.env ? homedir10() : platform === "win32" ? env.USERPROFILE : env.HOME);
   if (home) add(join19(home, ".config", "magpie"));
   return out;
 }
@@ -9410,6 +10188,12 @@ async function main() {
   } catch (e) {
     log("error", "\u65E7\u6570\u636E\u8FC1\u79FB\u5931\u8D25", { err: String(e) });
   }
+  try {
+    const { migrateAutoApprove13: migrateAutoApprove132 } = await Promise.resolve().then(() => (init_autoApprove13(), autoApprove13_exports));
+    await migrateAutoApprove132({ settings, threads });
+  } catch (e) {
+    log("error", "\u5168\u90E8\u81EA\u52A8\u540C\u610F\u8FC1\u79FB\u5931\u8D25", { err: String(e) });
+  }
   const manager = new AgentManager(gateway, threads, projects, settings, attachments);
   await manager.recoverOnStart();
   const terminals = new TerminalService(gateway);
@@ -9459,6 +10243,7 @@ async function main() {
   const bound = server.address();
   if (bound && typeof bound === "object") cfg.port = bound.port;
   process.stdout.write(JSON.stringify({ agentConsoleReady: true, port: cfg.port, pid: process.pid }) + "\n");
+  void settings.get().then((s) => refreshAgentShell(typeof s.bashPath === "string" ? s.bashPath : ""));
   void (async () => {
     const { warmProviderCache: warmProviderCache2 } = await Promise.resolve().then(() => (init_warm(), warm_exports));
     await warmProviderCache2(await settings.get());