neko-harness 0.4.5 → 0.4.7

package/dist/gateway.js

@@ -16497,14 +16497,17 @@ var GATEWAY_USAGE = `\u7528\u6CD5: neko serve [\u9009\u9879]
   --no-socket          \u7981\u7528 Unix socket \u4F20\u8F93\uFF08\u4EC5 WebSocket\uFF09
   --server-id <id>     \u903B\u8F91\u670D\u52A1\u5668\u8EAB\u4EFD\uFF08\u9ED8\u8BA4\u8BFB\u53D6/\u751F\u6210 <\u6570\u636E\u76EE\u5F55>/gateway-server-id\uFF09
   --cwd <dir>          \u4F1A\u8BDD\u5DE5\u5177\u7684\u5DE5\u4F5C\u76EE\u5F55\uFF08\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55\uFF09
-  --model <ref>        \u6A21\u578B\uFF0C\u683C\u5F0F provider/modelId\uFF08\u9ED8\u8BA4 deepseek/deepseek-flash\uFF09
+  --model <ref>        \u6A21\u578B\uFF0C\u683C\u5F0F provider/modelId\uFF08modelId \u53EF\u542B /\uFF0C\u9ED8\u8BA4 deepseek/deepseek-flash\uFF09
   --storage <path>     SQLite \u5B58\u50A8\u6587\u4EF6\uFF08\u9ED8\u8BA4 ~/.neko/neko.sqlite\uFF09
   --credentials <path> \u7528\u6237\u51ED\u636E\u6587\u4EF6\uFF08\u9ED8\u8BA4 ~/.neko/credentials.json\uFF09
   --config <dir>       neko.config.json \u67E5\u627E\u8D77\u59CB\u76EE\u5F55\uFF08\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55\uFF09
+  --stop-on-stdin      \u6807\u51C6\u8F93\u5165\u7ED3\u675F\u65F6\u5173\u505C\u7F51\u5173\uFF08\u4F9B Windows \u4E0A\u62C9\u8D77\u7F51\u5173\u7684\u524D\u7AEF\u4F7F\u7528\uFF09
   -h, --help           \u663E\u793A\u6B64\u5E2E\u52A9
 
-\u53EF\u901A\u8FC7\u524D\u7AEF\u8BBE\u7F6E\u6216 DEEPSEEK_API_KEY / TAVILY_API_KEY \u914D\u7F6E\u51ED\u636E\uFF1B
-\u8054\u7F51\u641C\u7D22\u670D\u52A1\u53EF\u5728\u524D\u7AEF\u8BBE\u7F6E\uFF0C\u6216\u7528\u914D\u7F6E\u6587\u4EF6 webSearch.provider\uFF08tavily / deepseek\uFF0C\u9ED8\u8BA4 tavily\uFF09\u3002`;
+\u53EF\u901A\u8FC7\u524D\u7AEF\u8BBE\u7F6E\u6216\u73AF\u5883\u53D8\u91CF\uFF08DEEPSEEK_API_KEY / OPENROUTER_API_KEY / OPENCODE_API_KEY / TAVILY_API_KEY \u7B49\uFF09\u914D\u7F6E\u51ED\u636E\uFF1B
+\u9664 DeepSeek \u5916\u7684\u6A21\u578B provider \u9700\u5148\u5728\u524D\u7AEF\u542F\u7528\uFF0C--model \u6307\u5411\u672A\u542F\u7528\u7684 provider \u65F6\u63D0\u4EA4\u4F1A\u88AB\u62D2\u7EDD\uFF1B
+\u8054\u7F51\u641C\u7D22\u670D\u52A1\u53EF\u5728\u524D\u7AEF\u8BBE\u7F6E\uFF0C\u6216\u7528\u914D\u7F6E\u6587\u4EF6 webSearch.provider\uFF08tavily / deepseek\uFF0C\u9ED8\u8BA4 tavily\uFF09\uFF1B
+\u9ED8\u8BA4\u6A21\u578B\u8FD8\u53EF\u5728 TUI /model \u6216 Web \u6A21\u578B\u9009\u62E9\u5668\u4E2D\u300C\u8BBE\u4E3A\u9ED8\u8BA4\u300D\uFF0C\u4F18\u5148\u7EA7\u4F4E\u4E8E --model\u3001\u9AD8\u4E8E\u914D\u7F6E\u6587\u4EF6 defaultModel\u3002`;
 function parseGatewayArgs(argv) {
   let port;
   const options = {};
@@ -16582,6 +16585,9 @@ function parseGatewayArgs(argv) {
         options.configDir = next;
         i++;
         break;
+      case "--stop-on-stdin":
+        options.stopOnStdin = true;
+        break;
       default:
         throw new Error(`\u672A\u77E5\u9009\u9879: ${arg}`);
     }
@@ -16888,6 +16894,16 @@ function validate(config, source) {
       throw new Error(`neko config: ${source}: "skills.marketUrl" must be a string.`);
     }
   }
+  const shell = config.shell;
+  if (shell !== undefined) {
+    if (typeof shell !== "object" || shell === null || Array.isArray(shell)) {
+      throw new Error(`neko config: ${source}: "shell" must be an object.`);
+    }
+    const { path } = shell;
+    if (path !== undefined && typeof path !== "string") {
+      throw new Error(`neko config: ${source}: "shell.path" must be a string.`);
+    }
+  }
   const webSearch = config.webSearch;
   if (webSearch !== undefined) {
     if (typeof webSearch !== "object" || webSearch === null || Array.isArray(webSearch)) {
@@ -16907,30 +16923,113 @@ function validate(config, source) {
   }
 }
 // packages/core/src/credentials.ts
-import { chmod, mkdir, open, readFile, rename, unlink } from "fs/promises";
+import { chmod, mkdir, open, readFile, stat, unlink } from "fs/promises";
 import { homedir as homedir2 } from "os";
 import { dirname as dirname2, join as join2 } from "path";
 
+// packages/core/src/rename-with-retry.ts
+import { rename } from "fs/promises";
+var TRANSIENT = new Set(["EPERM", "EBUSY", "EACCES"]);
+var FIRST_DELAY_MS = 10;
+var MAX_TOTAL_MS = 1000;
+async function renameWithRetry(from, to, deps = {}) {
+  const doRename = deps.rename ?? rename;
+  const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  let delay = FIRST_DELAY_MS;
+  let waited = 0;
+  for (;; ) {
+    try {
+      await doRename(from, to);
+      return;
+    } catch (error) {
+      const code = error.code;
+      if (typeof code !== "string" || !TRANSIENT.has(code) || waited >= MAX_TOTAL_MS)
+        throw error;
+      const step = Math.min(delay, MAX_TOTAL_MS - waited);
+      await sleep(step);
+      waited += step;
+      delay *= 2;
+    }
+  }
+}
+
 // packages/core/src/credential-providers.ts
+var model = (id, name, envVar, signupUrl) => ({ id, kind: "model", name, envVar, signupUrl, keyless: false });
+var MODEL_PROVIDERS = [
+  model("deepseek", "DeepSeek", "DEEPSEEK_API_KEY", "https://platform.deepseek.com/api_keys"),
+  model("openrouter", "OpenRouter", "OPENROUTER_API_KEY", "https://openrouter.ai/keys"),
+  model("opencode-go", "OpenCode Go", "OPENCODE_API_KEY", "https://opencode.ai/auth"),
+  model("opencode", "OpenCode Zen", "OPENCODE_API_KEY", "https://opencode.ai/auth"),
+  model("openai", "OpenAI", "OPENAI_API_KEY", "https://platform.openai.com/api-keys"),
+  model("google", "Google", "GEMINI_API_KEY", "https://aistudio.google.com/apikey"),
+  model("groq", "Groq", "GROQ_API_KEY", "https://console.groq.com/keys"),
+  model("mistral", "Mistral", "MISTRAL_API_KEY", "https://console.mistral.ai/api-keys"),
+  model("xai", "xAI", "XAI_API_KEY", "https://console.x.ai"),
+  model("together", "Together", "TOGETHER_API_KEY", "https://api.together.ai/settings/api-keys"),
+  model("fireworks", "Fireworks", "FIREWORKS_API_KEY", "https://fireworks.ai/account/api-keys"),
+  model("cerebras", "Cerebras", "CEREBRAS_API_KEY", "https://cloud.cerebras.ai"),
+  model("nvidia", "NVIDIA", "NVIDIA_API_KEY", "https://build.nvidia.com/settings/api-keys"),
+  model("huggingface", "Hugging Face", "HF_TOKEN", "https://huggingface.co/settings/tokens"),
+  model("vercel-ai-gateway", "Vercel AI Gateway", "AI_GATEWAY_API_KEY", "https://vercel.com/ai-gateway"),
+  model("moonshotai", "Moonshot AI", "MOONSHOT_API_KEY", "https://platform.moonshot.ai/console/api-keys"),
+  model("moonshotai-cn", "Moonshot AI CN", "MOONSHOT_API_KEY", "https://platform.moonshot.cn/console/api-keys"),
+  model("minimax", "MiniMax", "MINIMAX_API_KEY", "https://platform.minimax.io"),
+  model("minimax-cn", "MiniMax CN", "MINIMAX_CN_API_KEY", "https://platform.minimaxi.com"),
+  model("zai", "Z.AI", "ZAI_API_KEY", "https://z.ai/manage-apikey/apikey-list"),
+  model("zai-coding-cn", "Z.AI Coding CN", "ZAI_CODING_CN_API_KEY", "https://bigmodel.cn/usercenter/proj-mgmt/apikeys"),
+  model("qwen-token-plan", "Qwen Token Plan", "QWEN_TOKEN_PLAN_API_KEY", "https://modelstudio.console.alibabacloud.com"),
+  model("qwen-token-plan-cn", "Qwen Token Plan CN", "QWEN_TOKEN_PLAN_CN_API_KEY", "https://bailian.console.aliyun.com"),
+  model("qwen-token-plan-individual", "Qwen Token Plan Individual", "QWEN_TOKEN_PLAN_API_KEY", "https://modelstudio.console.alibabacloud.com"),
+  model("xiaomi", "Xiaomi MiMo", "XIAOMI_API_KEY", "https://platform.xiaomimimo.com"),
+  model("xiaomi-token-plan-cn", "Xiaomi Token Plan CN", "XIAOMI_TOKEN_PLAN_CN_API_KEY", "https://platform.xiaomimimo.com"),
+  model("xiaomi-token-plan-ams", "Xiaomi Token Plan AMS", "XIAOMI_TOKEN_PLAN_AMS_API_KEY", "https://platform.xiaomimimo.com"),
+  model("xiaomi-token-plan-sgp", "Xiaomi Token Plan SGP", "XIAOMI_TOKEN_PLAN_SGP_API_KEY", "https://platform.xiaomimimo.com"),
+  model("baseten", "Baseten", "BASETEN_API_KEY", "https://app.baseten.co/settings/api_keys"),
+  model("ant-ling", "Ant Ling", "ANT_LING_API_KEY", "https://ling.tbox.cn"),
+  model("kimi-coding", "Kimi For Coding", "KIMI_API_KEY", "https://www.kimi.com/code/console"),
+  model("meta", "Meta", "META_API_KEY", "https://llama.developer.meta.com")
+];
+var SEARCH_CREDENTIAL_PROVIDERS = [
+  {
+    id: "tavily",
+    kind: "search",
+    name: "Tavily",
+    envVar: "TAVILY_API_KEY",
+    signupUrl: "https://app.tavily.com",
+    keyless: true
+  }
+];
 var CREDENTIAL_PROVIDERS = [
-  { id: "deepseek", envVar: "DEEPSEEK_API_KEY", signupUrl: "https://platform.deepseek.com/api_keys", keyless: false },
-  { id: "tavily", envVar: "TAVILY_API_KEY", signupUrl: "https://app.tavily.com", keyless: true }
+  ...MODEL_PROVIDERS,
+  ...SEARCH_CREDENTIAL_PROVIDERS
 ];
+var DEFAULT_ENABLED_PROVIDERS = ["deepseek"];
+var LOCKED_PROVIDERS = ["deepseek"];
+function isModelProvider(id) {
+  return MODEL_PROVIDERS.some((item) => item.id === id);
+}
 function credentialProvider(id) {
   const spec = CREDENTIAL_PROVIDERS.find((item) => item.id === id);
   if (!spec)
     throw new Error(`Unknown credential provider: ${id}`);
   return spec;
 }
+function normalizeEnabledProviders(saved) {
+  const wanted = new Set([...LOCKED_PROVIDERS, ...saved ?? DEFAULT_ENABLED_PROVIDERS]);
+  return MODEL_PROVIDERS.map((item) => item.id).filter((id) => wanted.has(id));
+}
 
 // packages/core/src/credentials.ts
 import { InMemoryCredentialStore } from "@earendil-works/pi-ai";
+var STALE_LOCK_MS = 30000;
 var DEFAULT_CREDENTIALS_PATH = join2(homedir2(), ".neko", "credentials.json");
 
 class FileCredentialStore {
   path;
-  constructor(path = DEFAULT_CREDENTIALS_PATH) {
+  #renameDeps;
+  constructor(path = DEFAULT_CREDENTIALS_PATH, renameDeps = {}) {
     this.path = path;
+    this.#renameDeps = renameDeps;
   }
   async#read() {
     try {
@@ -16960,6 +17059,7 @@ class FileCredentialStore {
     await mkdir(dirname2(this.path), { recursive: true, mode: 448 });
     const lockPath = `${this.path}.lock`;
     let lock;
+    let reclaimed = false;
     for (let attempt = 0;; attempt++) {
       try {
         lock = await open(lockPath, "wx", 384);
@@ -16967,6 +17067,16 @@ class FileCredentialStore {
       } catch (error) {
         if (error.code !== "EEXIST" || attempt >= 100)
           throw new Error("Credential storage is busy or unavailable.");
+        if (!reclaimed) {
+          const info = await stat(lockPath).catch(() => {
+            return;
+          });
+          if (info && Date.now() - info.mtimeMs > STALE_LOCK_MS) {
+            reclaimed = true;
+            await unlink(lockPath).catch(() => {});
+            continue;
+          }
+        }
         await new Promise((resolve) => setTimeout(resolve, 25));
       }
     }
@@ -16988,7 +17098,7 @@ class FileCredentialStore {
       } finally {
         await file.close();
       }
-      await rename(temporary, this.path);
+      await renameWithRetry(temporary, this.path, this.#renameDeps);
       return result;
     } catch (error) {
       if (callbackFailed)
@@ -17815,7 +17925,7 @@ var structuredOutputSchema = Type.Union([
     next: Type.Union([Type.Integer(), Type.Null()])
   }, { additionalProperties: false })
 ]);
-function createSubagentExtension(prepare, discard) {
+function createSubagentExtension(prepare, discard, guard) {
   const finish = async (tx, input, status, report) => {
     const round = (await tx.doc(DelegationsDoc, input.parentId)).items.find((r) => r.taskId === input.taskId);
     round.status = status;
@@ -17959,6 +18069,8 @@ function createSubagentExtension(prepare, discard) {
           if (!args.task.trim() || !args.title.trim() || Buffer.byteLength(args.task) > 32768)
             throw new Error("Task/title must be nonempty; task limit is 32 KiB.");
           const agent = await api.agent(context);
+          if (agent.model)
+            await guard?.(agent.model);
           const round = await api.commit(async (tx) => {
             const rounds = await refreshDelegations(tx, api.conversationId);
             const receipt = rounds.find((r) => r.taskId === api.taskId);
@@ -18868,7 +18980,7 @@ import { homedir as homedir4 } from "os";
 import { join as join5 } from "path";
 import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT3 } from "@earendil-works/chord/context";
 import { clampThinkingLevel, createModels, getSupportedThinkingLevels as getSupportedThinkingLevels2 } from "@earendil-works/pi-ai/models";
-import { deepseekProvider } from "@earendil-works/pi-ai/providers/deepseek";
+import { builtinProviders } from "@earendil-works/pi-ai/providers/all";
 import {
   AssistantEntry as AssistantEntry2,
   createRegistry,
@@ -19011,7 +19123,7 @@ var SearchText = defineTool2({
             complete = false;
             continue;
           }
-          const lines = new TextDecoder("utf-8", { fatal: true }).decode(data).split(/\r?\n/);
+          const lines = new TextDecoder("utf-8", { fatal: true }).decode(data).replace(/^\uFEFF/, "").split(/\r?\n/);
           for (let i = 0;i < lines.length; i++) {
             ctx.abortSignal?.throwIfAborted();
             const value = lines[i];
@@ -19444,8 +19556,11 @@ class JobManager {
                 outcome = { status: "failed", exitCode: null, reason: "timeout" };
               else if (result.error.code === "aborted")
                 outcome = { status: "stopped", exitCode: null, reason: "aborted" };
-              else
+              else {
+                entry.buffer.append(`${result.error.message}
+`);
                 outcome = { status: "failed", exitCode: null, reason: "spawn-error" };
+              }
             }
             if (this.#closing) {
               await new Promise((resolve) => {
@@ -19842,10 +19957,15 @@ var TOOL_GUIDELINES = {
   ]
 };
 var GENERIC_RULES = ["Be concise in your responses", "Show file paths clearly when working with files"];
-var buildRules = (toolNames) => {
+var WINDOWS_SHELL_RULE = "On Windows, commands run in Git Bash (not PowerShell, cmd or WSL); write paths with forward slashes, e.g. D:/code or /d/code.";
+var toolRules = (name, platform) => {
+  const rules = TOOL_GUIDELINES[name] ?? [];
+  return platform === "win32" && (name === "bash" || name === "job") ? [...rules, WINDOWS_SHELL_RULE] : rules;
+};
+var buildRules = (toolNames, platform) => {
   const rules = [];
   const seen = new Set;
-  for (const rule of [...toolNames.flatMap((name) => TOOL_GUIDELINES[name] ?? []), ...GENERIC_RULES]) {
+  for (const rule of [...toolNames.flatMap((name) => toolRules(name, platform)), ...GENERIC_RULES]) {
     if (seen.has(rule))
       continue;
     seen.add(rule);
@@ -19862,7 +19982,7 @@ ${content}
 ].join(`
 
 `);
-var createNekoPrompt = (loadResources) => {
+var createNekoPrompt = (loadResources, platform = process.platform) => {
   const built = new WeakMap;
   const build = async (input, context) => {
     const cwd = input.agent.cwd;
@@ -19870,7 +19990,7 @@ var createNekoPrompt = (loadResources) => {
     const resources = cwd ? await loadResources(input.conversationId, cwd) : { contextFiles: [], skills: [] };
     const sections = {
       preamble: role ? ROLE_PROMPTS[role] + SUBAGENT_DELIVERY : PREAMBLE,
-      rules: buildRules(input.agent.tools.map((tool) => tool.name)),
+      rules: buildRules(input.agent.tools.map((tool) => tool.name), platform),
       project_context: renderProjectContext(resources.contextFiles),
       skills: formatSkillsForPrompt(resources.skills) || undefined,
       cwd: cwd?.replace(/\\/g, "/")
@@ -19918,7 +20038,7 @@ var readResources = async (workspace, home, builtinDir, report, invocationName)
   const contextFiles = [];
   for (const path of [userAgentsFile(home), workspaceAgentsFile(workspace)]) {
     try {
-      const content = await readFile3(path, "utf8");
+      const content = (await readFile3(path, "utf8")).replace(/^\uFEFF/, "");
       if (Buffer.byteLength(content, "utf8") > 64 * 1024)
         report({
           path,
@@ -20443,7 +20563,7 @@ function mergeUsage(base, extra) {
     }
   return result;
 }
-function namingTask() {
+function namingTask(canUse) {
   let active = 0;
   const waits = new Set;
   return defineTask3({
@@ -20480,7 +20600,7 @@ function namingTask() {
         try {
           const saved = await runtime.snapshot(SessionMetadataDoc, runtime.conversationId, context);
           const model = saved?.model && runtime.models.getModel(saved.model.provider, saved.model.modelId);
-          if (!saved || !model || saved.attempts >= 2 || !getSupportedThinkingLevels(model).includes("off")) {
+          if (!saved || !model || saved.attempts >= 2 || !getSupportedThinkingLevels(model).includes("off") || !await canUse(model.provider, model.id)) {
             await runtime.commit(async (tx) => {
               (await tx.doc(SessionMetadataDoc, runtime.conversationId)).naming = "fallback";
               return { status: "terminal", outcome: { status: "completed", result: null } };
@@ -20560,12 +20680,13 @@ class SessionMetadataManager {
   #known = new Set;
   #unsubscribe;
   #live = new Map;
-  task = namingTask();
+  task;
   harness;
   storage;
   context;
   report;
-  constructor(harness, storage, context, registry, report = console.error) {
+  constructor(harness, storage, context, registry, report = console.error, canUseModel = async () => true) {
+    this.task = namingTask(canUseModel);
     this.harness = harness;
     this.storage = storage;
     this.context = context;
@@ -21374,11 +21495,152 @@ function createTavilyProvider(resolveKey, fetchImpl = fetch) {
   };
 }
 
+// packages/core/src/windows-shell.ts
+import { spawnSync } from "child_process";
+import { statSync as statSync2 } from "fs";
+import { win32 } from "path";
+function isWslBashPath(path) {
+  const normalized = path.replace(/\//g, "\\").toLowerCase();
+  return /^[a-z]:\\windows\\(?:system32|sysnative)\\bash\.exe$/.test(normalized) || /\\microsoft\\windowsapps\\(?:[^\\]+\\)*bash\.exe$/.test(normalized);
+}
+function envValue(env, name) {
+  const wanted = name.toLowerCase();
+  for (const [key, value] of Object.entries(env))
+    if (key.toLowerCase() === wanted && value)
+      return value;
+  return;
+}
+function bashBesideGit(gitExe) {
+  const dir = win32.dirname(gitExe);
+  const parent = win32.dirname(dir);
+  const name = win32.basename(dir).toLowerCase();
+  if (name === "cmd")
+    return win32.join(parent, "bin", "bash.exe");
+  if (name === "bin") {
+    const root = win32.basename(parent).toLowerCase() === "mingw64" ? win32.dirname(parent) : parent;
+    return win32.join(root, "bin", "bash.exe");
+  }
+  return;
+}
+function configProblem(path, kind) {
+  if (isWslBashPath(path))
+    return "it is WSL's bash, which is not supported (commands must run in Git Bash)";
+  if (kind === "missing")
+    return "the file does not exist";
+  if (kind === "directory")
+    return "it is a directory, not bash.exe";
+  return;
+}
+function resolveWindowsShell(deps, configPath) {
+  if (configPath !== undefined && configPath !== "") {
+    const problem = configProblem(configPath, deps.kind(configPath));
+    if (problem !== undefined) {
+      return {
+        kind: "missing",
+        reason: "invalid_config",
+        detail: `shell.path "${configPath}" is invalid: ${problem}.`,
+        searched: [configPath]
+      };
+    }
+    return { kind: "found", path: configPath, source: "config" };
+  }
+  const searched = [];
+  const check = (path) => {
+    if (!searched.includes(path))
+      searched.push(path);
+    return !isWslBashPath(path) && deps.kind(path) === "file";
+  };
+  const roots = [
+    envValue(deps.env, "ProgramFiles"),
+    envValue(deps.env, "ProgramFiles(x86)"),
+    (() => {
+      const local = envValue(deps.env, "LOCALAPPDATA");
+      return local === undefined ? undefined : win32.join(local, "Programs");
+    })()
+  ];
+  for (const root of roots) {
+    if (root === undefined)
+      continue;
+    const candidate = win32.join(root, "Git", "bin", "bash.exe");
+    if (check(candidate))
+      return { kind: "found", path: candidate, source: "auto" };
+  }
+  for (const gitExe of deps.where("git.exe")) {
+    const candidate = bashBesideGit(gitExe);
+    if (candidate !== undefined && check(candidate))
+      return { kind: "found", path: candidate, source: "auto" };
+  }
+  for (const candidate of deps.where("bash.exe")) {
+    if (check(candidate))
+      return { kind: "found", path: candidate, source: "auto" };
+  }
+  return { kind: "missing", reason: "not_found", detail: "No Git Bash was found.", searched };
+}
+function summarizeWindowsShell(status) {
+  return status.kind === "found" ? { status: "ready", path: status.path, source: status.source } : { status: "missing", reason: status.reason, detail: status.detail };
+}
+function windowsShellMessage(status) {
+  const lines = status.reason === "invalid_config" ? [
+    `Cannot run shell commands: ${status.detail}`,
+    "Fix shell.path in neko.config.json, or remove it to auto-detect Git Bash."
+  ] : [
+    "Cannot run shell commands: Git Bash was not found. neko runs commands in Git for Windows' bash, not PowerShell, cmd or WSL.",
+    "Install Git for Windows (https://git-scm.com/download/win), or set shell.path in neko.config.json to its bash.exe."
+  ];
+  if (status.searched.length > 0)
+    lines.push("Checked:", ...status.searched.map((path) => `  ${path}`));
+  lines.push("File tools (read, write, edit) still work.");
+  return lines.join(`
+`);
+}
+function systemWindowsShellDeps() {
+  return {
+    env: process.env,
+    kind(path) {
+      try {
+        return statSync2(path).isDirectory() ? "directory" : "file";
+      } catch {
+        return "missing";
+      }
+    },
+    where(program) {
+      const result = spawnSync("where", [program], { encoding: "utf8", timeout: 5000, windowsHide: true });
+      if (result.status !== 0 || typeof result.stdout !== "string")
+        return [];
+      return result.stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line !== "");
+    }
+  };
+}
+var WINDOWS_SHELL_RETRY_MS = 30000;
+function createWindowsShellResolver(options) {
+  const deps = options?.deps ?? systemWindowsShellDeps();
+  const now = options?.now ?? Date.now;
+  let cached;
+  return {
+    status(call) {
+      if (cached !== undefined && call?.refresh !== true) {
+        if (cached.status.kind === "found") {
+          if (deps.kind(cached.status.path) === "file")
+            return cached.status;
+        } else if (now() - cached.at < WINDOWS_SHELL_RETRY_MS) {
+          return cached.status;
+        }
+      }
+      cached = { status: resolveWindowsShell(deps, options?.configPath), at: now() };
+      return cached.status;
+    }
+  };
+}
+
 // packages/core/src/workspace-files.ts
-import { open as open2, realpath as realpath2, stat } from "fs/promises";
+import { open as open2, realpath as realpath2, stat as stat2 } from "fs/promises";
 import { basename as basename2, isAbsolute as isAbsolute3, relative as relative2, resolve as resolve4, sep as sep2 } from "path";
 import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT2, withAbortSignal as withAbortSignal3 } from "@earendil-works/chord/context";
-import { getOrThrow as getOrThrow2 } from "@earendil-works/pi-durable/env";
+import {
+  ExecutionError,
+  err,
+  getOrThrow as getOrThrow2
+} from "@earendil-works/pi-durable/env";
 import { Connection, LocalExecutionEnv, localDaemon } from "@earendil-works/pi-env";
 var BROWSE_LIMITS = { children: 1000, readBytes: 512 * 1024 };
 var ENV_TEMPLATE = /\.(example|sample|template)$/;
@@ -21416,6 +21678,19 @@ var FILE_CACHE_LIMITS = {
   concurrent: 2
 };
 
+class ShellUnavailableEnv extends LocalExecutionEnv {
+  #message;
+  constructor(options, message) {
+    super(options);
+    this.#message = message;
+  }
+  async exec(command, options, context) {
+    if (typeof command === "string")
+      return err(new ExecutionError("shell_unavailable", this.#message));
+    return super.exec(command, options, context);
+  }
+}
+
 class WorkspaceFiles {
   #connection;
   #starting;
@@ -21430,8 +21705,10 @@ class WorkspaceFiles {
   #waiting = new Set;
   #timer;
   limits;
-  constructor(limits = FILE_CACHE_LIMITS) {
+  #shell;
+  constructor(limits = FILE_CACHE_LIMITS, shell) {
     this.limits = limits;
+    this.#shell = shell;
     this.#timer = setInterval(() => {
       for (const [key, item] of this.#cache)
         if (!item.waiters && Date.now() - item.used >= this.limits.idleMs)
@@ -21450,20 +21727,31 @@ class WorkspaceFiles {
       queued: this.#waiting.size
     };
   }
-  env(cwd) {
+  shellStatus(options) {
+    return this.#shell?.status(options);
+  }
+  #open() {
     if (this.#closed)
       throw new Error("File environment closed");
     this.#connection ??= new Connection({ command: [localDaemon()] });
-    return new LocalExecutionEnv({
-      connection: this.#connection,
+    return this.#connection;
+  }
+  env(cwd) {
+    const options = {
+      connection: this.#open(),
       cwd,
       ...process.platform === "win32" ? { shellEnv: { PYTHONIOENCODING: "utf-8", PYTHONUTF8: "1" } } : {}
-    });
+    };
+    const shell = this.#shell?.status();
+    if (shell === undefined)
+      return new LocalExecutionEnv(options);
+    if (shell.kind === "found")
+      return new LocalExecutionEnv({ ...options, shellPath: shell.path });
+    return new ShellUnavailableEnv(options, windowsShellMessage(shell));
   }
   async#ready() {
     if (!this.#starting) {
-      this.env(process.cwd());
-      const connection = this.#connection;
+      const connection = this.#open();
       let timer;
       const work = Promise.race([
         connection.info().then(() => connection.session()),
@@ -21540,7 +21828,7 @@ class WorkspaceFiles {
           { path: item.root, recursive: true, exclude: { names: [".git"] } }
         ];
         const git = resolve4(item.root, ".git");
-        if (await stat(git).then(() => true, () => false))
+        if (await stat2(git).then(() => true, () => false))
           targets.push({ path: git, recursive: true, exclude: { names: ["objects", "logs", "refs"] } });
         const result = await env.watch(targets, (change) => {
           for (const user of current.users) {
@@ -21648,7 +21936,7 @@ class WorkspaceFiles {
     const slash = query.lastIndexOf("/"), prefix = slash < 0 ? "" : query.slice(0, slash + 1), needle = query.slice(slash + 1);
     root = await realpath2(root);
     const base = await workspaceTarget(root, prefix);
-    if (!(await stat(base)).isDirectory())
+    if (!(await stat2(base)).isDirectory())
       throw new Error("Workspace directory is unavailable.");
     return this.#withListing(root, base, signal, async (listing) => {
       const pattern = new RegExp([...needle].map((c) => c.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*"), /[A-Z]/.test(needle) ? "" : "i");
@@ -21678,7 +21966,7 @@ class WorkspaceFiles {
     const clean = dir === "" ? "" : relativeQuery(dir).replace(/\/+$/, "");
     root = await realpath2(root);
     const target = await workspaceTarget(root, clean);
-    if (!(await stat(target)).isDirectory())
+    if (!(await stat2(target)).isDirectory())
       throw new Error("Not a directory.");
     const prefix = clean === "" ? "" : `${clean}/`;
     return this.#withListing(root, root, signal, async (listing) => {
@@ -21720,7 +22008,7 @@ class WorkspaceFiles {
         throw new Error("File not found.");
       throw error;
     }
-    const info = await stat(target);
+    const info = await stat2(target);
     if (!info.isFile())
       throw new Error("Not a file.");
     const base = { path: clean, size: info.size, mtimeMs: info.mtimeMs };
@@ -21852,6 +22140,22 @@ var SearchSettingsDoc = defineDoc7({
   fork: "initial",
   initial: () => ({ provider: null })
 });
+var ProviderSettingsDoc = defineDoc7({
+  kind: "app.neko.provider-settings",
+  version: 1,
+  scope: "conversation",
+  history: "latest",
+  fork: "initial",
+  initial: () => ({ enabled: null })
+});
+var DefaultModelDoc = defineDoc7({
+  kind: "app.neko.default-model",
+  version: 1,
+  scope: "conversation",
+  history: "latest",
+  fork: "initial",
+  initial: () => ({ model: null })
+});
 var ContextSettingsDoc = defineDoc7({
   kind: "app.neko.context-settings",
   version: 1,
@@ -21872,6 +22176,7 @@ async function createNekoRuntime(options = {}) {
   const context = options.context ?? BACKGROUND_CONTEXT3;
   const defaultCwd = normalizeWorkspace(options.cwd);
   const model = options.model ?? DEFAULT_MODEL;
+  const modelOverride = options.modelOverride;
   const providers = options.providers ?? [];
   const credentials = options.credentials ?? (options.storage === "memory" && !options.credentialsPath ? new InMemoryCredentialStore : new FileCredentialStore(options.credentialsPath));
   const runtimeKeys = new Map;
@@ -21891,16 +22196,47 @@ async function createNekoRuntime(options = {}) {
     delete: (id) => credentials.delete(id)
   } : credentials;
   const models = createModels({ credentials: effectiveCredentials });
-  models.setProvider(deepseekProvider());
+  for (const provider of builtinProviders())
+    if (isModelProvider(provider.id))
+      models.setProvider(provider);
   for (const provider of providers)
     models.setProvider(provider);
+  let enabled = new Set(normalizeEnabledProviders(null));
+  const guardProvider = async (ref) => {
+    if (!ref || !isModelProvider(ref.provider))
+      return;
+    const spec = credentialProvider(ref.provider);
+    if (!enabled.has(ref.provider))
+      throw new Error(`PROVIDER_DISABLED: ${spec.name} is not enabled. Enable it in /login or Web settings, or switch model.`);
+    if (!await models.checkAuth(ref.provider))
+      throw new Error(`PROVIDER_KEY_REQUIRED: Configure a ${spec.name} API key in /login or Web settings.`);
+  };
   const resolveLevel = (ref, level) => {
     const info = models.getModel(ref.provider, ref.modelId);
     if (!info)
       throw new Error("Unknown model");
     return clampThinkingLevel(info, level);
   };
-  const workspaceFiles = new WorkspaceFiles;
+  let modelInfoCache;
+  const allModels = () => {
+    modelInfoCache ??= models.getModels().map((model) => ({
+      provider: model.provider,
+      modelId: model.id,
+      name: model.name,
+      contextWindow: model.contextWindow,
+      input: model.input,
+      ...model.inputLimits ? { inputLimits: model.inputLimits } : {},
+      reasoning: model.reasoning,
+      supportedThinkingLevels: getSupportedThinkingLevels2(model),
+      thinkingLevelAdjustments: Object.fromEntries(["off", "minimal", "low", "medium", "high", "xhigh", "max"].map((level) => [
+        level,
+        clampThinkingLevel(model, level)
+      ]))
+    }));
+    return modelInfoCache;
+  };
+  const shellResolver = options.shellResolver ?? (process.platform === "win32" ? createWindowsShellResolver({ configPath: options.shellPath }) : undefined);
+  const workspaceFiles = new WorkspaceFiles(undefined, shellResolver);
   const storage = options.storage === "memory" ? new MemoryStorage : await openNodeSqliteStorage(options.storagePath ?? DEFAULT_STORAGE_PATH);
   const registry = createRegistry();
   registry.install(createCodingTools({ images: await createNodePhotonImages() }));
@@ -21926,7 +22262,7 @@ async function createNekoRuntime(options = {}) {
   registry.install(createNekoPrompt(resourceSnapshots.current));
   registry.install(createSubagentExtension(async (id, requestId, cwd) => {
     resourceSnapshots.stage(id, requestId, cwd, await loadResources(cwd));
-  }, resourceSnapshots.discard));
+  }, resourceSnapshots.discard, (ref) => guardProvider(ref)));
   const jobs = new JobManager;
   registry.install(jobs.extension);
   registry.install(createTodoExtension());
@@ -21944,7 +22280,7 @@ async function createNekoRuntime(options = {}) {
     registry,
     settings: {
       get compaction() {
-        return compactionPolicy(contextState, models.getModels().map((model) => model.contextWindow));
+        return compactionPolicy(contextState, allModels().filter((model) => !isModelProvider(model.provider) || enabled.has(model.provider)).map((model) => model.contextWindow));
       }
     },
     onReport: options.onReport,
@@ -21986,13 +22322,15 @@ async function createNekoRuntime(options = {}) {
     throw error;
   }
   await questions.reconcileAll();
+  const rootModel = modelOverride ?? model;
   const conversation = await harness.root(context, {
     agent: {
-      model,
-      thinkingLevel: resolveLevel(model, options.thinkingLevel ?? "high"),
+      model: rootModel,
+      thinkingLevel: resolveLevel(rootModel, options.thinkingLevel ?? "high"),
       cwd: defaultCwd
     }
   });
+  enabled = new Set(normalizeEnabledProviders((await harness.snapshot(ProviderSettingsDoc, conversation.id, context))?.enabled));
   const savedSearch = (await harness.snapshot(SearchSettingsDoc, conversation.id, context))?.provider;
   if (isSearchProvider(savedSearch))
     searchProvider = savedSearch;
@@ -22038,7 +22376,7 @@ async function createNekoRuntime(options = {}) {
   };
   if (existing.length === 0)
     await touchConversation(conversation.id);
-  const metadata = new SessionMetadataManager(harness, storage, context, registry, options.onReport);
+  const metadata = new SessionMetadataManager(harness, storage, context, registry, options.onReport, (provider, modelId) => guardProvider({ provider, modelId }).then(() => true, () => false));
   if (existing.length === 0)
     await metadata.initialize(conversation.id);
   for (const record of existing)
@@ -22099,9 +22437,8 @@ async function createNekoRuntime(options = {}) {
         data.skill = skill;
       });
     }
-    if (!duplicate && agent.model?.provider === "deepseek" && !await models.checkAuth("deepseek")) {
-      throw new Error("DEEPSEEK_KEY_REQUIRED: Configure a DeepSeek API key in /login or Web settings.");
-    }
+    if (!duplicate)
+      await guardProvider(agent.model);
     if (!duplicate && agent.model) {
       const resolved = models.getModel(agent.model.provider, agent.model.modelId);
       if (resolved)
@@ -22233,8 +22570,7 @@ async function createNekoRuntime(options = {}) {
     },
     async compact(instructions) {
       const agent = await target.agent(context);
-      if (agent.model?.provider === "deepseek" && !await models.checkAuth("deepseek"))
-        throw new Error("DEEPSEEK_KEY_REQUIRED: Configure DeepSeek in /login or Web settings.");
+      await guardProvider(agent.model);
       await admit(target.id, async () => {
         const live = await harness.snapshot(importLiveDoc, target.id, context);
         if (live?.compactions?.length || (await readCompaction(harness, storage, target.id, context))?.phase === "waiting-to-apply")
@@ -22410,6 +22746,10 @@ async function createNekoRuntime(options = {}) {
     questions,
     closed: harness.closed,
     workspaceFiles,
+    shellStatus(call) {
+      const status = workspaceFiles.shellStatus(call);
+      return status === undefined ? undefined : summarizeWindowsShell(status);
+    },
     conversation,
     root: rootSession,
     submit: rootSession.submit,
@@ -22460,11 +22800,13 @@ async function createNekoRuntime(options = {}) {
     },
     async createConversation(createOptions) {
       const workspace = await addWorkspace(createOptions?.cwd ?? defaultCwd);
+      const savedDefault = (await harness.snapshot(DefaultModelDoc, conversation.id, context))?.model ?? null;
+      const effective = createOptions?.model ?? modelOverride ?? savedDefault ?? model;
       const created = await harness.createConversation({
         ownership: { kind: "ownerless" },
         agent: {
-          model: createOptions?.model ?? model,
-          thinkingLevel: resolveLevel(createOptions?.model ?? model, createOptions?.thinkingLevel ?? options.thinkingLevel ?? "high"),
+          model: effective,
+          thinkingLevel: resolveLevel(effective, createOptions?.thinkingLevel ?? options.thinkingLevel ?? "high"),
           cwd: workspace.path
         }
       }, context);
@@ -22494,6 +22836,8 @@ async function createNekoRuntime(options = {}) {
         const targetModel = ref && models.getModel(ref.provider, ref.modelId);
         if (!targetModel)
           throw new Error("Unknown model");
+        if (change.model && isModelProvider(ref.provider) && !enabled.has(ref.provider))
+          throw new Error(`PROVIDER_DISABLED: ${credentialProvider(ref.provider).name} is not enabled.`);
         await session.conversation.configure({ model: ref, thinkingLevel: clampThinkingLevel(targetModel, change.thinkingLevel ?? current.thinkingLevel) }, context);
         return true;
       });
@@ -22548,20 +22892,62 @@ async function createNekoRuntime(options = {}) {
       }
     },
     listModels() {
-      return models.getModels().map((model) => ({
-        provider: model.provider,
-        modelId: model.id,
-        name: model.name,
-        contextWindow: model.contextWindow,
-        input: model.input,
-        ...model.inputLimits ? { inputLimits: model.inputLimits } : {},
-        reasoning: model.reasoning,
-        supportedThinkingLevels: getSupportedThinkingLevels2(model),
-        thinkingLevelAdjustments: Object.fromEntries(["off", "minimal", "low", "medium", "high", "xhigh", "max"].map((level) => [
-          level,
-          clampThinkingLevel(model, level)
-        ]))
-      }));
+      return allModels();
+    },
+    async listSelectableModels() {
+      const availability = new Map;
+      const result = [];
+      for (const info of allModels()) {
+        const managed = isModelProvider(info.provider);
+        if (managed && !enabled.has(info.provider))
+          continue;
+        if (!availability.has(info.provider))
+          availability.set(info.provider, !managed || Boolean(await models.checkAuth(info.provider)));
+        result.push({ ...info, available: availability.get(info.provider) ?? false });
+      }
+      return result;
+    },
+    enabledProviders() {
+      return MODEL_PROVIDERS.map((item) => item.id).filter((id) => enabled.has(id));
+    },
+    async setProviderEnabled(provider, value) {
+      if (!isModelProvider(provider))
+        throw new Error("Unknown model provider.");
+      if (typeof value !== "boolean")
+        throw new Error("Enabled must be a boolean.");
+      if (!value && LOCKED_PROVIDERS.includes(provider))
+        throw new Error("DeepSeek is always enabled.");
+      const next = new Set(enabled);
+      if (value)
+        next.add(provider);
+      else
+        next.delete(provider);
+      const list = normalizeEnabledProviders([...next]);
+      await harness.commit(async (tx) => {
+        (await tx.doc(ProviderSettingsDoc, conversation.id)).enabled = list;
+      }, context);
+      enabled = new Set(list);
+    },
+    async defaultModel() {
+      const saved = (await harness.snapshot(DefaultModelDoc, conversation.id, context))?.model ?? null;
+      if (modelOverride)
+        return { effective: modelOverride, source: "cli" };
+      if (saved)
+        return { effective: saved, source: "saved" };
+      if (options.model)
+        return { effective: model, source: "config" };
+      return { effective: model, source: "default" };
+    },
+    async setDefaultModel(ref) {
+      if (ref !== null) {
+        if (!models.getModel(ref.provider, ref.modelId))
+          throw new Error("Unknown model");
+        if (isModelProvider(ref.provider) && !enabled.has(ref.provider))
+          throw new Error(`PROVIDER_DISABLED: ${credentialProvider(ref.provider).name} is not enabled.`);
+      }
+      await harness.commit(async (tx) => {
+        (await tx.doc(DefaultModelDoc, conversation.id)).model = ref;
+      }, context);
     },
     async getAgent(id) {
       const session = await sessionFor(id);
@@ -22626,8 +23012,8 @@ var nullableString = Type7.Union([str, nil]);
 var phase = Type7.Enum(["pending", "running", "done"]);
 var level = Type7.Enum(["project", "user", "builtin"]);
 var thinking = Type7.Enum(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
-var model = Type7.Object({ provider: str, modelId: str });
-var change = Type7.Object({ model: Type7.Optional(model), thinkingLevel: Type7.Optional(thinking) }, { additionalProperties: false });
+var model2 = Type7.Object({ provider: str, modelId: str });
+var change = Type7.Object({ model: Type7.Optional(model2), thinkingLevel: Type7.Optional(thinking) }, { additionalProperties: false });
 var usage = Type7.Object({ input: num, output: num, cacheRead: num, cacheWrite: num, cost: num });
 var image = Type7.Object({
   name: str,
@@ -22865,7 +23251,7 @@ var ChatViewSchema = Type7.Object({
   subagents: Type7.Optional(Type7.Array(DelegationSchema)),
   taskUsage: Type7.Optional(usage),
   model: str,
-  agent: Type7.Object({ model: Type7.Union([model, nil]), thinkingLevel: Type7.Union([thinking, nil]) }),
+  agent: Type7.Object({ model: Type7.Union([model2, nil]), thinkingLevel: Type7.Union([thinking, nil]) }),
   cwd: str,
   busy: bool,
   status: nullableString,
@@ -22950,7 +23336,7 @@ var SessionSummarySchema = Type7.Object({
   firstPromptPreview: str,
   createdAt: num,
   lastMessageAt: Type7.Union([num, nil]),
-  model: Type7.Union([model, nil]),
+  model: Type7.Union([model2, nil]),
   status: Type7.Enum(["idle", "running", "error"]),
   awaitingAnswer: Type7.Optional(bool),
   id: str
@@ -22961,11 +23347,12 @@ var WorkspaceStateSchema = Type7.Object({ revision: integer, workspaces: Type7.A
 var credentialStatus = Type7.Object({
   savedConfigured: bool,
   environmentConfigured: bool,
-  source: Type7.Enum(["saved", "environment", "runtime", "keyless", "none"])
+  source: Type7.Enum(["saved", "environment", "runtime", "keyless", "none"]),
+  enabled: Type7.Optional(bool)
 });
 var CredentialStateSchema = Type7.Object({
   revision: integer,
-  statuses: Type7.Object({ deepseek: credentialStatus, tavily: credentialStatus })
+  statuses: Type7.Record(str, credentialStatus)
 });
 var AttachmentSchema = Type7.Object({ sessionId: str, attachmentId: str });
 var chatInput = Type7.Object({ sessionId: str, attachmentId: str }, { additionalProperties: false });
@@ -23007,6 +23394,7 @@ var modelInfo = Type7.Object({
   provider: str,
   modelId: str,
   name: str,
+  available: bool,
   contextWindow: num,
   input: Type7.Array(str),
   inputLimits: Type7.Optional(inputLimits),
@@ -23112,16 +23500,17 @@ var NekoWorkspaces = contract("neko.workspaces", {
     }
   }
 });
-var provider = Type7.Enum(["deepseek", "tavily"]);
+var provider = Type7.String({ minLength: 1, maxLength: 64 });
 var NekoCredentials = contract("neko.credentials", {
-  version: 1,
+  version: 2,
   input: Type7.Object({}, { additionalProperties: false }),
   variants: {
     ready: {
       state: { state: CredentialStateSchema },
       methods: {
         save: rpc(Type7.Object({ provider, key: Type7.String({ minLength: 1, maxLength: 8192 }) }, { additionalProperties: false }), nil),
-        remove: rpc(Type7.Object({ provider }, { additionalProperties: false }), nil)
+        remove: rpc(Type7.Object({ provider }, { additionalProperties: false }), nil),
+        setEnabled: rpc(Type7.Object({ provider, enabled: bool }, { additionalProperties: false }), nil)
       }
     }
   }
@@ -23198,6 +23587,24 @@ var NekoContextSettings = contract("neko.context-settings", {
     }
   }
 });
+var defaultModelSource = Type7.Enum(["cli", "saved", "config", "default"]);
+var DefaultModelStateSchema = Type7.Object({
+  effective: model2,
+  source: defaultModelSource
+});
+var NekoDefaultModel = contract("neko.default-model", {
+  version: 1,
+  input: Type7.Object({}, { additionalProperties: false }),
+  variants: {
+    ready: {
+      state: { state: DefaultModelStateSchema },
+      methods: {
+        set: rpc(model2, nil),
+        clear: rpc(nil, nil)
+      }
+    }
+  }
+});
 var FileCandidatesSchema = Type7.Object({
   entries: Type7.Array(Type7.Object({ name: str, path: str, kind: Type7.Enum(["file", "directory"]) }), { maxItems: 100 }),
   limited: bool,
@@ -23245,6 +23652,14 @@ var NekoSkillMarket = contract("neko.skill-market", {
     }
   }
 });
+var ShellStatusSchema = Type7.Union([
+  Type7.Object({ status: Type7.Literal("ready"), path: str, source: Type7.Enum(["config", "auto"]) }),
+  Type7.Object({
+    status: Type7.Literal("missing"),
+    reason: Type7.Enum(["not_found", "invalid_config"]),
+    detail: Type7.Optional(str)
+  })
+]);
 var ApplicationInfoSchema = Type7.Object({
   runningVersion: str,
   installedVersion: nullableString,
@@ -23252,7 +23667,8 @@ var ApplicationInfoSchema = Type7.Object({
   latestVersion: nullableString,
   checkedAt: Type7.Union([integer, nil]),
   checkState: Type7.Enum(["unknown", "checking", "ok", "failed", "development"]),
-  serverId: str
+  serverId: str,
+  shell: Type7.Optional(ShellStatusSchema)
 });
 var NekoApplicationInfo = contract("neko.application-info", {
   version: 1,
@@ -23290,7 +23706,7 @@ function isMobilePrincipal(principal) {
 
 // packages/gateway/src/mobile/store.ts
 import { randomBytes } from "crypto";
-import { chmod as chmod2, mkdir as mkdir2, readFile as readFile4, rename as rename2, rm, writeFile } from "fs/promises";
+import { chmod as chmod2, mkdir as mkdir2, readFile as readFile4, rm, writeFile } from "fs/promises";
 import { join as join6 } from "path";
 var MOBILE_STATE_FORMAT_VERSION = 1;
 var MOBILE_DEFAULT_PORT = 8323;
@@ -23418,9 +23834,10 @@ async function writeFileAtomic(filePath, contents, mode) {
     await writeFile(tempPath, contents, { mode });
     if (POSIX)
       await chmod2(tempPath, mode);
-    await rename2(tempPath, filePath);
-  } finally {
+    await renameWithRetry(tempPath, filePath);
+  } catch (error) {
     await rm(tempPath, { force: true });
+    throw error;
   }
 }
 async function writeSecretFile(filePath, contents) {
@@ -23976,8 +24393,8 @@ function subagentClient(connect) {
 import { createHash as createHash2 } from "crypto";
 
 // packages/core/src/application-version.ts
-var RUNNING_VERSION = "0.4.5";
-var APPLICATION_PROTOCOL = 6;
+var RUNNING_VERSION = "0.4.7";
+var APPLICATION_PROTOCOL = 8;
 function stableVersion(value) {
   return typeof value === "string" && /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(value) && value.split(".").every((n) => Number.isSafeInteger(Number(n)));
 }
@@ -26626,6 +27043,10 @@ function toMessage(error) {
   }
   return String(error);
 }
+function normalizeLocalAddress(address) {
+  const mapped = address?.startsWith("::ffff:") ? address.slice("::ffff:".length) : undefined;
+  return mapped !== undefined && isIpv4Literal(mapped) ? mapped : address;
+}
 
 class MobileGateway {
   serverId;
@@ -26954,11 +27375,12 @@ class MobileGateway {
       connection.sendNotification(method, params);
   }
   advertisedAddress(localAddress) {
+    const normalized = normalizeLocalAddress(localAddress);
     const state = this.stateValue;
-    if (state.status === "listening" && state.mode === "wsl-relay" && localAddress === state.bindAddress) {
+    if (state.status === "listening" && state.mode === "wsl-relay" && normalized === state.bindAddress) {
       return state.address;
     }
-    return localAddress;
+    return normalized;
   }
   requireStore() {
     if (this.storeHandle === undefined)
@@ -27219,7 +27641,7 @@ import { randomUUID as randomUUID5 } from "crypto";
 import { ChordError as ChordError5, local as local3, method as method2 } from "@earendil-works/chord";
 
 // packages/core/src/application-updates.ts
-import { mkdir as mkdir3, readFile as readFile6, rename as rename3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile6, rm as rm3, writeFile as writeFile3 } from "fs/promises";
 import { homedir as homedir5 } from "os";
 import { dirname as dirname5, join as join10 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -27349,7 +27771,7 @@ class UpdateChecker {
       try {
         await mkdir3(dirname5(this.#cachePath), { recursive: true });
         await writeFile3(temporary, JSON.stringify({ latestVersion: value.version, checkedAt: now }), { mode: 384 });
-        await rename3(temporary, this.#cachePath);
+        await renameWithRetry(temporary, this.#cachePath);
       } catch {} finally {
         await rm3(temporary, { force: true }).catch(() => {});
       }
@@ -27995,8 +28417,6 @@ function serveSessions(host, runtime, context) {
           for (const id of input.images ?? [])
             uploads.value.release(id);
         } catch (error) {
-          if (error instanceof Error && error.message.startsWith("DEEPSEEK_KEY_REQUIRED:"))
-            throw new ChordError4("invalid", "DEEPSEEK_KEY_REQUIRED: Configure DeepSeek in /login or Web settings.");
           throw new ChordError4("invalid", error instanceof Error ? error.message : "Cannot submit message");
         }
         return null;
@@ -28085,7 +28505,7 @@ function serveSessions(host, runtime, context) {
 
 // packages/gateway/src/skill-market.ts
 import { createHash as createHash6, randomUUID as randomUUID4 } from "crypto";
-import { mkdir as mkdir4, readdir as readdir2, rename as rename4, rm as rm4, stat as stat2, writeFile as writeFile4 } from "fs/promises";
+import { mkdir as mkdir4, readdir as readdir2, rm as rm4, stat as stat3, writeFile as writeFile4 } from "fs/promises";
 import { homedir as homedir6 } from "os";
 import { dirname as dirname6, join as join11 } from "path";
 
@@ -28230,11 +28650,11 @@ var ec = [
   "stream finishing",
   "invalid zip data"
 ];
-var err = function(ind, msg, nt) {
+var err2 = function(ind, msg, nt) {
   var e = new Error(msg || ec[ind]);
   e.code = ind;
   if (Error.captureStackTrace)
-    Error.captureStackTrace(e, err);
+    Error.captureStackTrace(e, err2);
   if (!nt)
     throw e;
   return e;
@@ -28267,7 +28687,7 @@ var inflt = function(dat, st, buf, dict) {
         var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
         if (t > sl) {
           if (noSt)
-            err(0);
+            err2(0);
           break;
         }
         if (resize)
@@ -28313,10 +28733,10 @@ var inflt = function(dat, st, buf, dict) {
         lm = hMap(lt, lbt, 1);
         dm = hMap(dt, dbt, 1);
       } else
-        err(1);
+        err2(1);
       if (pos > tbts) {
         if (noSt)
-          err(0);
+          err2(0);
         break;
       }
     }
@@ -28329,11 +28749,11 @@ var inflt = function(dat, st, buf, dict) {
       pos += c & 15;
       if (pos > tbts) {
         if (noSt)
-          err(0);
+          err2(0);
         break;
       }
       if (!c)
-        err(2);
+        err2(2);
       if (sym < 256)
         buf[bt++] = sym;
       else if (sym == 256) {
@@ -28348,7 +28768,7 @@ var inflt = function(dat, st, buf, dict) {
         }
         var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
         if (!d)
-          err(3);
+          err2(3);
         pos += d & 15;
         var dt = fd[dsym];
         if (dsym > 3) {
@@ -28357,7 +28777,7 @@ var inflt = function(dat, st, buf, dict) {
         }
         if (pos > tbts) {
           if (noSt)
-            err(0);
+            err2(0);
           break;
         }
         if (resize)
@@ -28366,7 +28786,7 @@ var inflt = function(dat, st, buf, dict) {
         if (bt < dt) {
           var shift = dl - dt, dend = Math.min(dt, end);
           if (shift + bt < 0)
-            err(3);
+            err2(3);
           for (;bt < dend; ++bt)
             buf[bt] = dict[shift + bt];
         }
@@ -28426,7 +28846,7 @@ function strFromU8(dat, latin1) {
   } else {
     var _a = dutf8(dat), { s, r } = _a;
     if (r.length)
-      err(8);
+      err2(8);
     return s;
   }
 }
@@ -28453,7 +28873,7 @@ var z64hs = function(d, b, l, z, sc, su, off) {
       }
     }
     if (z < 2)
-      err(13);
+      err2(13);
   }
   return [sc, su, off, 0];
 };
@@ -28462,7 +28882,7 @@ function unzipSync(data, opts) {
   var e = data.length - 22;
   for (;b4(data, e) != 101010256; --e) {
     if (!e || data.length - e > 65558)
-      err(13);
+      err2(13);
   }
   var c = b2(data, e + 8);
   if (!c)
@@ -28492,7 +28912,7 @@ function unzipSync(data, opts) {
       else if (c_2 == 8)
         files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) });
       else
-        err(14, "unknown compression type " + c_2);
+        err2(14, "unknown compression type " + c_2);
     }
   }
   return files;
@@ -28533,6 +28953,7 @@ function createSkillMarketClient(options) {
   const home = options.home ?? homedir6();
   const fetchImpl = options.fetchImpl ?? fetch;
   const now = options.now ?? Date.now;
+  const placeRename = options.renameImpl;
   let base;
   try {
     base = new URL(options.marketUrl);
@@ -28637,6 +29058,8 @@ function createSkillMarketClient(options) {
       throw new SkillMarketError("market_unavailable", "Project-scope install needs a workspaceRoot");
     return projectSkillsDir(workspaceRoot);
   };
+  const BACKUP_PREFIX = ".bak-";
+  const UUID_LENGTH = 36;
   const sweepTempDirs = async (skillsDir) => {
     const parent = dirname6(skillsDir);
     let names = [];
@@ -28646,11 +29069,26 @@ function createSkillMarketClient(options) {
       return;
     }
     await Promise.all(names.filter((n) => n.startsWith(".tmp-")).map((n) => rm4(join11(parent, n), { recursive: true, force: true }).catch(() => {})));
+    for (const n of names.filter((n) => n.startsWith(BACKUP_PREFIX))) {
+      const backup = join11(parent, n);
+      const skill = n.slice(BACKUP_PREFIX.length + UUID_LENGTH + 1);
+      if (skill === "" || skill.includes("/") || skill.includes("\\") || skill === "." || skill === "..")
+        continue;
+      const target = join11(skillsDir, skill);
+      if (await stat3(target).catch(() => {
+        return;
+      }) === undefined) {
+        await mkdir4(skillsDir, { recursive: true }).catch(() => {});
+        await renameWithRetry(backup, target).catch(() => {});
+      } else {
+        await rm4(backup, { recursive: true, force: true }).catch(() => {});
+      }
+    }
   };
   const install = async ({ name, scope, workspaceRoot, overwrite }) => {
     const skillsDir = skillsDirFor(scope, workspaceRoot);
     const target = join11(skillsDir, name);
-    const exists = await stat2(target).catch(() => {
+    const exists = await stat3(target).catch(() => {
       return;
     }) !== undefined;
     if (exists && overwrite !== true)
@@ -28665,17 +29103,27 @@ function createSkillMarketClient(options) {
         await mkdir4(dirname6(dest), { recursive: true });
         await writeFile4(dest, bytes);
       }
-      if (exists)
-        await rm4(target, { recursive: true, force: true });
       await mkdir4(skillsDir, { recursive: true });
-      await rename4(temp, target);
+      if (exists) {
+        const backup = join11(dirname6(skillsDir), `${BACKUP_PREFIX}${randomUUID4()}-${name}`);
+        await renameWithRetry(target, backup);
+        try {
+          await renameWithRetry(temp, target, placeRename ? { rename: placeRename } : {});
+        } catch (error) {
+          await renameWithRetry(backup, target).catch(() => {});
+          throw error;
+        }
+        await rm4(backup, { recursive: true, force: true }).catch(() => {});
+      } else {
+        await renameWithRetry(temp, target, placeRename ? { rename: placeRename } : {});
+      }
     } finally {
       await rm4(temp, { recursive: true, force: true }).catch(() => {});
     }
     let shadowedBy;
     if (scope === "user" && workspaceRoot !== undefined && workspaceRoot !== "") {
       const projectDir = join11(projectSkillsDir(workspaceRoot), name);
-      if (await stat2(projectDir).catch(() => {
+      if (await stat3(projectDir).catch(() => {
         return;
       }) !== undefined)
         shadowedBy = "project";
@@ -28685,7 +29133,7 @@ function createSkillMarketClient(options) {
   const uninstall = async ({ name, scope, workspaceRoot }) => {
     const skillsDir = skillsDirFor(scope, workspaceRoot);
     const target = join11(skillsDir, name);
-    if (await stat2(target).catch(() => {
+    if (await stat3(target).catch(() => {
       return;
     }) === undefined)
       throw new SkillMarketError("skill_not_installed", `Skill ${name} is not installed at ${scope} level`);
@@ -28719,7 +29167,7 @@ function createSkillMarketClient(options) {
 
 // packages/gateway/src/workspaces.ts
 import { constants as constants3 } from "fs";
-import { access, readdir as readdir3, stat as stat3 } from "fs/promises";
+import { access, readdir as readdir3, stat as stat4 } from "fs/promises";
 import { dirname as dirname7, isAbsolute as isAbsolute4, join as join12 } from "path";
 async function browseWorkspaces(options) {
   const requested = options.path.replace(/^\/+([A-Za-z]:[\\/])/, "$1");
@@ -28751,7 +29199,7 @@ async function browseWorkspaces(options) {
     if (!entry.isDirectory() && !entry.isSymbolicLink())
       continue;
     try {
-      if (!(await stat3(target)).isDirectory())
+      if (!(await stat4(target)).isDirectory())
         continue;
       await access(target, constants3.R_OK | constants3.X_OK);
       directories.push({ name: entry.name, path: target });
@@ -28788,9 +29236,11 @@ var ServerState = local3("neko.server-state", {
     credentials: CredentialStateSchema,
     searchSettings: SearchSettingsStateSchema,
     contextSettings: ContextSettingsStateSchema,
+    defaultModel: DefaultModelStateSchema,
     refreshCredentials: method2(Type12.Null(), Type12.Null()),
     refreshSearchSettings: method2(Type12.Null(), Type12.Null()),
-    refreshContextSettings: method2(Type12.Null(), Type12.Null())
+    refreshContextSettings: method2(Type12.Null(), Type12.Null()),
+    refreshDefaultModel: method2(Type12.Null(), Type12.Null())
   }
 });
 async function createNekoServerServices(options) {
@@ -28798,12 +29248,15 @@ async function createNekoServerServices(options) {
   const updates = new UpdateChecker(options.updates);
   await updates.local();
   const updateListeners = new Set;
-  const info = (value) => ({ ...value, serverId: options.serverId });
-  let published = JSON.stringify(updates.state), closed = false;
+  const info = (value) => {
+    const shell = runtime.shellStatus();
+    return { ...value, serverId: options.serverId, ...shell === undefined ? {} : { shell } };
+  };
+  let published = JSON.stringify(info(updates.state)), closed = false;
   const publishUpdates = () => {
     if (closed)
       return;
-    const next = JSON.stringify(updates.state);
+    const next = JSON.stringify(info(updates.state));
     if (next === published)
       return;
     published = next;
@@ -28822,6 +29275,7 @@ async function createNekoServerServices(options) {
       variant: "ready",
       info: current,
       check: async () => {
+        runtime.shellStatus({ refresh: true });
         await updates.check(true);
         publishUpdates();
         return info(updates.state);
@@ -28868,13 +29322,20 @@ async function createNekoServerServices(options) {
     status: info.status,
     awaitingAnswer: info.awaitingAnswer
   }));
-  const readStatuses = async () => Object.fromEntries(await Promise.all(CREDENTIAL_PROVIDERS.map(async (spec) => [spec.id, await runtime.credentialStatus(spec.id)])));
-  const [sessions, workspaces, statuses, search, contextSettings0] = await Promise.all([
+  const readStatuses = async () => {
+    const enabled = new Set(runtime.enabledProviders());
+    return Object.fromEntries(await Promise.all(CREDENTIAL_PROVIDERS.map(async (spec) => {
+      const status = await runtime.credentialStatus(spec.id);
+      return [spec.id, spec.kind === "model" ? { ...status, enabled: enabled.has(spec.id) } : status];
+    })));
+  };
+  const [sessions, workspaces, statuses, search, contextSettings0, defaultModel0] = await Promise.all([
     list(),
     runtime.listWorkspaces(),
     readStatuses(),
     runtime.searchSettings(),
-    runtime.contextSettings()
+    runtime.contextSettings(),
+    runtime.defaultModel()
   ]);
   let mutationTail = Promise.resolve();
   const serialize = (fn) => {
@@ -28891,6 +29352,7 @@ async function createNekoServerServices(options) {
       revision: 1,
       ...contextSettings0
     });
+    const defaultModel = self2.state("defaultModel", DefaultModelStateSchema, defaultModel0);
     const refreshContextSettings = async (_input, ctx) => {
       const next = await runtime.contextSettings();
       const { revision, ...current } = contextSettings.value;
@@ -28898,6 +29360,12 @@ async function createNekoServerServices(options) {
         contextSettings.replace(ctx, { revision: revision + 1, ...next });
       return null;
     };
+    const refreshDefaultModel = async (_input, ctx) => {
+      const next = await runtime.defaultModel();
+      if (JSON.stringify(next) !== JSON.stringify(defaultModel.value))
+        defaultModel.replace(ctx, next);
+      return null;
+    };
     const refreshSearchSettings = async (_input, ctx) => {
       const next = await runtime.searchSettings();
       const current = searchSettings.value;
@@ -28926,6 +29394,7 @@ async function createNekoServerServices(options) {
       credentials,
       searchSettings,
       contextSettings,
+      defaultModel,
       async refreshCredentials(_input, ctx) {
         credentials.replace(ctx, {
           revision: credentials.value.revision + 1,
@@ -28934,7 +29403,8 @@ async function createNekoServerServices(options) {
         return null;
       },
       refreshSearchSettings,
-      refreshContextSettings
+      refreshContextSettings,
+      refreshDefaultModel
     };
   }, { lifetime: "host" });
   const shared = (self2) => self2.get(ServerState, {});
@@ -28957,7 +29427,17 @@ async function createNekoServerServices(options) {
       remove: async (input, ctx) => {
         await runtime.removeCredential(input.provider);
         return hub.refreshCredentials(null, ctx);
-      }
+      },
+      setEnabled: (input, ctx) => serialize(async () => {
+        if (!isModelProvider(input.provider))
+          throw new ChordError5("invalid", "Unknown model provider.");
+        try {
+          await runtime.setProviderEnabled(input.provider, input.enabled);
+        } catch (error) {
+          throw new ChordError5("invalid", error instanceof Error ? error.message : "Cannot change provider.");
+        }
+        return hub.refreshCredentials(null, ctx);
+      })
     };
   });
   host.serve(NekoSearchSettings, (_input, _principal, self2) => {
@@ -28986,9 +29466,24 @@ async function createNekoServerServices(options) {
       })
     };
   });
+  host.serve(NekoDefaultModel, (_input, _principal, self2) => {
+    const hub = shared(self2);
+    return {
+      variant: "ready",
+      state: hub.defaultModel,
+      set: (input, ctx) => serialize(async () => {
+        await runtime.setDefaultModel(input);
+        return hub.refreshDefaultModel(null, ctx);
+      }),
+      clear: (_input, ctx) => serialize(async () => {
+        await runtime.setDefaultModel(null);
+        return hub.refreshDefaultModel(null, ctx);
+      })
+    };
+  });
   host.serve(NekoModels, () => ({
     variant: "ready",
-    list: async () => [...runtime.listModels()].map((value) => ({
+    list: async () => (await runtime.listSelectableModels()).map((value) => ({
       ...value,
       input: [...value.input],
       supportedThinkingLevels: [...value.supportedThinkingLevels]
@@ -29282,7 +29777,6 @@ var SERVER_ID_FILENAME = "gateway-server-id";
 async function startGateway(options = {}) {
   const context = options.context ?? BACKGROUND_CONTEXT4;
   const fileConfig = loadNekoConfig(options.configDir);
-  const model = options.model ?? fileConfig.defaultModel ?? DEFAULT_MODEL;
   const storagePath = options.storagePath ?? fileConfig.storagePath ?? DEFAULT_STORAGE_PATH;
   const host = options.host ?? fileConfig.gateway?.host ?? DEFAULT_HOST;
   const port = options.port !== undefined ? options.port : fileConfig.gateway?.port ?? (process.platform === "win32" ? 0 : DEFAULT_PORT);
@@ -29300,12 +29794,15 @@ async function startGateway(options = {}) {
     ...options.apiKey !== undefined ? { apiKey: options.apiKey } : {},
     ...searchProvider !== undefined ? { searchProvider } : {},
     ...fileConfig.context !== undefined ? { contextSettings: fileConfig.context } : {},
-    model,
+    ...fileConfig.defaultModel !== undefined ? { model: fileConfig.defaultModel } : {},
+    ...options.model !== undefined ? { modelOverride: options.model } : {},
     thinkingLevel: options.thinkingLevel ?? fileConfig.thinkingLevel ?? "high",
     ...options.cwd !== undefined ? { cwd: options.cwd } : {},
     ...options.providers !== undefined ? { providers: options.providers } : {},
     ...options.extensions !== undefined ? { extensions: options.extensions } : {},
-    ...options.promptHome !== undefined ? { promptHome: options.promptHome } : {}
+    ...options.promptHome !== undefined ? { promptHome: options.promptHome } : {},
+    ...fileConfig.shell?.path !== undefined ? { shellPath: fileConfig.shell.path } : {},
+    ...options.shellResolver !== undefined ? { shellResolver: options.shellResolver } : {}
   });
   try {
     return await bindGateway(runtime, {
@@ -29315,12 +29812,12 @@ async function startGateway(options = {}) {
       socketPath,
       serverId,
       nekoDir,
-      model,
       marketUrl,
       promptHome: options.promptHome,
       updates: options.updates,
       updateIntervalMs: options.updateIntervalMs,
       mobileServerName: options.mobileServerName,
+      mobileNetwork: options.mobileNetwork,
       onError: options.onError
     });
   } catch (error) {
@@ -29355,12 +29852,13 @@ async function bindGateway(runtime, options) {
     wsListener = createWsListener({ host, port, onError: options.onError });
     listeners.push(wsListener);
   }
+  const acceptLocal = (link) => chord.accept(link, {
+    principal: { kind: "local", connectionId: randomUUID6() },
+    onProtocolMismatch: ({ peer }) => options.onError?.(new Error(`Rejected a client on Chord protocol ${peer ?? "unknown"}; restart or update it.`))
+  });
   try {
     for (const listener of listeners)
-      await listener.start((link) => chord.accept(link, {
-        principal: { kind: "local", connectionId: randomUUID6() },
-        onProtocolMismatch: ({ peer }) => options.onError?.(new Error(`Rejected a client on Chord protocol ${peer ?? "unknown"}; restart or update it.`))
-      }));
+      await listener.start(acceptLocal);
   } catch (error) {
     await Promise.allSettled(listeners.map((listener) => listener.close()));
     await chord.close();
@@ -29376,6 +29874,7 @@ async function bindGateway(runtime, options) {
     serverId,
     serverName: options.mobileServerName,
     onError: options.onError,
+    network: options.mobileNetwork,
     chord: {
       accept: (link, acceptOptions) => chord.accept(link, acceptOptions),
       invalidatePrincipal: (match) => chord.invalidatePrincipal(match)
@@ -29400,6 +29899,9 @@ async function bindGateway(runtime, options) {
     port: wsListener?.port,
     runtime,
     mobile,
+    accept(link) {
+      acceptLocal(link);
+    },
     async close() {
       if (closing)
         return closing;
@@ -29485,14 +29987,15 @@ function installShutdown(options = {}) {
       exit(1);
     });
   };
-  const onSignal = () => {
+  const begin = (reason) => {
     if (controller.signal.aborted) {
       options.log?.("\u518D\u6B21\u6536\u5230\u7EC8\u6B62\u4FE1\u53F7\uFF0C\u5F3A\u5236\u9000\u51FA\u3002");
       exit(130);
       return;
     }
-    options.log?.(`
-\u6B63\u5728\u5173\u95ED\u2026`);
+    options.log?.(reason === undefined ? `
+\u6B63\u5728\u5173\u95ED\u2026` : `
+\u6B63\u5728\u5173\u95ED\uFF08${reason}\uFF09\u2026`);
     controller.abort();
     timer = setTimeout(() => {
       options.log?.("\u5173\u95ED\u8D85\u65F6\uFF0C\u5F3A\u5236\u9000\u51FA\u3002");
@@ -29501,6 +30004,7 @@ function installShutdown(options = {}) {
     timer.unref?.();
     runCleanup();
   };
+  const onSignal = () => begin(undefined);
   const installed = [];
   for (const signal of shutdownSignals(proc.platform)) {
     try {
@@ -29515,6 +30019,9 @@ function installShutdown(options = {}) {
       if (controller.signal.aborted)
         runCleanup();
     },
+    trigger(reason) {
+      begin(reason);
+    },
     dispose() {
       clearTimeout(timer);
       for (const signal of installed)
@@ -29545,3 +30052,15 @@ if (gateway.wsUrl !== undefined)
   console.log(`  WebSocket:   ${gateway.wsUrl}`);
 console.log("\u6309 Ctrl+C \u505C\u6B62\u3002");
 shutdown.setCleanup(() => gateway.close());
+if (options.stopOnStdin === true) {
+  let triggered = false;
+  const onStdinEnd = () => {
+    if (triggered)
+      return;
+    triggered = true;
+    shutdown.trigger("stdin \u5DF2\u5173\u95ED");
+  };
+  process.stdin.once("end", onStdinEnd);
+  process.stdin.once("close", onStdinEnd);
+  process.stdin.resume();
+}