dsh-composer-ux 0.3.0 → 0.5.0

package/lib/index.js

@@ -419,8 +419,8 @@ for (const key of [
   return schema;
 } });
 var resolvers = {};
-Schema.extend = function extend(type, resolve2) {
-  resolvers[type] = resolve2;
+Schema.extend = function extend(type, resolve3) {
+  resolvers[type] = resolve3;
 };
 Schema.resolve = function resolve(data, schema, options = {}, strict = false) {
   if (!schema) return [data];
@@ -786,9 +786,253 @@ defineMethod("transform", [
   "preserve"
 ], ({ inner }, isInner) => inner.toString(isInner));
 
+// src/host.ts
+import { spawn } from "node:child_process";
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "node:path";
+import inspector from "node:inspector";
+
+// src/terminal/discover.ts
+var WSL_REASON = "WSL \u7684 bash\uFF1A\u5B83\u6309 Linux \u89C4\u5219\u89E3\u91CA\u8DEF\u5F84\uFF08D:\\x \u8981\u5199\u6210 /mnt/d/x\uFF09\uFF0C\u4E0E\u6A21\u578B\u624B\u91CC\u7684 Windows \u5DE5\u4F5C\u76EE\u5F55\u4E0D\u517C\u5BB9\uFF0C\u6545\u4E0D\u91C7\u7528";
+function normalizePath(value) {
+  const trimmed = value.trim().replace(/^"|"$/g, "");
+  const slashed = trimmed.replace(/\\/g, "/").replace(/\/{2,}/g, "/");
+  return slashed.length > 1 ? slashed.replace(/\/+$/, "") : slashed;
+}
+function isWslBash(value) {
+  const path = normalizePath(value).toLowerCase();
+  return /\/windows\/system32\/bash\.exe$/.test(path) || /\/windowsapps\/bash\.exe$/.test(path);
+}
+function candidateKindOf(value) {
+  const path = normalizePath(value).toLowerCase();
+  if (path.endsWith("/niu.exe") || path.includes("/niubash/")) return "niubash";
+  if (path.includes("/msys64/") || path.includes("/msys32/") || path.includes("/msys2/")) return "msys2";
+  if (path.includes("/cygwin")) return "cygwin";
+  if (/(^|\/)(portable)?git(\/|$)/.test(path)) return "git";
+  return "path";
+}
+function kindLabel(kind) {
+  switch (kind) {
+    case "git":
+      return "Git for Windows";
+    case "msys2":
+      return "MSYS2";
+    case "cygwin":
+      return "Cygwin";
+    case "niubash":
+      return "Niubash\uFF08\u725B bash\uFF09";
+    default:
+      return "PATH";
+  }
+}
+var KIND_RANK = { git: 0, msys2: 1, cygwin: 2, niubash: 3, path: 4 };
+var DRIVE_LETTERS = "CDEFGHIJKLMNOPQRSTUVWXYZ";
+function gitRootOf(entry) {
+  const path = normalizePath(entry);
+  if (path === "") return void 0;
+  const lower = path.toLowerCase();
+  for (const suffix of ["/mingw64/bin", "/mingw32/bin", "/usr/bin", "/cmd", "/bin"]) {
+    if (lower.endsWith(suffix)) return path.slice(0, path.length - suffix.length);
+  }
+  return path;
+}
+function bashPathsUnder(root) {
+  return [`${root}/bin/bash.exe`, `${root}/usr/bin/bash.exe`, `${root}/mingw64/bin/bash.exe`];
+}
+function unpreparedBashRoot(value) {
+  const match = /^(.*)\/(usr|mingw32|mingw64)\/bin\/bash\.exe$/i.exec(normalizePath(value));
+  return match?.[1];
+}
+function discoverBashCandidates(input) {
+  const seen = /* @__PURE__ */ new Set();
+  const excluded = [];
+  const ordered = [];
+  const dirsOf = (parent) => {
+    if (input.listDirs === void 0) return [];
+    try {
+      return input.listDirs(parent);
+    } catch {
+      return [];
+    }
+  };
+  const consider = (raw, label, isExplicit = false) => {
+    const path = normalizePath(raw);
+    if (path === "") return;
+    if (isWslBash(path)) {
+      if (!input.exists(path)) return;
+      if (!excluded.some((item) => item.path.toLowerCase() === path.toLowerCase())) {
+        excluded.push({ path, reason: WSL_REASON });
+      }
+      return;
+    }
+    if (!isExplicit) {
+      const root = unpreparedBashRoot(path);
+      if (root !== void 0 && input.exists(`${root}/bin/bash.exe`)) return;
+    }
+    const key = path.toLowerCase();
+    if (seen.has(key)) return;
+    if (!input.exists(path)) return;
+    seen.add(key);
+    const kind = candidateKindOf(path);
+    ordered.push({ path, kind, label: label ?? kindLabel(kind), explicit: isExplicit });
+  };
+  const addGroup = (group) => {
+    for (const root of group.roots) {
+      if (root === "" || !input.exists(root)) continue;
+      for (const path of bashPathsUnder(root)) consider(path, group.label);
+    }
+  };
+  const explicitRaw = normalizePath(input.explicitPath ?? "");
+  let explicit;
+  if (explicitRaw !== "") {
+    if (isWslBash(explicitRaw)) {
+      explicit = { path: explicitRaw, state: "wsl" };
+      if (input.exists(explicitRaw)) excluded.push({ path: explicitRaw, reason: WSL_REASON });
+    } else if (input.exists(explicitRaw)) explicit = { path: explicitRaw, state: "ok" };
+    else explicit = { path: explicitRaw, state: "missing" };
+  }
+  const entries = input.pathEntries.map((entry) => normalizePath(entry)).filter((entry) => entry !== "");
+  const env = (name2) => {
+    const value = input.env(name2);
+    return value === void 0 || value === "" ? void 0 : normalizePath(value);
+  };
+  const programFiles = env("ProgramFiles") ?? "C:/Program Files";
+  const programFilesX86 = env("ProgramFiles(x86)") ?? "C:/Program Files (x86)";
+  const programW6432 = env("ProgramW6432");
+  const localAppData = env("LOCALAPPDATA");
+  const home = env("USERPROFILE") ?? env("HOME");
+  const scoop = env("SCOOP") ?? (home === void 0 ? void 0 : `${home}/scoop`);
+  const choco = env("ChocolateyInstall") ?? (env("ProgramData") === void 0 ? "C:/ProgramData/chocolatey" : `${env("ProgramData")}/chocolatey`);
+  const versioned = [];
+  if (localAppData !== void 0) {
+    const desktop = `${localAppData}/GitHubDesktop`;
+    for (const dir of [...dirsOf(desktop)].sort().reverse()) {
+      if (dir.startsWith("app-")) versioned.push(`${desktop}/${dir}/resources/app/git`);
+    }
+    const github = `${localAppData}/GitHub`;
+    for (const dir of [...dirsOf(github)].sort().reverse()) {
+      if (dir.startsWith("PortableGit")) versioned.push(`${github}/${dir}`);
+    }
+  }
+  const vsRoot = `${programFiles}/Microsoft Visual Studio`;
+  for (const year of dirsOf(vsRoot)) {
+    const yearRoot = `${vsRoot}/${year}`;
+    for (const edition of dirsOf(yearRoot)) {
+      versioned.push(`${yearRoot}/${edition}/Common7/IDE/CommonExtensions/Microsoft/TeamFoundation/Team Explorer/Git`);
+    }
+  }
+  const drives = [];
+  for (const letter of DRIVE_LETTERS) {
+    const root = `${letter}:`;
+    if (input.exists(`${root}/`)) drives.push(root);
+  }
+  const driveRoots = (names) => drives.flatMap((root) => names.map((name2) => `${root}/${name2}`));
+  const groups = [
+    // 2) PATH 上认出来的 git 根 —— 那才是用户实际在用的那份。
+    ...entries.map((entry) => gitRootOf(entry)).filter((root) => root !== void 0).map((root) => ({ roots: [root] })),
+    // 3) 官方安装器的两个默认落点 + 32 位 / 重定向后的 Program Files。
+    { roots: [programFiles, programFilesX86, programW6432, localAppData === void 0 ? void 0 : `${localAppData}/Programs`].filter((base) => base !== void 0).map((base) => `${base}/Git`) },
+    // 4) Scoop（`scoop install git` 会带一份 bash）。
+    ...scoop === void 0 ? [] : [{ roots: [`${scoop}/apps/git/current`, `${scoop}/apps/git`], label: "Scoop \u7684 git" }],
+    // 5) Chocolatey 的便携包（`git.install` 装的仍在 Program Files，上面那条已覆盖）。
+    { roots: [`${choco}/lib/git.portable/tools`, `${choco}/lib/git.portable/tools/git`], label: "Chocolatey \u4FBF\u643A\u5305" },
+    // 6) GitHub Desktop / 旧 GitHub for Windows / Visual Studio 自带（都带版本号，靠 listDirs）。
+    { roots: versioned.filter((path) => path.includes("GitHubDesktop")), label: "GitHub Desktop \u5185\u5D4C" },
+    { roots: versioned.filter((path) => path.includes("/GitHub/PortableGit")), label: "GitHub PortableGit" },
+    { roots: versioned.filter((path) => path.includes("/Microsoft Visual Studio/")), label: "Visual Studio \u5185\u5D4C" },
+    // 7) MSYS2 / Cygwin 的常见位置（含各盘符根下的同名目录）。
+    { roots: [`${programFiles}/msys64`, "C:/msys64", ...driveRoots(["msys64"])], label: "MSYS2" },
+    { roots: [`${programFiles}/cygwin64`, "C:/cygwin64", "C:/cygwin", ...driveRoots(["cygwin64", "cygwin"])], label: "Cygwin" },
+    // 8) 各盘符根下的 Git / PortableGit（装在 D:\Git、D:\PortableGit 这类）。
+    { roots: driveRoots(["Git", "Program Files/Git", "Program Files (x86)/Git"]), label: "Git for Windows" },
+    { roots: driveRoots(["PortableGit"]), label: "PortableGit\uFF08\u81EA\u89E3\u538B\uFF09" }
+  ];
+  for (const group of groups) addGroup(group);
+  if (localAppData !== void 0) consider(`${localAppData}/Programs/Niubash/niu.exe`, "Niubash\uFF08\u725B bash\uFF09");
+  for (const entry of entries) consider(`${entry}/bash.exe`);
+  if (explicit?.state === "ok") consider(explicit.path, void 0, true);
+  const ranked = ordered.map((candidate, index) => ({ candidate, index })).sort((a, b) => {
+    if (a.candidate.explicit !== b.candidate.explicit) return a.candidate.explicit ? -1 : 1;
+    const rank = KIND_RANK[a.candidate.kind] - KIND_RANK[b.candidate.kind];
+    return rank !== 0 ? rank : a.index - b.index;
+  }).map((item) => item.candidate);
+  return {
+    candidates: ranked,
+    excluded,
+    ...explicit === void 0 ? {} : { explicit }
+  };
+}
+function defaultBashPath(result) {
+  return result.candidates[0]?.path ?? "";
+}
+
+// src/terminal/contracts.ts
+var TERMINAL_MODE_FIELD = "terminalMode";
+var TERMINAL_BASH_PATH_FIELD = "terminalBashPath";
+var TERMINAL_CANDIDATES_FIELD = "terminalCandidates";
+var TERMINAL_STATUS_FIELD = "terminalStatus";
+var TERMINAL_EFFECTIVE_FIELD = "terminalEffective";
+var DEFAULT_TERMINAL_MODE = "auto";
+function terminalModeFrom(value) {
+  return value === "auto" || value === "gitbash" || value === "pwsh" ? value : DEFAULT_TERMINAL_MODE;
+}
+function candidatesToStored(candidates) {
+  return candidates.map((candidate) => ({
+    path: candidate.path,
+    label: candidate.label,
+    kind: candidate.kind,
+    explicit: candidate.explicit
+  }));
+}
+function activeBashPath(mode, bashPath, candidates, explicitState) {
+  if (mode === "pwsh") return "";
+  const explicit = normalizePath(bashPath);
+  if (explicit !== "" && (explicitState === void 0 || explicitState.state === "ok")) return explicit;
+  return defaultBashPath({ candidates, excluded: [] });
+}
+function probeBash(explicitPath, pathValue, env, exists, listDirs) {
+  return discoverBashCandidates({
+    exists,
+    pathEntries: pathValue.split(";"),
+    env,
+    explicitPath,
+    ...listDirs === void 0 ? {} : { listDirs }
+  });
+}
+function terminalStatusText(input) {
+  const text = (() => {
+    if (input.platform !== "win32") {
+      return `\u672C\u63D2\u4EF6\u53EA\u5728 Windows \u4E0A\u63A5\u7BA1\u7EC8\u7AEF\uFF08\u5F53\u524D\u5E73\u53F0 ${input.platform}\uFF09\uFF0C\u6B64\u5904\u4E0D\u751F\u6548`;
+    }
+    if (input.mode === "pwsh") {
+      return "\u4FDD\u6301 DSH \u9ED8\u8BA4\uFF08PowerShell\uFF09\u2014\u2014\u672C\u63D2\u4EF6\u4E0D\u4ECB\u5165\u7EC8\u7AEF\u5DE5\u5177\u9762";
+    }
+    if (input.effective === "bash") {
+      const path = input.effectivePath ?? "";
+      const candidate = input.candidates.find((item) => item.path === path);
+      const suffix = input.explicit?.state === "missing" ? `\uFF08\u4F60\u586B\u7684\u8DEF\u5F84\u4E0D\u5B58\u5728\uFF1A${input.explicit.path}\uFF09` : input.explicit?.state === "wsl" ? `\uFF08\u4F60\u586B\u7684\u662F WSL \u7684 bash\uFF1A${input.explicit.path}\uFF09` : "";
+      return `\u5DF2\u751F\u6548\uFF1A${path}${candidate === void 0 ? "" : `\uFF08${candidate.label}\uFF09`}${suffix}`;
+    }
+    if (input.candidates.length === 0) {
+      const excluded = input.excludedCount > 0 ? `\uFF08\u5DF2\u6392\u9664 ${input.excludedCount} \u4E2A WSL \u7684 bash.exe\uFF09` : "";
+      return `\u6CA1\u627E\u5230\u53EF\u7528\u7684 bash${excluded}\uFF0C\u6682\u65F6\u4FDD\u6301 PowerShell`;
+    }
+    return `\u5019\u9009\u4E0D\u53EF\u7528\uFF0C\u6682\u65F6\u4FDD\u6301 PowerShell`;
+  })();
+  const failure = input.failure === void 0 || input.failure === "" ? "" : `\uFF1B\u4E0B\u53D1\u5931\u8D25\uFF1A${input.failure}`;
+  return `${text}${failure}`.slice(0, 400);
+}
+
 // src/settings-contract.ts
 var NAMESPACE = "composer-ux";
+var RESTART_API_PATH = "/composer-ux/restart";
 var ENABLED_FIELD = "enabled";
+var KEYS_ENABLED_FIELD = "keysEnabled";
+var MENU_ENABLED_FIELD = "menuEnabled";
+var QUICK_ENABLED_FIELD = "quickEnabled";
+var PANEL_ENABLED_FIELD = "panelEnabled";
+var TERMINAL_ENABLED_FIELD = "terminalEnabled";
 var SEND_KEY_FIELD = "sendKey";
 var NEWLINE_KEY_FIELD = "newlineKey";
 var PANEL_SCROLL_FIELD = "panelScroll";
@@ -804,7 +1048,14 @@ var MENU_FIELDS = [
   "menuDelete",
   "menuSelectAll"
 ];
+var MENU_MODE_FIELD = "menuMode";
 var MENU_NATIVE_FIELD = "menuNative";
+function menuModeFrom(storedMode, legacyNative) {
+  if (storedMode === "official" || storedMode === "browser" || storedMode === "custom") return storedMode;
+  if (legacyNative === true) return "browser";
+  if (legacyNative === false) return "custom";
+  return DEFAULT_SETTINGS.menuMode;
+}
 var QUICK_PROMPTS_FIELD = "quickPrompts";
 var OPTIMIZER_TIER_FIELD = "optimizerTier";
 var QUICK_PROMPT_MAX = 60;
@@ -820,15 +1071,15 @@ var OPTIMIZE_OUTPUT_MAX = 12e3;
 var OPTIMIZER_API_PATH = "/composer-ux/optimize";
 var DEFAULT_OPTIMIZER_TIER = "advanced";
 var DEFAULT_QUICK_PROMPTS = [
-  { id: "builtin-1", label: "\u4E00\u95EE\u4E00\u7B54", prompt: "\u4F60\u4E0D\u61C2\u7684\u5C31\u95EE\u6211\uFF0C\u4E00\u95EE\u4E00\u7B54\uFF1B\u540C\u65F6\u8BF4\u6E05\u695A\u4F60\u4E3A\u4EC0\u4E48\u8981\u95EE\u8BE5\u95EE\u9898\uFF1B\u76F4\u5230\u4F60\u5BF9\u6211\u7684\u76EE\u6807\u6709\u660E\u786E\u8BA4\u77E5\u540E\u518D\u5F00\u59CB\u5E72\u6D3B\u3002", always: false },
-  { id: "builtin-2", label: "\u4EA4\u63A5\u6587\u6863", prompt: "\u628A\u8FD9\u6B21\u4EFB\u52A1\u3001\u5DF2\u5B8C\u6210\u5185\u5BB9\u3001\u5F53\u524D\u5361\u70B9\u3001\u4E0B\u4E00\u6B65\u8BA1\u5212\u3001\u8E29\u8FC7\u7684\u5751\uFF0C\u6574\u7406\u6210\u4E00\u4EFD\u4EA4\u63A5\u6587\u6863\uFF0C\u5199\u7ED9\u65B0\u4F1A\u8BDD\u770B\u3002", always: false },
-  { id: "builtin-3", label: "\u4EC5\u8BF4\u660E\u539F\u56E0", prompt: "\u4EC5\u8BF4\u660E\u539F\u56E0\uFF0C\u4E0D\u8981\u505A\u5176\u4ED6\u52A8\u4F5C\u3002", always: false },
-  { id: "builtin-4", label: "\u5206\u6790\u540E\u76F4\u63A5\u5E72", prompt: "\u5206\u6790\u539F\u56E0\uFF0C\u7136\u540E\u76F4\u63A5\u5F00\u59CB\u5E72\u6D3B\uFF0C\u4E0D\u9700\u8981\u8FC7\u95EE\u6211\u3002", always: false },
-  { id: "builtin-5", label: "\u63D0\u4EA4\u4EE3\u7801", prompt: "\u8BF7\u5E2E\u6211\u63D0\u4EA4\u4EE3\u7801\uFF1A\u68C0\u67E5\u5F53\u524D git \u53D8\u66F4\uFF0C\u751F\u6210\u89C4\u8303\u7684 commit message \u5E76\u6267\u884C\u63D0\u4EA4\u3002", always: false },
-  { id: "builtin-6", label: "\u7ED9\u65B9\u6848", prompt: "\u8BF7\u9488\u5BF9\u4E0A\u9762\u7684\u95EE\u9898\u7ED9\u51FA\u4E00\u4E2A\u5B8C\u6574\u65B9\u6848\uFF0C\u5305\u62EC\u601D\u8DEF\u3001\u6B65\u9AA4\u3001\u6CE8\u610F\u4E8B\u9879\u548C\u98CE\u9669\u3002", always: false },
-  { id: "builtin-7", label: "\u89E3\u91CA\u4EE3\u7801", prompt: "\u8BF7\u89E3\u91CA\u8FD9\u6BB5\u4EE3\u7801\u7684\u4F5C\u7528\u548C\u5B9E\u73B0\u601D\u8DEF\u3002", always: false },
-  { id: "builtin-8", label: "\u5199\u6D4B\u8BD5", prompt: "\u8BF7\u4E3A\u4E0B\u9762\u7684\u4EE3\u7801\u7F16\u5199\u5355\u5143\u6D4B\u8BD5\u3002", always: false },
-  { id: "builtin-9", label: "\u4EE3\u7801\u5BA1\u67E5", prompt: "\u8BF7\u5BF9\u4E0B\u9762\u7684\u4EE3\u7801\u8FDB\u884C\u4EE3\u7801\u5BA1\u67E5\uFF0C\u6307\u51FA\u95EE\u9898\u5E76\u7ED9\u51FA\u6539\u8FDB\u5EFA\u8BAE\u3002", always: false }
+  { id: "builtin-1", label: "\u4E00\u95EE\u4E00\u7B54", prompt: "\u4F60\u4E0D\u61C2\u7684\u5C31\u95EE\u6211\uFF0C\u4E00\u95EE\u4E00\u7B54\uFF1B\u540C\u65F6\u8BF4\u6E05\u695A\u4F60\u4E3A\u4EC0\u4E48\u8981\u95EE\u8BE5\u95EE\u9898\uFF1B\u76F4\u5230\u4F60\u5BF9\u6211\u7684\u76EE\u6807\u6709\u660E\u786E\u8BA4\u77E5\u540E\u518D\u5F00\u59CB\u5E72\u6D3B\u3002", always: false, firstOnly: false },
+  { id: "builtin-2", label: "\u4EA4\u63A5\u6587\u6863", prompt: "\u628A\u8FD9\u6B21\u4EFB\u52A1\u3001\u5DF2\u5B8C\u6210\u5185\u5BB9\u3001\u5F53\u524D\u5361\u70B9\u3001\u4E0B\u4E00\u6B65\u8BA1\u5212\u3001\u8E29\u8FC7\u7684\u5751\uFF0C\u6574\u7406\u6210\u4E00\u4EFD\u4EA4\u63A5\u6587\u6863\uFF0C\u5199\u7ED9\u65B0\u4F1A\u8BDD\u770B\u3002", always: false, firstOnly: false },
+  { id: "builtin-3", label: "\u4EC5\u8BF4\u660E\u539F\u56E0", prompt: "\u4EC5\u8BF4\u660E\u539F\u56E0\uFF0C\u4E0D\u8981\u505A\u5176\u4ED6\u52A8\u4F5C\u3002", always: false, firstOnly: false },
+  { id: "builtin-4", label: "\u5206\u6790\u540E\u76F4\u63A5\u5E72", prompt: "\u5206\u6790\u539F\u56E0\uFF0C\u7136\u540E\u76F4\u63A5\u5F00\u59CB\u5E72\u6D3B\uFF0C\u4E0D\u9700\u8981\u8FC7\u95EE\u6211\u3002", always: false, firstOnly: false },
+  { id: "builtin-5", label: "\u63D0\u4EA4\u4EE3\u7801", prompt: "\u8BF7\u5E2E\u6211\u63D0\u4EA4\u4EE3\u7801\uFF1A\u68C0\u67E5\u5F53\u524D git \u53D8\u66F4\uFF0C\u751F\u6210\u89C4\u8303\u7684 commit message \u5E76\u6267\u884C\u63D0\u4EA4\u3002", always: false, firstOnly: false },
+  { id: "builtin-6", label: "\u7ED9\u65B9\u6848", prompt: "\u8BF7\u9488\u5BF9\u4E0A\u9762\u7684\u95EE\u9898\u7ED9\u51FA\u4E00\u4E2A\u5B8C\u6574\u65B9\u6848\uFF0C\u5305\u62EC\u601D\u8DEF\u3001\u6B65\u9AA4\u3001\u6CE8\u610F\u4E8B\u9879\u548C\u98CE\u9669\u3002", always: false, firstOnly: false },
+  { id: "builtin-7", label: "\u89E3\u91CA\u4EE3\u7801", prompt: "\u8BF7\u89E3\u91CA\u8FD9\u6BB5\u4EE3\u7801\u7684\u4F5C\u7528\u548C\u5B9E\u73B0\u601D\u8DEF\u3002", always: false, firstOnly: false },
+  { id: "builtin-8", label: "\u5199\u6D4B\u8BD5", prompt: "\u8BF7\u4E3A\u4E0B\u9762\u7684\u4EE3\u7801\u7F16\u5199\u5355\u5143\u6D4B\u8BD5\u3002", always: false, firstOnly: false },
+  { id: "builtin-9", label: "\u4EE3\u7801\u5BA1\u67E5", prompt: "\u8BF7\u5BF9\u4E0B\u9762\u7684\u4EE3\u7801\u8FDB\u884C\u4EE3\u7801\u5BA1\u67E5\uFF0C\u6307\u51FA\u95EE\u9898\u5E76\u7ED9\u51FA\u6539\u8FDB\u5EFA\u8BAE\u3002", always: false, firstOnly: false }
 ];
 function newQuickPromptId() {
   return `qp-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
@@ -855,7 +1106,13 @@ function asPromptRow(value) {
   const id = typeof row.id === "string" && row.id !== "" ? row.id.slice(0, 64) : newQuickPromptId();
   const order = typeof row.order === "number" && Number.isFinite(row.order) ? Math.max(1, Math.round(row.order)) : void 0;
   return {
-    prompt: { id, label: label === "" ? prompt.slice(0, 12) : label, prompt, always: row.always === true || row.autoSend === true },
+    prompt: {
+      id,
+      label: label === "" ? prompt.slice(0, 12) : label,
+      prompt,
+      always: row.always === true || row.autoSend === true,
+      firstOnly: row.firstOnly === true || row.autoSendFirst === true
+    },
     order
   };
 }
@@ -918,6 +1175,8 @@ function bookToFile(book) {
         title: prompt.label,
         text: prompt.prompt,
         autoSend: prompt.always,
+        // 「仅首次」是我们加的键，只在为真时写出来：文件形状尽量贴近参考实现。
+        ...prompt.firstOnly ? { autoSendFirst: true } : {},
         order: index + 1
       }))
     }))
@@ -937,7 +1196,14 @@ var DEFAULT_HEADER_NAME = "x-opencode-session";
 var HEADER_VALUE_MAX = 200;
 var HEADER_NAME_MAX = 64;
 var DEFAULT_SETTINGS = {
+  // 总开关默认开：它只是总闸，真正"要不要用这一栏"由下面五个开关决定（默认关）。
   enabled: true,
+  // 五栏默认关（老文档由 sectionEnabledOf 迁移成"碰过就开"）。
+  keysEnabled: false,
+  menuEnabled: false,
+  quickEnabled: false,
+  panelEnabled: false,
+  terminalEnabled: false,
   sendKey: "Enter",
   newlineKey: "Shift+Enter",
   menuUndo: true,
@@ -947,7 +1213,7 @@ var DEFAULT_SETTINGS = {
   menuPaste: true,
   menuDelete: true,
   menuSelectAll: true,
-  menuNative: false,
+  menuMode: "official",
   panelScroll: true,
   panelResize: true,
   headerEnabled: false,
@@ -958,7 +1224,12 @@ var DEFAULT_SETTINGS = {
   headerAppliedValue: "",
   headerStatus: "",
   quickPrompts: DEFAULT_QUICK_PROMPTS,
-  optimizerTier: DEFAULT_OPTIMIZER_TIER
+  optimizerTier: DEFAULT_OPTIMIZER_TIER,
+  terminalMode: DEFAULT_TERMINAL_MODE,
+  terminalBashPath: "",
+  terminalCandidates: [],
+  terminalStatus: "",
+  terminalEffective: ""
 };
 function newSessionId() {
   const bag = globalThis;
@@ -973,6 +1244,950 @@ function parseRouteList(text) {
   const parts = text.split(/[\s,，、]+/).map((item) => item.trim()).filter((item) => item !== "");
   return [...new Set(parts)];
 }
+var SECTION_SIGNALS = {
+  [KEYS_ENABLED_FIELD]: (source) => touched(source, SEND_KEY_FIELD, DEFAULT_SETTINGS.sendKey) || touched(source, NEWLINE_KEY_FIELD, DEFAULT_SETTINGS.newlineKey),
+  // 「官方」＝本插件不介入，等价于关；所以只有选过另外两档才算"碰过"。
+  // （`menuModeFrom` 对"两个键都没有"给的就是 'official'，天然满足"缺省 = 默认"。）
+  [MENU_ENABLED_FIELD]: (source) => menuModeFrom(source[MENU_MODE_FIELD], source[MENU_NATIVE_FIELD]) !== "official",
+  [QUICK_ENABLED_FIELD]: (source) => Array.isArray(source[QUICK_PROMPTS_FIELD]) && source[QUICK_PROMPTS_FIELD].length !== DEFAULT_QUICK_PROMPTS.length || touched(source, OPTIMIZER_TIER_FIELD, DEFAULT_OPTIMIZER_TIER),
+  [PANEL_ENABLED_FIELD]: (source) => touched(source, PANEL_SCROLL_FIELD, true) || touched(source, PANEL_RESIZE_FIELD, true) || source[PANEL_WIDTH_FIELD] !== void 0 || source[PANEL_HEIGHT_FIELD] !== void 0,
+  [TERMINAL_ENABLED_FIELD]: (source) => touched(source, TERMINAL_MODE_FIELD, DEFAULT_TERMINAL_MODE) || touched(source, TERMINAL_BASH_PATH_FIELD, "")
+};
+function touched(source, field, untouched) {
+  const value = source[field];
+  return value !== void 0 && value !== untouched;
+}
+function sectionEnabledOf(field, source) {
+  const explicit = source[field];
+  if (typeof explicit === "boolean") return explicit;
+  const signal = SECTION_SIGNALS[field];
+  return signal === void 0 ? false : signal(source);
+}
+
+// src/terminal/host.ts
+import { existsSync, readdirSync } from "node:fs";
+import { isAbsolute, sep } from "node:path";
+
+// src/terminal/sandbox.ts
+var WIDER_MODES = {
+  "read-only": ["workspace-write", "danger-full-access"],
+  "workspace-write": ["danger-full-access"]
+};
+var ESCALATION_TARGETS = ["workspace-write", "danger-full-access"];
+function sandboxDenialMarker(mode) {
+  return `[sandbox: file access denied under ${mode} mode]`;
+}
+function escalationHintMarker(subject) {
+  return `[sandbox: escalation available \u2014 retry this exact ${subject} once with sandbox_permissions (the narrowest wider mode that suffices) + justification; the approval prompt asks the user]`;
+}
+function validateEscalationArgs(sandboxPermissions, justification) {
+  if (sandboxPermissions !== void 0 && justification === void 0) {
+    throw new Error("invalid escalation: sandbox_permissions requires a justification");
+  }
+  if (justification !== void 0 && sandboxPermissions === void 0) {
+    throw new Error("invalid escalation: justification is only valid together with sandbox_permissions");
+  }
+  if (justification !== void 0 && justification.trim().length === 0) {
+    throw new Error("invalid justification: expected a non-empty sentence");
+  }
+}
+async function approveEscalation(request, approval) {
+  const { requestedMode: mode, effectiveMode, justification, subject } = request;
+  if (mode === effectiveMode) return effectiveMode;
+  if (!(WIDER_MODES[effectiveMode] ?? []).includes(mode)) {
+    throw new Error(`sandbox escalation to "${mode}" is not strictly wider than this call's current "${effectiveMode}" mode`);
+  }
+  if (approval.approver === void 0) {
+    throw new Error(`sandbox escalation to "${mode}" requires approval, but no approval service is composed`);
+  }
+  if (approval.agent === void 0) {
+    throw new Error(`sandbox escalation to "${mode}" requires approval, but the call has no agent to route it through`);
+  }
+  const outcome = await approval.approver.request({
+    agent: approval.agent,
+    toolName: approval.toolName,
+    callId: approval.callId,
+    reason: `escalate sandbox to ${mode}: ${justification}`,
+    ...approval.signal === void 0 ? {} : { signal: approval.signal }
+  });
+  switch (outcome) {
+    case "allowed-once":
+      return mode;
+    case "rejected":
+      throw new Error(`the user rejected escalating this ${subject} to "${mode}"`);
+    case "cancelled":
+      throw new Error(`approval for escalating to "${mode}" was cancelled`);
+    case "unavailable":
+      throw new Error(`sandbox escalation to "${mode}" requires approval, but no approval channel is available`);
+    default:
+      throw new Error(`unexpected escalation outcome ${JSON.stringify(outcome)}`);
+  }
+}
+
+// src/terminal/render.ts
+function parseExitStatus(text) {
+  const signal = /\n\[killed by signal: ([^\]\n]+)\]$/.exec(text);
+  if (signal?.[1] !== void 0) return { body: text.slice(0, signal.index), signal: signal[1] };
+  const exit = /\n\[exit code: (\d+)\]$/.exec(text);
+  if (exit?.[1] !== void 0) return { body: text.slice(0, exit.index), exitCode: Number(exit[1]) };
+  return { body: text, exitCode: 0 };
+}
+function streamText(output) {
+  if (!output.truncated) return output.text;
+  return `${output.text}
+[output truncated; full output: ${output.spillPath ?? "(unavailable)"}]`;
+}
+function renderBashResult(result, escalationModes = []) {
+  const out = streamText(result.stdout);
+  const err = streamText(result.stderr);
+  let body = out;
+  if (err.length > 0) {
+    if (body.length > 0 && !body.endsWith("\n")) body += "\n";
+    body += `[stderr]
+${err}`;
+  }
+  if (body.length === 0) body = "(no output)";
+  const markers = [];
+  if (result.sandbox?.denied === true) {
+    markers.push(sandboxDenialMarker(result.sandbox.mode));
+    if (escalationModes.length > 0) markers.push(escalationHintMarker("command"));
+  }
+  if (result.timedOut) markers.push(`[timed out after ${result.timeoutMs}ms]`);
+  if (result.signal !== null) markers.push(`[killed by signal: ${result.signal}]`);
+  else if (result.exitCode !== 0) markers.push(`[exit code: ${result.exitCode}]`);
+  if (markers.length === 0) return body;
+  if (!body.endsWith("\n")) body += "\n";
+  return body + markers.join("\n");
+}
+function renderProcessRead(read, sandbox, escalationModes = []) {
+  const notices = [];
+  if (read.lossy) {
+    const paths = [read.stdoutSpillPath, read.stderrSpillPath].filter((path) => path !== void 0);
+    notices.push(`[some output was dropped from memory; full output: ${paths.length > 0 ? paths.join(", ") : "(unavailable)"}]`);
+  }
+  if (sandbox?.runnerFailed === true) {
+    notices.push(`[sandbox: the sandbox runner itself failed under ${sandbox.mode} mode \u2014 the command did not run; this is a sandbox problem, not a command failure]`);
+  } else if (sandbox?.denied === true) {
+    notices.push(sandboxDenialMarker(sandbox.mode));
+    if (escalationModes.length > 0) notices.push(escalationHintMarker("command"));
+  }
+  if (notices.length === 0) return read.delta;
+  const separator = read.delta.length > 0 && !read.delta.endsWith("\n") ? "\n" : "";
+  return `${read.delta}${separator}${notices.join("\n")}`;
+}
+
+// src/terminal/tool.ts
+var BASH_TOOL_NAME = "bash";
+var TOOL_BASH_SECTION_ORDER = 1e3;
+var BASH_SECTION_TEXT = "Check the [exit code: N] marker on every bash result; investigate failures before moving on.";
+var DEFAULT_TIMEOUT_MS = 12e4;
+var MAX_TIMEOUT_MS = 6e5;
+var MAX_OUTPUT_BYTES = 64e3;
+var MAX_SPILL_BYTES = 64 * 1024 * 1024;
+var GRACE_MS = 3e3;
+var TOOL_ABORTED = "ABORTED";
+var ENV_OVERRIDES = {
+  NO_COLOR: "1",
+  TERM: "dumb",
+  PAGER: "cat",
+  GIT_PAGER: "cat"
+};
+function escalationModesOf(deps) {
+  return deps.sandbox !== void 0 && deps.sandboxPolicy !== void 0 ? ESCALATION_TARGETS : [];
+}
+function bashDescription(backgroundEnabled, escalationModes) {
+  const background = backgroundEnabled ? "Set `run_in_background: true` for long-running commands: the call returns a job id immediately; read its output with `job_output` and stop it with `job_kill`." : "Background execution is not available; long-running commands must finish within the timeout.";
+  const base = "Execute a bash command (`bash -c`) and return its stdout/stderr. Each call runs in a fresh shell: no state (cwd, variables, functions) persists between calls \u2014 pass `workdir` instead of using `cd`. Non-zero exits are reported as `[exit code: N]`. Current harness environment facts are exposed through managed `$DSH_*` variables; inspect them when needed. Commands may run under a file sandbox; a blocked file operation is reported as `[sandbox: file access denied under <mode> mode]` \u2014 a policy denial, not a bug in the command; do not retry another way. Long output is truncated to its tail; the full output is saved to a file whose path is reported when available. " + background;
+  if (escalationModes.length === 0) return base;
+  return base + " Attempting a command the sandbox may deny is safe and expected: run it and read the marker rather than assuming the denial. When a command is denied and a wider mode would let it succeed, escalate immediately in the same turn \u2014 the one sanctioned exception to a denial: retry the exact same command once with `sandbox_permissions` (the narrowest wider mode that suffices) plus a one-sentence `justification`. Do not detour through chat to ask permission first \u2014 the approval prompt raised by that retry is how the user consents. If the session states approval prompts are disabled, there is no exception: a denial is final \u2014 do not set `sandbox_permissions`. Never escalate speculatively: ground the request in a real denial \u2014 normally the one this command just hit; escalating up front is fine only when this session already denied the same access. A rejected escalation is final for that command \u2014 stop and explain, never work around it \u2014 but it does not forbid attempting or escalating other commands later.";
+}
+function bashParameters(escalationModes) {
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      command: { type: "string", description: "The bash command to execute." },
+      description: {
+        type: "string",
+        description: 'Clear, concise description of what this command does in active voice, 5-10 words (shown in the UI). Examples: "ls" \u2192 "List files in current directory"; "git status" \u2192 "Show working tree status"; "npm install" \u2192 "Install package dependencies".'
+      },
+      timeoutMs: {
+        type: "number",
+        description: "Timeout in milliseconds. The executor applies its configured default and cap, and kills the command on expiry."
+      },
+      workdir: {
+        type: "string",
+        description: "Working directory for this command. Defaults to the session workspace; a relative path is resolved against it."
+      },
+      ...escalationModes.length === 0 ? {} : {
+        sandbox_permissions: {
+          type: "string",
+          enum: [...escalationModes],
+          description: "The wider sandbox mode this command needs. Only valid as a one-shot retry of a command the sandbox just denied; requires justification and user approval."
+        },
+        justification: {
+          type: "string",
+          description: "Required with sandbox_permissions: one sentence for the user explaining why this exact command needs the wider access."
+        }
+      }
+    },
+    required: ["command", "description"]
+  };
+}
+function bashOutputSchema() {
+  const stream = {
+    type: "object",
+    additionalProperties: false,
+    required: ["text", "truncated"],
+    properties: {
+      text: { type: "string" },
+      truncated: { type: "boolean" },
+      spillPath: { type: "string" }
+    }
+  };
+  return {
+    oneOf: [
+      {
+        type: "object",
+        additionalProperties: false,
+        required: ["kind", "jobId"],
+        properties: {
+          kind: { type: "string", const: "background" },
+          jobId: { type: "string" }
+        }
+      },
+      {
+        type: "object",
+        additionalProperties: false,
+        required: ["kind", "exitCode", "signal", "timedOut", "aborted", "timeoutMs", "stdout", "stderr"],
+        properties: {
+          kind: { type: "string", const: "foreground" },
+          exitCode: { oneOf: [{ type: "integer" }, { type: "null" }] },
+          signal: { oneOf: [{ type: "string" }, { type: "null" }] },
+          timedOut: { type: "boolean" },
+          aborted: { type: "boolean" },
+          timeoutMs: { type: "number" },
+          stdout: stream,
+          stderr: stream,
+          sandbox: {
+            type: "object",
+            additionalProperties: false,
+            required: ["mode", "denied"],
+            properties: {
+              mode: { type: "string" },
+              denied: { type: "boolean" },
+              enforcement: { type: "string" },
+              runnerFailed: { type: "boolean" }
+            }
+          }
+        }
+      }
+    ]
+  };
+}
+function clampTimeout(requested, min, max) {
+  if (requested === void 0 || !Number.isFinite(requested) || requested <= 0) return min;
+  return Math.min(Math.max(requested, min), max);
+}
+function resolveWorkdir(modelWorkdir, exec, policyWorkspaceRoot, sep2, isAbsolute2) {
+  const headerCwd = exec.agent?.session.header.cwd;
+  const sessionCwd = policyWorkspaceRoot ?? headerCwd;
+  if (modelWorkdir === void 0) return sessionCwd;
+  if (sessionCwd !== void 0 && !isAbsolute2(modelWorkdir)) return `${sessionCwd}${sep2}${modelWorkdir}`;
+  return modelWorkdir;
+}
+function abortedError() {
+  const error = new Error("tool call aborted");
+  error.name = "AbortError";
+  error.code = TOOL_ABORTED;
+  return error;
+}
+function createBashTool(deps, options) {
+  const escalationModes = escalationModesOf(deps);
+  const sep2 = options.sep ?? "\\";
+  const isAbsolute2 = options.isAbsolute ?? ((path) => /^([a-zA-Z]:[\\/]|[\\/])/.test(path));
+  const minTimeout = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const maxTimeout = options.maxTimeoutMs ?? MAX_TIMEOUT_MS;
+  const spawnSpec = (argv, cwd, dshEnv, signal) => ({
+    argv,
+    cwd,
+    stdio: {
+      stdin: "ignore",
+      stdout: { maxBytes: MAX_OUTPUT_BYTES, spill: { maxBytes: MAX_SPILL_BYTES } },
+      stderr: { maxBytes: MAX_OUTPUT_BYTES, spill: { maxBytes: MAX_SPILL_BYTES } }
+    },
+    graceMs: GRACE_MS,
+    ...signal === void 0 ? {} : { signal },
+    // dshEnv 必须显式带上：subprocess 会先按凭据形状清洗父环境（含清掉所有 DSH_*）。
+    env: { ...ENV_OVERRIDES, ...dshEnv }
+  });
+  const readFrame = (handle, offsets) => {
+    const outRead = handle.collected.stdout?.readFrom(offsets.stdout);
+    const errRead = handle.collected.stderr?.readFrom(offsets.stderr);
+    offsets.stdout = outRead?.nextOffset ?? offsets.stdout;
+    offsets.stderr = errRead?.nextOffset ?? offsets.stderr;
+    const outText = outRead?.text ?? "";
+    const errText = errRead?.text ?? "";
+    const separator = outText.length > 0 && !outText.endsWith("\n") ? "\n" : "";
+    return {
+      delta: outText + (errText.length > 0 ? `${separator}[stderr]
+${errText}` : ""),
+      lossy: (outRead?.lossy ?? false) || (errRead?.lossy ?? false),
+      ...outRead?.spillPath === void 0 ? {} : { stdoutSpillPath: outRead.spillPath },
+      ...errRead?.spillPath === void 0 ? {} : { stderrSpillPath: errRead.spillPath }
+    };
+  };
+  const execute = async (rawArgs, exec) => {
+    const args = rawArgs;
+    if (args.command.trim().length === 0) throw new Error("invalid command: expected a non-empty string");
+    if (args.description.trim().length === 0) throw new Error("invalid description: expected a non-empty string");
+    if (args.timeoutMs !== void 0 && (!Number.isFinite(args.timeoutMs) || args.timeoutMs <= 0)) {
+      throw new Error(`invalid timeoutMs: expected a positive number, got ${JSON.stringify(args.timeoutMs)}`);
+    }
+    validateEscalationArgs(args.sandbox_permissions, args.justification);
+    const standingPolicy = deps.sandboxPolicy?.resolve(
+      exec.agent === void 0 ? {} : { session: exec.agent.session }
+    );
+    const approvedMode = args.sandbox_permissions !== void 0 && args.justification !== void 0 ? await approveEscalation(
+      {
+        requestedMode: args.sandbox_permissions,
+        justification: args.justification,
+        effectiveMode: standingPolicy.mode,
+        subject: "command"
+      },
+      {
+        approver: deps.approval,
+        agent: exec.agent,
+        callId: exec.callId,
+        toolName: BASH_TOOL_NAME,
+        signal: exec.signal
+      }
+    ) : void 0;
+    const policy = approvedMode === void 0 ? standingPolicy : { ...standingPolicy, mode: approvedMode };
+    const workdir = resolveWorkdir(args.workdir, exec, standingPolicy?.workspaceRoot, sep2, isAbsolute2);
+    const dshEnv = deps.shellEnv?.collect(exec) ?? {};
+    let argv = [options.bashPath, "-c", args.command];
+    let confined;
+    if (policy !== void 0 && policy.mode !== "danger-full-access" && deps.sandbox !== void 0) {
+      confined = await deps.sandbox.confine(argv, { ...policy, mode: policy.mode });
+      argv = confined.argv;
+    }
+    const timeoutMs = clampTimeout(args.timeoutMs, minTimeout, maxTimeout);
+    if (args.run_in_background === true) {
+      const jobs = deps.jobs;
+      if (jobs === void 0) {
+        throw new Error("background jobs unavailable: load @deepseek-ai/dsh-jobs and @deepseek-ai/dsh-tool-jobs");
+      }
+      if (exec.signal.aborted) throw abortedError();
+      const id = jobs.start({
+        kind: "bash",
+        label: args.command,
+        ...exec.agent === void 0 ? {} : { owner: exec.agent },
+        run: () => {
+          const controller2 = new AbortController();
+          let handle2;
+          const offsets = { stdout: 0, stderr: 0 };
+          const done = (async () => {
+            try {
+              handle2 = deps.subprocess.spawn(spawnSpec(argv, workdir ?? process.cwd(), dshEnv, controller2.signal));
+              if (controller2.signal.aborted) handle2.terminate();
+              const outcome = await handle2.done;
+              if (controller2.signal.aborted) {
+                return {
+                  status: "killed",
+                  detail: outcome.signal !== null ? `signal: ${outcome.signal}` : "killed before exit"
+                };
+              }
+              return { status: "completed", detail: `exit code: ${outcome.exitCode ?? 0}` };
+            } catch (error) {
+              return {
+                status: controller2.signal.aborted && handle2 === void 0 ? "killed" : "failed",
+                detail: error instanceof Error ? error.message : String(error)
+              };
+            }
+          })();
+          return {
+            cancel: () => {
+              if (controller2.signal.aborted) return;
+              controller2.abort();
+              handle2?.terminate();
+            },
+            done,
+            readOutput: () => handle2 === void 0 ? "" : renderProcessRead(readFrame(handle2, offsets), void 0, escalationModes)
+          };
+        }
+      });
+      return { kind: "background", jobId: id };
+    }
+    const controller = new AbortController();
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeoutMs);
+    const onAbort = () => {
+      controller.abort();
+    };
+    exec.signal.addEventListener("abort", onAbort);
+    let handle;
+    try {
+      handle = deps.subprocess.spawn(spawnSpec(argv, workdir ?? process.cwd(), dshEnv, controller.signal));
+    } catch (error) {
+      clearTimeout(timer);
+      exec.signal.removeEventListener("abort", onAbort);
+      throw error;
+    }
+    const onControllerAbort = () => {
+      try {
+        handle?.terminate();
+      } catch {
+      }
+    };
+    controller.signal.addEventListener("abort", onControllerAbort);
+    try {
+      const outcome = await handle.done;
+      const read = readFrame(handle, { stdout: 0, stderr: 0 });
+      const aborted = exec.signal.aborted && !timedOut;
+      const denied = confined !== void 0 && outcome.exitCode !== 0 && confined.denialSignatures.some((signature) => read.delta.toLowerCase().includes(signature.toLowerCase()));
+      const result = {
+        exitCode: outcome.exitCode,
+        signal: outcome.signal,
+        timedOut,
+        aborted,
+        timeoutMs,
+        stdout: { text: read.delta, truncated: read.lossy, ...read.stdoutSpillPath === void 0 ? {} : { spillPath: read.stdoutSpillPath } },
+        stderr: { text: "", truncated: false },
+        ...denied ? { sandbox: { mode: policy?.mode ?? "read-only", denied: true } } : {}
+      };
+      if (aborted) throw abortedError();
+      return { kind: "foreground", ...result };
+    } finally {
+      clearTimeout(timer);
+      exec.signal.removeEventListener("abort", onAbort);
+      controller.signal.removeEventListener("abort", onControllerAbort);
+    }
+  };
+  return {
+    name: BASH_TOOL_NAME,
+    description: bashDescription(true, escalationModes),
+    parameters: bashParameters(escalationModes),
+    output: {
+      schema: bashOutputSchema(),
+      render: (_args, value) => {
+        const v = value;
+        const text = v.kind === "background" ? `started background job ${v.jobId}` : renderBashResult(v, escalationModes);
+        return [{ type: "text", text }];
+      }
+    },
+    execute,
+    presentCall: (args) => {
+      const a = args;
+      if (a.run_in_background === true) {
+        return {
+          card: "generic",
+          title: a.command,
+          kind: "execute",
+          rawInput: a.command,
+          content: [{ type: "text", text: a.description }]
+        };
+      }
+      return {
+        card: "terminal",
+        title: a.command,
+        description: a.description,
+        ...a.workdir === void 0 ? {} : { cwd: a.workdir }
+      };
+    },
+    presentResult: (args, result) => {
+      const block = result.content.length === 1 ? result.content[0] : void 0;
+      if (block === void 0 || block.type !== "text") return void 0;
+      const raw = block.text;
+      const isBackground = typeof args === "object" && args !== null && args.run_in_background === true;
+      if (isBackground || result.isError) {
+        return { card: "generic", content: [{ type: "text", text: `\`\`\`console
+${raw.replace(/\n+$/, "")}
+\`\`\`` }] };
+      }
+      const { body, ...exit } = parseExitStatus(raw);
+      return { card: "terminal", output: body, ...exit };
+    }
+  };
+}
+
+// src/terminal/host.ts
+var TERMINAL_OFF_TEXT = "\u672A\u542F\u7528\uFF1A\u6253\u5F00\u8FD9\u4E00\u680F\u7684\u5F00\u5173\u540E\u624D\u4F1A\u63A5\u7BA1\uFF08\u73B0\u5728\u4FDD\u6301 PowerShell\uFF09";
+function objectOf(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function textOf(value) {
+  return typeof value === "string" ? value : "";
+}
+function errorText(error) {
+  return error instanceof Error && error.message !== "" ? error.message : String(error);
+}
+function installTerminalPolicy(ctx, namespace, settings, readToolDeps, options = {}) {
+  const platform = options.platform ?? process.platform;
+  const isWindows = platform === "win32";
+  const existsFn = options.exists ?? existsSync;
+  const installed = /* @__PURE__ */ new Map();
+  let lastStatus = "";
+  let lastEffective = "";
+  let lastCandidates = "";
+  let failure = "";
+  let busy = false;
+  let again = false;
+  const discover = options.discover ?? ((explicitPath) => probeBash(
+    explicitPath,
+    process.env.PATH ?? "",
+    (name2) => process.env[name2],
+    (path) => existsFn(path),
+    // 只读子目录名（带版本号的来源：GitHub Desktop 的 app-*、旧 GitHub 的 PortableGit_*、VS 的年份/版本）；
+    // 目录不存在或没权限一律当空，探测就退化成纯存在性检查。
+    (parent) => {
+      try {
+        return readdirSync(parent, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+      } catch {
+        return [];
+      }
+    }
+  ));
+  const install = (agent, bashPath) => {
+    const scoped = agent.ctx;
+    const cleanups = [];
+    const notes = [];
+    try {
+      const lift = scoped.tools?.restrict({ deny: ["pwsh"] });
+      if (typeof lift === "function") cleanups.push(lift);
+    } catch (error) {
+      notes.push(`restrict(pwsh) \u8DF3\u8FC7\uFF1A${errorText(error)}`);
+    }
+    try {
+      const deps = readToolDeps();
+      if (deps === void 0) {
+        notes.push("\u5BBF\u4E3B\u6CA1\u6709 subprocess \u670D\u52A1\uFF0C\u65E0\u6CD5\u6CE8\u518C bash");
+      } else {
+        const definition = createBashTool(deps, { bashPath, sep, isAbsolute });
+        const unregister = scoped.tools?.register(definition);
+        if (typeof unregister === "function") cleanups.push(unregister);
+      }
+    } catch (error) {
+      notes.push(`\u6CE8\u518C bash \u5931\u8D25\uFF1A${errorText(error)}`);
+    }
+    try {
+      const bashSection = scoped.systemPrompt?.section({
+        name: "tool:bash",
+        order: TOOL_BASH_SECTION_ORDER,
+        text: BASH_SECTION_TEXT
+      });
+      if (typeof bashSection === "function") cleanups.push(bashSection);
+      const dropPwsh = scoped.on?.("system-prompt/assemble", (async (_assembly, _context, next) => {
+        const assembly = await next();
+        return { ...assembly, sections: assembly.sections.filter((section) => section.name !== "tool:pwsh") };
+      }));
+      if (typeof dropPwsh === "function") cleanups.push(dropPwsh);
+    } catch (error) {
+      notes.push(`\u63D0\u793A\u8BCD\u6BB5\u5931\u8D25\uFF1A${errorText(error)}`);
+    }
+    return {
+      path: bashPath,
+      dispose: () => {
+        for (const cleanup of [...cleanups].reverse()) {
+          try {
+            cleanup();
+          } catch {
+          }
+        }
+      },
+      ...notes.length === 0 ? {} : { failure: notes.join("\uFF1B") }
+    };
+  };
+  const reconcile = () => {
+    if (busy) {
+      again = true;
+      return;
+    }
+    busy = true;
+    void (async () => {
+      const row = settings === void 0 ? void 0 : objectOf(settings.get(namespace));
+      const mode = terminalModeFrom(row?.[TERMINAL_MODE_FIELD]);
+      const explicit = textOf(row?.[TERMINAL_BASH_PATH_FIELD]);
+      const agents = ctx.get("agents");
+      const ops = [];
+      const sectionOn = row?.["enabled"] !== false && sectionEnabledOf(TERMINAL_ENABLED_FIELD, row ?? {});
+      if (!isWindows) {
+        for (const entry of installed.values()) entry.dispose();
+        installed.clear();
+        failure = "";
+        writeState(ops, {
+          status: terminalStatusText({ platform, mode, candidates: [], excludedCount: 0, effective: "unsupported" }),
+          effective: "unsupported",
+          candidates: []
+        });
+        await flush(ops);
+        return;
+      }
+      if (!sectionOn) {
+        for (const entry of installed.values()) entry.dispose();
+        installed.clear();
+        failure = "";
+        writeState(ops, { status: TERMINAL_OFF_TEXT, effective: "pwsh", candidates: [] });
+        await flush(ops);
+        return;
+      }
+      const found = discover(explicit);
+      const candidates = candidatesToStored(found.candidates);
+      const bashPath = activeBashPath(mode, explicit, candidates, found.explicit);
+      const usable = bashPath !== "" && existsFn(bashPath);
+      if (usable) {
+        for (const agent of agents?.list() ?? []) {
+          const current = installed.get(agent);
+          if (current !== void 0 && current.path === bashPath) continue;
+          if (current !== void 0) {
+            current.dispose();
+            installed.delete(agent);
+          }
+          const record = install(agent, bashPath);
+          if (record !== void 0) installed.set(agent, record);
+        }
+      } else {
+        for (const entry of installed.values()) entry.dispose();
+        installed.clear();
+        failure = "";
+      }
+      const firstFailure = [...installed.values()].find((entry) => entry.failure !== void 0)?.failure;
+      writeState(ops, {
+        status: terminalStatusText({
+          platform,
+          mode,
+          candidates,
+          excludedCount: found.excluded.length,
+          ...found.explicit === void 0 ? {} : { explicit: found.explicit },
+          effective: usable ? "bash" : "pwsh",
+          ...usable ? { effectivePath: bashPath } : {},
+          ...firstFailure === void 0 && failure === "" ? {} : { failure: firstFailure ?? failure }
+        }),
+        effective: usable ? "bash" : "pwsh",
+        candidates
+      });
+      await flush(ops);
+    })().catch((error) => {
+      console.error("[composer-ux] \u7EC8\u7AEF\u7B56\u7565\u4E0B\u53D1\u5931\u8D25", error);
+    }).finally(() => {
+      busy = false;
+      if (again) {
+        again = false;
+        reconcile();
+      }
+    });
+  };
+  const writeState = (ops, next) => {
+    const candidatesJson = JSON.stringify(next.candidates);
+    if (next.status !== lastStatus) {
+      lastStatus = next.status;
+      ops.push({ op: "set", path: [TERMINAL_STATUS_FIELD], value: next.status });
+    }
+    if (next.effective !== lastEffective) {
+      lastEffective = next.effective;
+      ops.push({ op: "set", path: [TERMINAL_EFFECTIVE_FIELD], value: next.effective });
+    }
+    if (candidatesJson !== lastCandidates) {
+      lastCandidates = candidatesJson;
+      ops.push({ op: "set", path: [TERMINAL_CANDIDATES_FIELD], value: next.candidates });
+    }
+  };
+  const flush = async (ops) => {
+    if (ops.length === 0 || settings === void 0) return;
+    try {
+      await settings.mutate(namespace, ops);
+    } catch (error) {
+      console.error("[composer-ux] \u7EC8\u7AEF\u72B6\u6001\u5199\u5165\u5931\u8D25", error);
+    }
+  };
+  if (typeof ctx.on !== "function") {
+    failure = "\u4E0A\u4E0B\u6587\u4E0D\u652F\u6301\u4E8B\u4EF6\uFF0C\u65E0\u6CD5\u5728\u4F1A\u8BDD\u521B\u5EFA\u65F6\u4E0B\u53D1";
+  }
+  ctx.on?.("agent/created", (() => {
+    reconcile();
+  }));
+  ctx.on?.("agent/disposed", ((payload) => {
+    if (payload?.agent !== void 0) installed.delete(payload.agent);
+  }));
+  if (settings !== void 0) ctx.on?.("settings/updated", (() => {
+    reconcile();
+  }));
+  ctx.effect(() => ctx.webServer.register({
+    kind: "exact",
+    path: "/composer-ux/terminal",
+    handler: async (req, res) => {
+      const send = (code, payload) => {
+        res.writeHead(code, { "content-type": "application/json; charset=utf-8" });
+        res.end(JSON.stringify(payload));
+      };
+      const connection = ctx.get("connection");
+      const rejection = connection?.requestRejection?.(req);
+      if (rejection !== void 0) {
+        res.statusCode = rejection;
+        res.end();
+        return;
+      }
+      const method = (req.method ?? "GET").toUpperCase();
+      const row = settings === void 0 ? void 0 : objectOf(settings.get(namespace));
+      const mode = terminalModeFrom(row?.[TERMINAL_MODE_FIELD]);
+      const explicit = textOf(row?.[TERMINAL_BASH_PATH_FIELD]);
+      if (method === "POST") {
+        reconcile();
+        const found2 = discover(explicit);
+        send(200, {
+          ok: true,
+          candidates: candidatesToStored(found2.candidates),
+          excluded: found2.excluded,
+          ...found2.explicit === void 0 ? {} : { explicit: found2.explicit }
+        });
+        return;
+      }
+      const found = discover(explicit);
+      send(200, {
+        ok: true,
+        platform,
+        supported: isWindows,
+        mode,
+        bashPath: explicit,
+        effective: lastEffective === "" ? "pwsh" : lastEffective,
+        status: lastStatus,
+        candidates: isWindows ? candidatesToStored(found.candidates) : [],
+        excluded: found.excluded
+      });
+    }
+  }), "composer-ux: terminal status route");
+  reconcile();
+  return;
+}
+
+// src/restart.ts
+var RESTART_POLL_MS = 250;
+var RESTART_PORT_WAIT_MS = 3e4;
+var RESTART_PORT_SETTLE_MS = 300;
+var RESTART_EXIT_DELAY_MS = 500;
+var RESTART_REPLACEMENT_WAIT_MS = 2e4;
+var RESTART_PROBE_TIMEOUT_MS = 500;
+var RESTART_NO_PORT_DELAY_MS = 1500;
+var RESTART_HELPER_LINGER_MS = 3e3;
+var RESTART_STOP_FALLBACK_MS = 1e4;
+var RESTART_LOG_PREFIX = "composer-ux-restart-";
+function nodeExecutableOf(input) {
+  const { argv0, execPath, exists } = input;
+  if (argv0 !== void 0 && argv0 !== "" && isAbsolutePath(argv0) && exists(argv0)) return argv0;
+  return execPath;
+}
+function isAbsolutePath(value) {
+  return value.startsWith("/") || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\");
+}
+function launchCommand(facts) {
+  const { argv1, execArgv, rest, cwd, platform, resolve: resolve3, dirname: dirname3 } = facts;
+  if (argv1 !== void 0 && /[\\/](?:bin\.(?:js|ts)|dsh)$/.test(argv1)) {
+    const absolute = resolve3(argv1);
+    return { file: facts.node, args: [...execArgv, absolute, ...rest], cwd: dirname3(absolute), viaShell: false };
+  }
+  return { file: "dsh", args: [...rest], cwd, viaShell: platform === "win32" };
+}
+function quotePowerShell(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function respawnCommand(launch, platform) {
+  if (platform !== "win32") {
+    return { file: launch.file, args: launch.args, viaShell: launch.viaShell, detached: true };
+  }
+  const file = launch.viaShell && !/\.(?:cmd|bat)$/iu.test(launch.file) ? `${launch.file}.cmd` : launch.file;
+  return {
+    file: "powershell.exe",
+    args: [
+      "-NoProfile",
+      "-WindowStyle",
+      "Hidden",
+      "-Command",
+      [`& ${quotePowerShell(file)}`, ...launch.args.map(quotePowerShell)].join(" ")
+    ],
+    viaShell: false,
+    detached: false
+  };
+}
+function servingPort(hostHeader) {
+  if (hostHeader === void 0) return null;
+  const match = /:(\d{1,5})$/u.exec(hostHeader);
+  if (match === null) return null;
+  const port = Number(match[1]);
+  return Number.isInteger(port) && port > 0 && port < 65536 ? port : null;
+}
+function isLoopbackAddress(address) {
+  return address === "127.0.0.1" || address === "::1" || address === "::ffff:127.0.0.1";
+}
+function trustedRestartRequest(request) {
+  if (!isLoopbackAddress(request.remoteAddress)) return false;
+  const headers = request.headers;
+  if (headers.forwarded !== void 0 || headers["x-forwarded-for"] !== void 0 || headers["x-real-ip"] !== void 0) return false;
+  const origin = firstHeader(headers.origin);
+  const host = firstHeader(headers.host);
+  if (origin === void 0 || host === void 0) return false;
+  try {
+    const parsed = new URL(origin);
+    return (parsed.protocol === "http:" || parsed.protocol === "https:") && parsed.host === host;
+  } catch {
+    return false;
+  }
+}
+function firstHeader(value) {
+  if (value === void 0) return void 0;
+  return typeof value === "string" ? value : value[0];
+}
+var INSPECT_ARG_PREFIXES = ["--inspect", "--inspect-brk", "--inspect-port", "--inspect-wait"];
+function tokenHasInspectFlag(token) {
+  for (const prefix of INSPECT_ARG_PREFIXES) {
+    if (token === prefix || token.startsWith(`${prefix}=`)) return true;
+  }
+  if (token === "--debug-brk" || token.startsWith("--debug-brk=")) return true;
+  if (token === "--debug" || token.startsWith("--debug=")) return true;
+  return false;
+}
+function detectedDebugger(input) {
+  const { inspectorUrl, execArgv, nodeOptions } = input;
+  if (inspectorUrl !== void 0 && inspectorUrl !== "") return "inspector";
+  if (execArgv.some(tokenHasInspectFlag)) return "inspector";
+  const options = (nodeOptions ?? "").trim();
+  if (options !== "" && options.split(/\s+/u).some(tokenHasInspectFlag)) return "inspector";
+  return null;
+}
+function detectedSupervisor(input) {
+  const set2 = (name2) => (input.env[name2] ?? "") !== "";
+  if (!set2("INVOCATION_ID") && !set2("JOURNAL_STREAM")) return null;
+  if (input.ppid === 1 || input.parentComm(input.ppid) === "systemd") return "systemd";
+  return null;
+}
+function restartHelperSource(input) {
+  const { spawned, cwd, logs, port } = input;
+  return [
+    "const { spawn } = require('node:child_process')",
+    "const fs = require('node:fs')",
+    "const net = require('node:net')",
+    `const file = ${JSON.stringify(spawned.file)}`,
+    `const args = ${JSON.stringify(spawned.args)}`,
+    `const cwd = ${JSON.stringify(cwd)}`,
+    `const viaShell = ${JSON.stringify(spawned.viaShell)}`,
+    `const detached = ${JSON.stringify(spawned.detached)}`,
+    `const logOut = ${JSON.stringify(logs.out)}`,
+    `const logErr = ${JSON.stringify(logs.err)}`,
+    `const port = ${JSON.stringify(port)}`,
+    `const pollMs = ${String(RESTART_POLL_MS)}`,
+    `const portWaitMs = ${String(RESTART_PORT_WAIT_MS)}`,
+    `const settleMs = ${String(RESTART_PORT_SETTLE_MS)}`,
+    `const probeMs = ${String(RESTART_PROBE_TIMEOUT_MS)}`,
+    `const noPortDelayMs = ${String(RESTART_NO_PORT_DELAY_MS)}`,
+    `const lingerMs = ${String(RESTART_HELPER_LINGER_MS)}`,
+    `const replacementWaitMs = ${String(RESTART_REPLACEMENT_WAIT_MS)}`,
+    "const sleep = (ms) => new Promise(r => setTimeout(r, ms))",
+    // 失败必须留证据，而且这些行只能在"宿主已经退出"之后写 —— 所以由助手写。
+    "const note = (line) => { try { fs.appendFileSync(logErr, '[dsh-composer-ux] ' + line + '\\n') } catch {} }",
+    // "空闲" = 没人接受连接。用 connect 探而不是 bind：bind 一下自己就把端口占住了，
+    // 而那正是替换进程马上要用的东西。
+    "const listening = () => new Promise((resolve) => {",
+    '  const probe = net.connect({ host: "127.0.0.1", port })',
+    "  const done = (value) => { probe.destroy(); resolve(value) }",
+    '  probe.on("connect", () => done(true))',
+    '  probe.on("error", () => done(false))',
+    "  setTimeout(() => done(false), probeMs)",
+    "})",
+    "const main = async () => {",
+    "  if (port) {",
+    "    const until = Date.now() + portWaitMs",
+    "    while (Date.now() < until && await listening()) await sleep(pollMs)",
+    '    if (await listening()) note("port " + port + " was still in use after " + portWaitMs + "ms; starting anyway")',
+    "    await sleep(settleMs)",
+    "  } else {",
+    "    await sleep(noPortDelayMs)",
+    "  }",
+    "  let child",
+    "  try {",
+    '    const out = fs.openSync(logOut, "a")',
+    '    const err = fs.openSync(logErr, "a")',
+    // windowsHide：助手自己是 detached 的，Windows 上它没有控制台，而一个没有控制台的
+    // 父进程 spawn 控制台程序会**新建一个可见控制台** —— 就是那个关掉就把宿主带走的黑窗口。
+    '    child = spawn(file, args, { cwd, detached, stdio: ["ignore", out, err], env: process.env, shell: viaShell, windowsHide: true })',
+    // spawn 报"文件不存在/不可执行"是**异步**的，下面的 try/catch 只接同步抛出，
+    // 所以少了这个监听，失败会和被修的那个 bug 一样安静。
+    '    child.on("error", (error) => note("could not start the replacement: " + (error && error.message ? error.message : String(error))))',
+    "    child.unref()",
+    "  } catch (error) {",
+    '    note("could not start the replacement: " + (error && error.message ? error.message : String(error)))',
+    "    return",
+    "  }",
+    // 多活一会儿在 Windows 上是有意义的：spawn 完立刻退出的助手可能把还没 detach 完的
+    // 替换进程一起带走。有端口可探的那条路本来就要多待，这条是给没有端口的情况补上同样的保证。
+    "  if (!port) { await sleep(lingerMs); return }",
+    "  const upBy = Date.now() + replacementWaitMs",
+    "  while (Date.now() < upBy && !(await listening())) await sleep(500)",
+    '  if (!(await listening())) note("the replacement did not bind port " + port + " within " + replacementWaitMs + "ms \u2014 see the output log beside this one")',
+    "}",
+    "main()"
+  ].join("\n");
+}
+function planRestart(io, port) {
+  const node = nodeExecutableOf({ argv0: io.argv0, execPath: io.execPath, exists: io.exists });
+  const launch = launchCommand({
+    node,
+    argv1: io.argv1,
+    execArgv: io.execArgv,
+    rest: io.rest,
+    cwd: io.cwd,
+    platform: io.platform,
+    resolve: io.resolve,
+    dirname: io.dirname
+  });
+  const respawn = respawnCommand(launch, io.platform);
+  const logOut = io.join(io.tmpdir, `${RESTART_LOG_PREFIX}${io.stamp}.out.log`);
+  const logErr = io.join(io.tmpdir, `${RESTART_LOG_PREFIX}${io.stamp}.err.log`);
+  return {
+    node,
+    launch,
+    respawn,
+    helper: restartHelperSource({ spawned: respawn, cwd: launch.cwd, logs: { out: logOut, err: logErr }, port }),
+    logOut,
+    logErr,
+    port
+  };
+}
+function scheduleRestart(io, port) {
+  const plan = planRestart(io, port);
+  const helper = io.spawn(plan.node, ["-e", plan.helper], {
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true,
+    env: io.env
+  });
+  helper.unref?.();
+  void io.wait(RESTART_EXIT_DELAY_MS).then(() => {
+    io.stop();
+  });
+  return {
+    ok: true,
+    pid: io.pid,
+    helperPid: helper.pid,
+    logOut: plan.logOut,
+    logErr: plan.logErr,
+    port: plan.port,
+    command: [plan.respawn.file, ...plan.respawn.args].join(" ")
+  };
+}
+function gracefulStop(io, signal = "SIGTERM") {
+  try {
+    io.emitSignal(signal);
+  } catch {
+  }
+  io.timer(RESTART_STOP_FALLBACK_MS, () => {
+    io.exit(0);
+  });
+}
+function bootId(pid, now) {
+  return `${String(pid)}-${String(now)}`;
+}
 
 // src/optimizer-prompt.ts
 var RELAY_ROLE = [
@@ -1083,15 +2298,15 @@ function dshHome() {
 function quickStorePath() {
   return join(dshHome(), QUICK_STORE_FILE);
 }
-function errorText(error) {
+function errorText2(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function hasCode(error, code) {
   return typeof error === "object" && error !== null && error.code === code;
 }
 function delay(ms) {
-  return new Promise((resolve2) => {
-    setTimeout(resolve2, ms);
+  return new Promise((resolve3) => {
+    setTimeout(resolve3, ms);
   });
 }
 async function quarantine(file) {
@@ -1110,14 +2325,14 @@ async function readQuickBook(file = quickStorePath()) {
     raw = await readFile(file, "utf8");
   } catch (error) {
     if (hasCode(error, "ENOENT")) return { kind: "missing" };
-    return { kind: "broken", error: `\u8BFB\u53D6\u5931\u8D25\uFF1A${errorText(error)}` };
+    return { kind: "broken", error: `\u8BFB\u53D6\u5931\u8D25\uFF1A${errorText2(error)}` };
   }
   if (raw.trim() === "") return { kind: "broken", error: "\u6587\u4EF6\u662F\u7A7A\u7684", quarantined: await quarantine(file) };
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (error) {
-    return { kind: "broken", error: `\u4E0D\u662F\u5408\u6CD5 JSON\uFF1A${errorText(error)}`, quarantined: await quarantine(file) };
+    return { kind: "broken", error: `\u4E0D\u662F\u5408\u6CD5 JSON\uFF1A${errorText2(error)}`, quarantined: await quarantine(file) };
   }
   const book = sanitizeBook(parsed);
   if (book === void 0) {
@@ -1207,12 +2422,19 @@ async function ensureQuickBook(seed, file = quickStorePath()) {
 var name = "composer-ux";
 var PANEL_MIN = 560;
 var PANEL_MAX = 4e3;
-function objectOf(value) {
+function objectOf2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
-function textOf(value) {
+function textOf2(value) {
   return typeof value === "string" ? value : "";
 }
+function firstHeaderValue(value) {
+  if (value === void 0) return void 0;
+  return typeof value === "string" ? value : value[0];
+}
+function bookLooksCustom(book) {
+  return JSON.stringify(sanitizeBook(book)) !== JSON.stringify(defaultQuickBook());
+}
 function nameIsValid(name2) {
   if (name2 === "" || name2.length > HEADER_NAME_MAX) return false;
   try {
@@ -1232,7 +2454,7 @@ function valueIsValid(value) {
   }
 }
 function isOpencodeBaseUrl(value) {
-  const raw = textOf(value).trim();
+  const raw = textOf2(value).trim();
   if (raw === "") return false;
   let host = "";
   try {
@@ -1245,28 +2467,28 @@ function isOpencodeBaseUrl(value) {
 function pickRoutes(providers, listed) {
   const keys = Object.keys(providers);
   if (listed.length === 0) {
-    return keys.filter((key) => key.startsWith(OPENCODE_ROUTE_PREFIX) || isOpencodeBaseUrl(objectOf(providers[key])?.baseURL));
+    return keys.filter((key) => key.startsWith(OPENCODE_ROUTE_PREFIX) || isOpencodeBaseUrl(objectOf2(providers[key])?.baseURL));
   }
   return listed.filter((key) => Object.prototype.hasOwnProperty.call(providers, key));
 }
-function errorText2(error) {
+function errorText3(error) {
   if (error instanceof Error && error.message !== "") return error.message;
   return String(error);
 }
 async function mirrorHeader(settings) {
-  const own = objectOf(settings.get(NAMESPACE));
+  const own = objectOf2(settings.get(NAMESPACE));
   if (own === void 0) return;
   const enabled = own[ENABLED_FIELD] === true && own[HEADER_ENABLED_FIELD] === true;
-  const name2 = textOf(own[HEADER_NAME_FIELD]);
+  const name2 = textOf2(own[HEADER_NAME_FIELD]);
   const nameOk = nameIsValid(name2);
-  const routesText = parseRouteList(textOf(own[HEADER_ROUTES_FIELD]));
-  let value = textOf(own[HEADER_VALUE_FIELD]);
+  const routesText = parseRouteList(textOf2(own[HEADER_ROUTES_FIELD]));
+  let value = textOf2(own[HEADER_VALUE_FIELD]);
   if (enabled && nameOk && value === "") {
     value = newSessionId();
     await settings.mutate(NAMESPACE, [{ op: "set", path: [HEADER_VALUE_FIELD], value }]);
   }
-  const llm = objectOf(settings.get(LLM_NAMESPACE));
-  const providers = llm === void 0 ? void 0 : objectOf(llm.providers);
+  const llm = objectOf2(settings.get(LLM_NAMESPACE));
+  const providers = llm === void 0 ? void 0 : objectOf2(llm.providers);
   const writes = [];
   const applied = [];
   let status = "";
@@ -1280,7 +2502,7 @@ async function mirrorHeader(settings) {
     status = `\u5934\u503C\u4E0D\u5408\u6CD5\uFF08\u9700 1\u2013${HEADER_VALUE_MAX} \u5B57\u7B26\u4E14\u5355\u884C\uFF09\uFF0C\u672A\u5199\u5165`;
   } else {
     for (const route of pickRoutes(providers, routesText)) {
-      const headers = objectOf(objectOf(providers[route])?.headers);
+      const headers = objectOf2(objectOf2(providers[route])?.headers);
       if (headers?.[name2] !== value) {
         writes.push({ op: "set", path: ["providers", route, "headers", name2], value });
       }
@@ -1290,9 +2512,9 @@ async function mirrorHeader(settings) {
   }
   const stale = [];
   if (providers !== void 0) {
-    const previousName = textOf(own[HEADER_APPLIED_NAME_FIELD]);
-    const previousValue = textOf(own[HEADER_APPLIED_VALUE_FIELD]);
-    const ours = /* @__PURE__ */ new Set([textOf(own[HEADER_VALUE_FIELD]), previousValue]);
+    const previousName = textOf2(own[HEADER_APPLIED_NAME_FIELD]);
+    const previousValue = textOf2(own[HEADER_APPLIED_VALUE_FIELD]);
+    const ours = /* @__PURE__ */ new Set([textOf2(own[HEADER_VALUE_FIELD]), previousValue]);
     ours.delete("");
     const targets = new Set(applied.map((route) => `${route}\0${name2}`));
     const candidates = /* @__PURE__ */ new Set([previousName, nameOk ? name2 : ""]);
@@ -1300,7 +2522,7 @@ async function mirrorHeader(settings) {
     for (const candidate of candidates) {
       for (const [route, profile] of Object.entries(providers)) {
         if (targets.has(`${route}\0${candidate}`)) continue;
-        const headers = objectOf(objectOf(profile)?.headers);
+        const headers = objectOf2(objectOf2(profile)?.headers);
         const current = headers?.[candidate];
         if (typeof current !== "string" || !ours.has(current)) continue;
         stale.push({ op: "unset", path: ["providers", route, "headers", candidate] });
@@ -1314,19 +2536,19 @@ async function mirrorHeader(settings) {
       await settings.mutate(LLM_NAMESPACE, providerOps);
     } catch (error) {
       failed = true;
-      status = `\u5199\u5165\u5931\u8D25\uFF1A${errorText2(error)}`;
+      status = `\u5199\u5165\u5931\u8D25\uFF1A${errorText3(error)}`;
     }
   }
   const nextAppliedName = !failed && applied.length > 0 ? name2 : "";
   const nextAppliedValue = !failed && applied.length > 0 ? value : "";
   const ownOps = [];
-  if (textOf(own[HEADER_APPLIED_NAME_FIELD]) !== nextAppliedName) {
+  if (textOf2(own[HEADER_APPLIED_NAME_FIELD]) !== nextAppliedName) {
     ownOps.push({ op: "set", path: [HEADER_APPLIED_NAME_FIELD], value: nextAppliedName });
   }
-  if (textOf(own[HEADER_APPLIED_VALUE_FIELD]) !== nextAppliedValue) {
+  if (textOf2(own[HEADER_APPLIED_VALUE_FIELD]) !== nextAppliedValue) {
     ownOps.push({ op: "set", path: [HEADER_APPLIED_VALUE_FIELD], value: nextAppliedValue });
   }
-  if (textOf(own[HEADER_STATUS_FIELD]) !== status) {
+  if (textOf2(own[HEADER_STATUS_FIELD]) !== status) {
     ownOps.push({ op: "set", path: [HEADER_STATUS_FIELD], value: status });
   }
   if (ownOps.length > 0) await settings.mutate(NAMESPACE, ownOps);
@@ -1337,13 +2559,27 @@ function apply(ctx) {
       NAMESPACE,
       Schema.object({
         [ENABLED_FIELD]: Schema.boolean().default(DEFAULT_SETTINGS.enabled),
+        // 五栏开关。**故意不给默认值、声明成可选**：迁移要用的信息就是"文档里有没有这个键"
+        // —— 没有 ⇒ 从没碰过这一栏 ⇒ 关闭；有 ⇒ 用户碰过 ⇒ 保持他写下的值。
+        // 给了静态默认值就再也分不出这两种情况了（净化的 sectionEnabledOf 靠它）。
+        [KEYS_ENABLED_FIELD]: Schema.boolean().required(false),
+        [MENU_ENABLED_FIELD]: Schema.boolean().required(false),
+        [QUICK_ENABLED_FIELD]: Schema.boolean().required(false),
+        [PANEL_ENABLED_FIELD]: Schema.boolean().required(false),
+        [TERMINAL_ENABLED_FIELD]: Schema.boolean().required(false),
         [SEND_KEY_FIELD]: Schema.string().default(DEFAULT_SETTINGS.sendKey),
         [NEWLINE_KEY_FIELD]: Schema.string().default(DEFAULT_SETTINGS.newlineKey),
         ...Object.fromEntries(MENU_FIELDS.map((field) => [
           field,
           Schema.boolean().default(DEFAULT_SETTINGS[field])
         ])),
-        [MENU_NATIVE_FIELD]: Schema.boolean().default(DEFAULT_SETTINGS.menuNative),
+        // 右键菜单模式（0.5.0 起三档）。**故意不给默认值、且声明成可选**：
+        // 「文档里没有这个键」本身就是迁移要用的信息——净化据此按旧布尔 menuNative
+        // 推断（见 menuModeFrom）。给了默认值就再也分不出「从没设置过」与「明确设成了它」。
+        [MENU_MODE_FIELD]: Schema.string().required(false),
+        // 旧的布尔字段：只作迁移线索，故同样不给默认值——旧文档里的 true / false
+        // 都要保住原意（true = 浏览器菜单、false = 明确选过自定义菜单）。
+        [MENU_NATIVE_FIELD]: Schema.boolean().required(false),
         [PANEL_SCROLL_FIELD]: Schema.boolean().default(DEFAULT_SETTINGS.panelScroll),
         [PANEL_RESIZE_FIELD]: Schema.boolean().default(DEFAULT_SETTINGS.panelResize),
         // schemastery 无 .optional()：可选键用 .required(false)。
@@ -1365,7 +2601,19 @@ function apply(ctx) {
           prompt: Schema.string().default(""),
           always: Schema.boolean().default(false)
         })).default(DEFAULT_QUICK_PROMPTS.map((item) => ({ ...item }))),
-        [OPTIMIZER_TIER_FIELD]: Schema.string().default(DEFAULT_SETTINGS.optimizerTier)
+        [OPTIMIZER_TIER_FIELD]: Schema.string().default(DEFAULT_SETTINGS.optimizerTier),
+        // 「默认终端」（0.5.0 起）：用户档位与可选路径。
+        [TERMINAL_MODE_FIELD]: Schema.string().default(DEFAULT_SETTINGS.terminalMode),
+        [TERMINAL_BASH_PATH_FIELD]: Schema.string().default(DEFAULT_SETTINGS.terminalBashPath),
+        // 宿主半自持的三项：探测候选、状态行、当前生效 shell（见 HOST_OWNED_FIELDS）。
+        [TERMINAL_CANDIDATES_FIELD]: Schema.array(Schema.object({
+          path: Schema.string().default(""),
+          label: Schema.string().default(""),
+          kind: Schema.string().default("path"),
+          explicit: Schema.boolean().default(false)
+        })).default([]),
+        [TERMINAL_STATUS_FIELD]: Schema.string().default(DEFAULT_SETTINGS.terminalStatus),
+        [TERMINAL_EFFECTIVE_FIELD]: Schema.string().default(DEFAULT_SETTINGS.terminalEffective)
       })
     );
     const settings = settingsCtx.settings;
@@ -1413,13 +2661,13 @@ function apply(ctx) {
       return Buffer.concat(chunks).toString("utf8");
     };
     const resolveRoute = (payload) => {
-      const provider = textOf(payload.provider);
-      const model = textOf(payload.model);
+      const provider = textOf2(payload.provider);
+      const model = textOf2(payload.model);
       if (provider !== "" && model !== "") return { provider, model };
       try {
         const selector = optCtx.get("agentDefaultModel");
         const current = selector?.currentSelection?.();
-        return { provider: textOf(current?.provider), model: textOf(current?.model) };
+        return { provider: textOf2(current?.provider), model: textOf2(current?.model) };
       } catch {
         return { provider: "", model: "" };
       }
@@ -1431,12 +2679,12 @@ function apply(ctx) {
       }
       let payload;
       try {
-        payload = objectOf(JSON.parse(await readBody(req))) ?? {};
+        payload = objectOf2(JSON.parse(await readBody(req))) ?? {};
       } catch (error) {
-        sendJson(res, 400, { ok: false, error: `\u8BF7\u6C42\u4F53\u4E0D\u662F\u5408\u6CD5 JSON\uFF1A${errorText2(error)}` });
+        sendJson(res, 400, { ok: false, error: `\u8BF7\u6C42\u4F53\u4E0D\u662F\u5408\u6CD5 JSON\uFF1A${errorText3(error)}` });
         return;
       }
-      const text = textOf(payload.text).trim();
+      const text = textOf2(payload.text).trim();
       if (text === "") {
         sendJson(res, 400, { ok: false, error: "\u8F93\u5165\u6846\u662F\u7A7A\u7684\uFF0C\u6CA1\u6709\u53EF\u4F18\u5316\u7684\u5185\u5BB9" });
         return;
@@ -1445,7 +2693,7 @@ function apply(ctx) {
         sendJson(res, 400, { ok: false, error: `\u539F\u6587\u8FC7\u957F\uFF08\u4E0A\u9650 ${TEXT_MAX} \u5B57\u7B26\uFF09` });
         return;
       }
-      const tier = textOf(payload.tier) === "" ? DEFAULT_OPTIMIZER_TIER : textOf(payload.tier);
+      const tier = textOf2(payload.tier) === "" ? DEFAULT_OPTIMIZER_TIER : textOf2(payload.tier);
       const route = resolveRoute(payload);
       if (route.provider === "" || route.model === "") {
         sendJson(res, 200, { ok: false, error: "\u62FF\u4E0D\u5230\u5F53\u524D\u7684\u6A21\u578B\u8DEF\u7531\uFF0C\u65E0\u6CD5\u4F18\u5316\uFF08\u8BF7\u5148\u5728\u8F93\u5165\u6846\u65C1\u7684\u6A21\u578B\u9009\u62E9\u5668\u91CC\u9009\u4E00\u4E2A\u6A21\u578B\uFF09" });
@@ -1476,15 +2724,15 @@ function apply(ctx) {
             out += String(chunk.text ?? "");
             if (out.length > OPTIMIZE_OUTPUT_MAX) break;
           } else if (chunk.type === "finish") {
-            const reason = objectOf(chunk.reason);
+            const reason = objectOf2(chunk.reason);
             if (reason?.kind === "error" || reason?.kind === "aborted") {
-              const detail = objectOf(reason.failure);
-              failure = textOf(detail?.message) || (reason.kind === "aborted" ? "\u4F18\u5316\u88AB\u4E2D\u65AD" : "\u6A21\u578B\u8FD4\u56DE\u9519\u8BEF");
+              const detail = objectOf2(reason.failure);
+              failure = textOf2(detail?.message) || (reason.kind === "aborted" ? "\u4F18\u5316\u88AB\u4E2D\u65AD" : "\u6A21\u578B\u8FD4\u56DE\u9519\u8BEF");
             }
           }
         }
       } catch (error) {
-        failure = errorText2(error);
+        failure = errorText3(error);
       } finally {
         clearTimeout(timer);
       }
@@ -1530,7 +2778,7 @@ function apply(ctx) {
     const legacyPrompts = () => {
       try {
         const settings = storeCtx.get("settings");
-        const row = objectOf(settings?.get(NAMESPACE));
+        const row = objectOf2(settings?.get(NAMESPACE));
         const list = row?.[QUICK_PROMPTS_FIELD];
         return Array.isArray(list) ? list : void 0;
       } catch {
@@ -1560,9 +2808,9 @@ function apply(ctx) {
       }
       let payload;
       try {
-        payload = objectOf(JSON.parse(await readBody(req))) ?? {};
+        payload = objectOf2(JSON.parse(await readBody(req))) ?? {};
       } catch (error) {
-        sendJson(res, 400, { ok: false, error: `\u8BF7\u6C42\u4F53\u4E0D\u662F\u5408\u6CD5 JSON\uFF1A${errorText2(error)}` });
+        sendJson(res, 400, { ok: false, error: `\u8BF7\u6C42\u4F53\u4E0D\u662F\u5408\u6CD5 JSON\uFF1A${errorText3(error)}` });
         return;
       }
       const candidate = payload.book !== void 0 ? payload.book : payload;
@@ -1577,7 +2825,7 @@ function apply(ctx) {
       try {
         await writeQuickBook(next, file);
       } catch (error) {
-        sendJson(res, 500, { ok: false, error: `\u5199\u5165\u5931\u8D25\uFF1A${errorText2(error)}` });
+        sendJson(res, 500, { ok: false, error: `\u5199\u5165\u5931\u8D25\uFF1A${errorText3(error)}` });
         return;
       }
       const verified = await readQuickBook(file);
@@ -1589,6 +2837,175 @@ function apply(ctx) {
       handler: handle
     }), "composer-ux: quick prompt store route");
   });
+  ctx.inject(["settings", "webServer"], (termCtx) => {
+    const readToolDeps = () => {
+      const subprocess = termCtx.get("subprocess");
+      if (subprocess === void 0) return void 0;
+      const sandbox = termCtx.get("sandbox");
+      const sandboxPolicy = termCtx.get("sandboxPolicy");
+      const approval = termCtx.get("approval");
+      const jobs = termCtx.get("jobs");
+      const shellEnv = termCtx.get("shellEnv");
+      return {
+        subprocess,
+        ...sandbox === void 0 ? {} : { sandbox },
+        ...sandboxPolicy === void 0 ? {} : { sandboxPolicy },
+        ...approval === void 0 ? {} : { approval },
+        ...jobs === void 0 ? {} : { jobs },
+        ...shellEnv === void 0 ? {} : { shellEnv }
+      };
+    };
+    installTerminalPolicy(
+      termCtx,
+      NAMESPACE,
+      termCtx.get("settings"),
+      readToolDeps
+    );
+  });
+  ctx.inject(["settings"], (migrateCtx) => {
+    void (async () => {
+      const service = migrateCtx.get("settings");
+      if (service === void 0) return;
+      const row = objectOf2(service.get(NAMESPACE));
+      if (row === void 0 || row[QUICK_ENABLED_FIELD] !== void 0) return;
+      try {
+        const outcome = await readQuickBook(quickStorePath());
+        if (outcome.kind !== "ok" || !bookLooksCustom(outcome.book)) return;
+        await service.mutate(NAMESPACE, [
+          { op: "set", path: [QUICK_ENABLED_FIELD], value: true }
+        ]);
+      } catch (error) {
+        console.error("[composer-ux] quick section migration skipped", error);
+      }
+    })();
+  });
+  ctx.inject(["webServer"], (restartCtx) => {
+    const BOOT_ID = bootId(process.pid, Date.now());
+    const blockedBy = () => {
+      const supervisor = detectedSupervisor({
+        env: process.env,
+        ppid: process.ppid,
+        parentComm: (pid) => {
+          try {
+            return readFileSync(`/proc/${String(pid)}/comm`, "utf8").trim();
+          } catch {
+            return null;
+          }
+        }
+      });
+      if (supervisor !== null) return `supervised:${supervisor}`;
+      if (detectedDebugger({
+        inspectorUrl: inspector.url(),
+        execArgv: process.execArgv,
+        nodeOptions: process.env.NODE_OPTIONS
+      }) !== null) return "debugger";
+      return null;
+    };
+    const buildIo = () => ({
+      platform: process.platform,
+      pid: process.pid,
+      argv0: process.argv0,
+      execPath: process.execPath,
+      argv1: process.argv[1],
+      execArgv: process.execArgv,
+      // argv[0] 是 node 自己、argv[1] 是入口；重放的是"入口 + 之后的参数"。
+      rest: process.argv.slice(2),
+      cwd: process.cwd(),
+      env: process.env,
+      tmpdir: tmpdir(),
+      stamp: (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19),
+      exists: (path) => existsSync2(path),
+      resolve: (path) => resolve2(path),
+      dirname: (path) => dirname2(path),
+      join: (...parts) => join2(...parts),
+      spawn: (command, args, options) => spawn(command, [...args], {
+        detached: options.detached,
+        stdio: options.stdio,
+        windowsHide: options.windowsHide,
+        env: options.env
+      }),
+      stop: () => {
+        gracefulStop({
+          emitSignal: (signal) => {
+            process.emit(signal);
+          },
+          exit: (code) => {
+            process.exit(code);
+          },
+          timer: (ms, run) => {
+            setTimeout(run, ms);
+          }
+        });
+      },
+      wait: (ms) => new Promise((done) => {
+        setTimeout(done, ms);
+      })
+    });
+    let restarting = false;
+    const planForDisplay = () => {
+      const io = buildIo();
+      const plan = planRestart(io, null);
+      return {
+        command: [plan.respawn.file, ...plan.respawn.args].join(" "),
+        execPath: plan.node,
+        logHint: join2(io.tmpdir, `${RESTART_LOG_PREFIX}*.err.log`)
+      };
+    };
+    restartCtx.effect(() => restartCtx.webServer.register({
+      kind: "exact",
+      path: RESTART_API_PATH,
+      handler: (req, res) => {
+        const send = (code, payload) => {
+          res.writeHead(code, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
+          res.end(JSON.stringify(payload));
+        };
+        const connection = restartCtx.get("connection");
+        const rejection = connection?.requestRejection?.(req);
+        if (rejection !== void 0) {
+          res.statusCode = rejection;
+          res.end();
+          return;
+        }
+        const agents = restartCtx.get("agents");
+        const running = agents?.list?.().length ?? 0;
+        const blocked = blockedBy();
+        const method = (req.method ?? "GET").toUpperCase();
+        if (method !== "GET" && method !== "POST") {
+          res.writeHead(405, { allow: "GET, POST" });
+          res.end();
+          return;
+        }
+        if (method === "GET") {
+          const plan = planForDisplay();
+          send(200, { ok: true, ...plan, running, blocked, boot: BOOT_ID });
+          return;
+        }
+        if (!trustedRestartRequest({
+          remoteAddress: req.socket?.remoteAddress,
+          headers: req.headers ?? {}
+        })) {
+          send(403, { ok: false, error: "restart is limited to same-origin loopback requests" });
+          return;
+        }
+        if (blocked !== null) {
+          send(403, { ok: false, error: blocked === "debugger" ? "self-restart is disabled while the host is under a debugger" : `restart belongs to the ${blocked.slice("supervised:".length)} supervisor on this host` });
+          return;
+        }
+        if (restarting) {
+          send(409, { ok: false, error: "restart already scheduled" });
+          return;
+        }
+        restarting = true;
+        try {
+          const scheduled = scheduleRestart(buildIo(), servingPort(firstHeaderValue(req.headers?.host)));
+          send(202, { ok: true, boot: BOOT_ID, running, ...scheduled });
+        } catch (error) {
+          restarting = false;
+          send(500, { ok: false, error: error instanceof Error ? error.message : String(error) });
+        }
+      }
+    }), "composer-ux: restart route");
+  });
 }
 export {
   apply,