@co0ontty/wand 1.41.3 → 1.42.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "1f4df3d175e7fca737cf75fa45388d55dc870531",
-  "builtAt": "2026-05-30T23:40:01.415Z",
-  "version": "1.41.3",
+  "commit": "c94bcd87ab8e081c2d72f7d9c35130991379e5e0",
+  "builtAt": "2026-05-31T01:26:56.891Z",
+  "version": "1.42.0",
   "channel": "stable"
 }

package/dist/npm-update-utils.d.ts

@@ -8,8 +8,8 @@
  * 如果安装中途失败，这个备份目录会留下，之后每次 npm install 都会因为目标 dest 已存在
  * 报 `ENOTEMPTY: directory not empty, rename ...`。
  *
- * 我们的策略：每次 npm install 之前先清掉 `@co0ontty/.wand-*` 残留目录；
- * 如果第一次安装仍然撞上 ENOTEMPTY，清理后重试；再不行就 uninstall + force install。
+ * 我们的策略：安装前备份当前全局包，补齐 npm 子进程 PATH，清掉
+ * `@co0ontty/.wand-*` 残留目录；失败时恢复备份，避免运行中的服务被半成品安装拆掉。
  */
 /**
  * 解析当前 `npm root -g` 的目录。失败返回 null。

package/dist/npm-update-utils.js

@@ -8,24 +8,64 @@
  * 如果安装中途失败，这个备份目录会留下，之后每次 npm install 都会因为目标 dest 已存在
  * 报 `ENOTEMPTY: directory not empty, rename ...`。
  *
- * 我们的策略：每次 npm install 之前先清掉 `@co0ontty/.wand-*` 残留目录；
- * 如果第一次安装仍然撞上 ENOTEMPTY，清理后重试；再不行就 uninstall + force install。
+ * 我们的策略：安装前备份当前全局包，补齐 npm 子进程 PATH，清掉
+ * `@co0ontty/.wand-*` 残留目录；失败时恢复备份，避免运行中的服务被半成品安装拆掉。
  */
-import { exec, spawnSync } from "node:child_process";
-import { chmodSync, existsSync, readdirSync, rmSync, statSync } from "node:fs";
+import { execFile, spawnSync } from "node:child_process";
+import { chmodSync, cpSync, existsSync, mkdtempSync, readdirSync, rmSync, statSync } from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import process from "node:process";
 import { promisify } from "node:util";
-const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
 const PACKAGE_NAME = "@co0ontty/wand";
 const PACKAGE_SCOPE = "@co0ontty";
 const PACKAGE_BASENAME = "wand";
+const NPM_BIN = process.platform === "win32" ? "npm.cmd" : "npm";
+const COMMON_UNIX_PATHS = ["/usr/local/sbin", "/usr/local/bin", "/usr/sbin", "/usr/bin", "/sbin", "/bin"];
+const INSTALL_MAX_BUFFER = 10 * 1024 * 1024;
+function getChildEnv() {
+    const entries = [
+        path.dirname(process.execPath),
+        ...(process.env.PATH || "").split(path.delimiter),
+        ...(process.platform === "win32" ? [] : COMMON_UNIX_PATHS),
+    ];
+    const seen = new Set();
+    const pathEntries = [];
+    for (const entry of entries) {
+        if (!entry || seen.has(entry))
+            continue;
+        seen.add(entry);
+        pathEntries.push(entry);
+    }
+    return {
+        ...process.env,
+        PATH: pathEntries.join(path.delimiter),
+    };
+}
+function runNpmSync(args, timeoutMs) {
+    const options = {
+        encoding: "utf8",
+        timeout: timeoutMs,
+        env: getChildEnv(),
+        maxBuffer: INSTALL_MAX_BUFFER,
+    };
+    return spawnSync(NPM_BIN, args, options);
+}
+async function runNpmAsync(args, timeoutMs) {
+    const options = {
+        timeout: timeoutMs,
+        env: getChildEnv(),
+        maxBuffer: INSTALL_MAX_BUFFER,
+    };
+    await execFileAsync(NPM_BIN, args, options);
+}
 /**
  * 解析当前 `npm root -g` 的目录。失败返回 null。
  */
 export function getNpmGlobalRoot() {
     try {
-        const res = spawnSync("npm", ["root", "-g"], { encoding: "utf8", timeout: 10_000 });
+        const res = runNpmSync(["root", "-g"], 10_000);
         if (res.status !== 0)
             return null;
         const out = (res.stdout || "").trim();
@@ -82,6 +122,7 @@ const REQUIRED_RUNTIME_FILES = [
     path.join("dist", "cli.js"),
     path.join("dist", "server.js"),
     path.join("dist", "web-ui", "index.js"),
+    path.join("dist", "web-ui", "embedded-assets.js"),
     path.join("dist", "web-ui", "scripts.js"),
     path.join("dist", "web-ui", "styles.js"),
     path.join("dist", "web-ui", "content", "scripts.js"),
@@ -139,6 +180,60 @@ function assertGlobalWandInstallComplete() {
         throw new Error(result.message);
     }
 }
+function createGlobalInstallBackup(note) {
+    const packageDir = getGlobalPackageDir();
+    if (!packageDir) {
+        return { packageDir: "", backupDir: null };
+    }
+    if (!existsSync(packageDir)) {
+        return { packageDir, backupDir: null };
+    }
+    const backupRoot = mkdtempSync(path.join(os.tmpdir(), "wand-global-backup-"));
+    const backupDir = path.join(backupRoot, PACKAGE_BASENAME);
+    try {
+        cpSync(packageDir, backupDir, {
+            recursive: true,
+            dereference: false,
+            verbatimSymlinks: true,
+        });
+        note?.(`[wand] 已备份当前全局安装: ${backupDir}`);
+        return { packageDir, backupDir };
+    }
+    catch (err) {
+        rmSync(backupRoot, { recursive: true, force: true });
+        note?.(`[wand] 全局安装备份失败，继续尝试更新: ${err instanceof Error ? err.message : String(err)}`);
+        return { packageDir, backupDir: null };
+    }
+}
+function cleanupGlobalInstallBackup(backup) {
+    if (!backup.backupDir)
+        return;
+    rmSync(path.dirname(backup.backupDir), { recursive: true, force: true });
+}
+function restoreGlobalInstallBackup(backup, note) {
+    if (!backup.packageDir || !backup.backupDir || !existsSync(backup.backupDir))
+        return false;
+    try {
+        rmSync(backup.packageDir, { recursive: true, force: true });
+        cpSync(backup.backupDir, backup.packageDir, {
+            recursive: true,
+            dereference: false,
+            verbatimSymlinks: true,
+        });
+        note?.(`[wand] 已恢复更新前的全局安装: ${backup.packageDir}`);
+        return true;
+    }
+    catch (err) {
+        note?.(`[wand] 恢复更新前安装失败: ${err instanceof Error ? err.message : String(err)}`);
+        return false;
+    }
+}
+async function npmInstallGlobalAsync(pkg, timeoutMs, extra = []) {
+    await runNpmAsync(["install", "-g", ...extra, pkg], timeoutMs);
+}
+function isRecoverableInstallError(message) {
+    return /ENOTEMPTY|EEXIST|全局 wand 安装不完整|无法解析 npm 全局安装目录|全局 wand CLI 无法设置执行权限/.test(message);
+}
 /**
  * 异步版本的全局安装：
  * 1. 清理残留
@@ -155,54 +250,67 @@ export async function installPackageGloballyAsync(pkg, timeoutMs, log) {
         if (log)
             log(line);
     };
-    const cleanup = cleanupNpmLeftovers();
-    if (cleanup.removed.length > 0) {
-        note(`[wand] 清理 npm 残留目录: ${cleanup.removed.join(", ")}`);
-    }
+    const backup = createGlobalInstallBackup(note);
+    let success = false;
     try {
-        await execAsync(`npm install -g ${pkg}`, { timeout: timeoutMs });
-        assertGlobalWandInstallComplete();
-        return;
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        if (!/ENOTEMPTY|EEXIST/.test(msg)) {
-            if (/全局 wand 安装不完整|无法解析 npm 全局安装目录/.test(msg)) {
-                note(`[wand] npm install 后安装目录不完整，尝试强制重装...`);
-            }
-            else {
+        const cleanup = cleanupNpmLeftovers();
+        if (cleanup.removed.length > 0) {
+            note(`[wand] 清理 npm 残留目录: ${cleanup.removed.join(", ")}`);
+        }
+        try {
+            await npmInstallGlobalAsync(pkg, timeoutMs);
+            assertGlobalWandInstallComplete();
+            success = true;
+            return;
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            if (!isRecoverableInstallError(msg)) {
                 throw error;
             }
-        }
-        else {
-            note(`[wand] npm install 遇到 ENOTEMPTY/EEXIST，清理后重试一次...`);
-            cleanupNpmLeftovers();
-            try {
-                await execAsync(`npm install -g ${pkg}`, { timeout: timeoutMs });
-                assertGlobalWandInstallComplete();
-                return;
+            if (/全局 wand 安装不完整|无法解析 npm 全局安装目录|全局 wand CLI 无法设置执行权限/.test(msg)) {
+                note(`[wand] npm install 后安装目录不完整，尝试强制重装...`);
             }
-            catch (retryError) {
-                const retryMsg = retryError instanceof Error ? retryError.message : String(retryError);
-                if (!/ENOTEMPTY|EEXIST|全局 wand 安装不完整|无法解析 npm 全局安装目录/.test(retryMsg)) {
-                    throw retryError;
+            else {
+                note(`[wand] npm install 遇到 ENOTEMPTY/EEXIST，清理后重试一次...`);
+                cleanupNpmLeftovers();
+                try {
+                    await npmInstallGlobalAsync(pkg, timeoutMs);
+                    assertGlobalWandInstallComplete();
+                    success = true;
+                    return;
                 }
+                catch (retryError) {
+                    const retryMsg = retryError instanceof Error ? retryError.message : String(retryError);
+                    if (!isRecoverableInstallError(retryMsg)) {
+                        throw retryError;
+                    }
+                }
+                note(`[wand] 重试仍失败，尝试先卸载再强制安装...`);
             }
-            note(`[wand] 重试仍失败，尝试先卸载再强制安装...`);
         }
+        // 终极兜底：uninstall + force install
+        // 卸载用固定包名 PACKAGE_NAME，而不是从 install spec 反推：spec 可能是 git
+        // 形式（`github:co0ontty/wand#beta`），用正则 strip @tag 反推会得到错误的卸载目标。
+        try {
+            await runNpmAsync(["uninstall", "-g", PACKAGE_NAME], timeoutMs);
+        }
+        catch {
+            /* 卸载失败也继续，下一步 --force 可能仍然能装上 */
+        }
+        cleanupNpmLeftovers();
+        await npmInstallGlobalAsync(pkg, timeoutMs, ["--force"]);
+        assertGlobalWandInstallComplete();
+        success = true;
     }
-    // 终极兜底：uninstall + force install
-    // 卸载用固定包名 PACKAGE_NAME，而不是从 install spec 反推：spec 可能是 git
-    // 形式（`github:co0ontty/wand#beta`），用正则 strip @tag 反推会得到错误的卸载目标。
-    try {
-        await execAsync(`npm uninstall -g ${PACKAGE_NAME}`, { timeout: timeoutMs });
-    }
-    catch {
-        /* 卸载失败也继续，下一步 --force 可能仍然能装上 */
+    finally {
+        if (!success) {
+            if (restoreGlobalInstallBackup(backup, note)) {
+                cleanupNpmLeftovers();
+            }
+        }
+        cleanupGlobalInstallBackup(backup);
     }
-    cleanupNpmLeftovers();
-    await execAsync(`npm install -g --force ${pkg}`, { timeout: timeoutMs });
-    assertGlobalWandInstallComplete();
 }
 /**
  * 同步版本，给 TUI installUpdate 用。
@@ -211,6 +319,8 @@ export async function installPackageGloballyAsync(pkg, timeoutMs, log) {
  */
 export function installPackageGloballySync(pkg, timeoutMs) {
     const attempts = [];
+    const backupNotes = [];
+    const backup = createGlobalInstallBackup((line) => backupNotes.push(line));
     const withValidation = (res) => {
         if (res.status !== 0)
             return res;
@@ -226,32 +336,55 @@ export function installPackageGloballySync(pkg, timeoutMs) {
     const tryInstall = (extra) => {
         const args = ["install", "-g", ...extra, pkg];
         attempts.push(`npm ${args.join(" ")}`);
-        const r = spawnSync("npm", args, { encoding: "utf8", timeout: timeoutMs });
+        const r = runNpmSync(args, timeoutMs);
         return withValidation({
             status: r.status,
             stdout: r.stdout || "",
             stderr: r.stderr || "",
         });
     };
+    const withBackupNotes = (res) => ({
+        ...res,
+        stderr: [res.stderr, ...backupNotes].filter(Boolean).join("\n"),
+        attempts,
+    });
+    const finishSuccess = (res) => {
+        cleanupGlobalInstallBackup(backup);
+        return withBackupNotes(res);
+    };
+    const finishFailure = (res) => {
+        if (restoreGlobalInstallBackup(backup, (line) => backupNotes.push(line))) {
+            cleanupNpmLeftovers();
+        }
+        cleanupGlobalInstallBackup(backup);
+        return withBackupNotes(res);
+    };
     cleanupNpmLeftovers();
     let res = tryInstall([]);
-    if (res.status === 0)
-        return { ...res, attempts };
-    const hitRecoverableInstallError = (r) => /ENOTEMPTY|EEXIST|全局 wand 安装不完整|无法解析 npm 全局安装目录/.test(r.stdout + r.stderr);
-    if (!hitRecoverableInstallError(res))
-        return { ...res, attempts };
+    if (res.status === 0) {
+        return finishSuccess(res);
+    }
+    const hitRecoverableInstallError = (r) => isRecoverableInstallError(r.stdout + r.stderr);
+    if (!hitRecoverableInstallError(res)) {
+        return finishFailure(res);
+    }
     cleanupNpmLeftovers();
     res = tryInstall([]);
-    if (res.status === 0)
-        return { ...res, attempts };
-    if (!hitRecoverableInstallError(res))
-        return { ...res, attempts };
+    if (res.status === 0) {
+        return finishSuccess(res);
+    }
+    if (!hitRecoverableInstallError(res)) {
+        return finishFailure(res);
+    }
     // 终极兜底（卸载用固定包名，兼容 git spec，见 async 版同样注释）
     attempts.push(`npm uninstall -g ${PACKAGE_NAME}`);
-    spawnSync("npm", ["uninstall", "-g", PACKAGE_NAME], { encoding: "utf8", timeout: timeoutMs });
+    runNpmSync(["uninstall", "-g", PACKAGE_NAME], timeoutMs);
     cleanupNpmLeftovers();
     res = tryInstall(["--force"]);
-    return { ...res, attempts };
+    if (res.status === 0) {
+        return finishSuccess(res);
+    }
+    return finishFailure(res);
 }
 /**
  * 解析「刚装好的全局 wand CLI 入口」(dist/cli.js) 的绝对路径。
@@ -276,7 +409,7 @@ export function resolveGlobalWandCli() {
     }
     try {
         const tool = process.platform === "win32" ? "where" : "which";
-        const r = spawnSync(tool, ["wand"], { encoding: "utf8", timeout: 10_000 });
+        const r = spawnSync(tool, ["wand"], { encoding: "utf8", timeout: 10_000, env: getChildEnv() });
         if (r.status === 0) {
             const first = (r.stdout || "").split(/\r?\n/).find((line) => line.trim().length > 0);
             if (first)

package/dist/pwa.js

@@ -1,13 +1,8 @@
 /**
  * PWA manifest and Service Worker generation.
  */
-import { readFileSync, existsSync, statSync } from "node:fs";
 import { createHash } from "node:crypto";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const pkgPath = path.join(__dirname, "..", "package.json");
-const pkgVersion = JSON.parse(readFileSync(pkgPath, "utf-8")).version ?? "0";
+import { EMBEDDED_WEB_ASSET_VERSION } from "./web-ui/embedded-assets.js";
 /** Cache version: package version + content fingerprint.
  *
  * 之前只用 pkgVersion 派生，本地 dev 时同一个 1.36.0 下改了几次 CSS / scripts，
@@ -18,22 +13,7 @@ const pkgVersion = JSON.parse(readFileSync(pkgPath, "utf-8")).version ?? "0";
  * 正式发版时由于 pkgVersion 也会变，效果叠加，无副作用。
  */
 function buildCacheVersion() {
-    const h = createHash("md5").update(pkgVersion);
-    const fingerprintTargets = [
-        path.join(__dirname, "web-ui", "content", "scripts.js"),
-        path.join(__dirname, "web-ui", "content", "styles.css"),
-    ];
-    for (const p of fingerprintTargets) {
-        try {
-            if (existsSync(p)) {
-                const s = statSync(p);
-                h.update(":").update(p).update(":").update(String(s.mtimeMs)).update(":").update(String(s.size));
-            }
-        }
-        catch {
-            // best effort — fingerprint 只是为了 bust 缓存，失败就退化成 pkg-only
-        }
-    }
+    const h = createHash("md5").update(EMBEDDED_WEB_ASSET_VERSION);
     return h.digest("hex").slice(0, 8);
 }
 // 不 freeze 进模块加载时——SW JS 是每次请求 generateServiceWorker() 现拼的，

package/dist/server.js

@@ -25,11 +25,13 @@ import { installPackageGloballyAsync, resolveGlobalWandCli } from "./npm-update-
 import { repairServiceUnitAfterUpdate } from "./service-self-repair.js";
 import { computeRelaunch } from "./relaunch.js";
 import { isServiceInstalled } from "./tui/commands.js";
+import { canUseDetachedUpdateHelper, startDetachedUpdateHelper } from "./update-helper.js";
 import { registerUploadRoutes } from "./upload-routes.js";
 import { optimizePrompt, PromptOptimizeError } from "./prompt-optimizer.js";
 import { resolveDatabasePath, WandStorage } from "./storage.js";
 import { deepRepairRuntimePath, formatPathRepairSummary, repairRuntimePath } from "./path-repair.js";
 import { isLogBusActive, wandTuiLog } from "./tui/log-bus.js";
+import { EMBEDDED_WEB_ASSETS } from "./web-ui/embedded-assets.js";
 import { renderApp } from "./web-ui/index.js";
 import { WsBroadcastManager } from "./ws-broadcast.js";
 import { checkRateLimit, recordFailedLogin, resetRateLimit } from "./middleware/rate-limit.js";
@@ -930,12 +932,14 @@ export async function startServer(config, configPath) {
     const nodeModulesDir = path.join(RUNTIME_ROOT_DIR, "node_modules");
     app.use(express.json({ limit: "1mb" }));
     app.use(compression({ threshold: 1024 }));
-    const vendorCacheOpts = { maxAge: "7d", immutable: true };
-    const contentDir = existsSync(path.join(SERVER_MODULE_DIR, "web-ui", "content"))
-        ? path.join(SERVER_MODULE_DIR, "web-ui", "content")
-        : path.join(RUNTIME_ROOT_DIR, "src", "web-ui", "content");
-    app.use("/vendor/wterm", express.static(path.join(contentDir, "vendor", "wterm"), vendorCacheOpts));
-    app.use("/vendor/qrcode", express.static(path.join(contentDir, "vendor", "qrcode"), vendorCacheOpts));
+    const sendEmbeddedVendorAsset = (assetPath, _req, res) => {
+        const asset = EMBEDDED_WEB_ASSETS.vendor[assetPath];
+        res.setHeader("Cache-Control", "public, max-age=604800, immutable");
+        res.type(asset.contentType).send(asset.content);
+    };
+    app.get("/vendor/wterm/wterm.bundle.js", (req, res) => sendEmbeddedVendorAsset("/vendor/wterm/wterm.bundle.js", req, res));
+    app.get("/vendor/wterm/terminal.css", (req, res) => sendEmbeddedVendorAsset("/vendor/wterm/terminal.css", req, res));
+    app.get("/vendor/qrcode/qrcode.bundle.js", (req, res) => sendEmbeddedVendorAsset("/vendor/qrcode/qrcode.bundle.js", req, res));
     // ── Web UI and PWA endpoints ──
     app.get("/", (_req, res) => {
         res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
@@ -994,9 +998,6 @@ export async function startServer(config, configPath) {
             res.type("image/svg+xml").send(getAvatarSvg(avatarSeed, size));
         });
     }
-    const iconsDir = path.resolve(existsSync(path.join(SERVER_MODULE_DIR, "web-ui", "content"))
-        ? path.join(SERVER_MODULE_DIR, "web-ui", "content")
-        : path.join(RUNTIME_ROOT_DIR, "src", "web-ui", "content"));
     app.get("/sw.js", (_req, res) => {
         res.setHeader("Content-Type", "application/javascript");
         res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
@@ -1569,31 +1570,40 @@ export async function startServer(config, configPath) {
                 installSpec = `${PKG_NAME}@latest`;
                 targetLabel = onBetaBuild ? "最新正式版" : latest;
             }
-            // beta 走 git 安装（clone + 装依赖），比 registry tarball 慢，给足超时。
-            const logLines = [];
-            try {
-                await installPackageGloballyAsync(installSpec, 300000, (line) => {
-                    logLines.push(line);
-                    process.stdout.write(`${line}\n`);
-                });
+            if (!canUseDetachedUpdateHelper()) {
+                res.status(500).json({ error: "当前平台暂不支持 Web 异步更新，请在终端运行 install.sh 更新。" });
+                return;
             }
-            catch (e) {
-                res.status(500).json({
-                    error: getErrorMessage(e, "更新失败。"),
-                    detail: logLines.join("\n").slice(-2000),
-                });
+            const helper = startDetachedUpdateHelper({
+                installSpec,
+                configPath,
+                parentPid: process.pid,
+                cliArgs: process.argv.slice(2),
+                cwd: process.cwd(),
+                env: process.env,
+                timeoutMs: 300000,
+            });
+            if (!helper.started) {
+                res.status(500).json({ error: helper.message, detail: `script=${helper.scriptPath}\nlog=${helper.logPath}` });
                 return;
             }
-            // 镜像 install.sh：装完用全局安装刷新服务 unit（ExecStart/PATH），重启才会跑到新版。
-            const repair = repairServiceUnitAfterUpdate(configPath);
-            // 装包成功后告知前端可以发起重启；前端会随即调用 /api/restart 完成自动重启。
+            process.stdout.write(`[wand] ${helper.message}\n`);
+            wsManager.emitEvent({
+                type: "notification",
+                sessionId: "__system__",
+                data: { kind: "auto-update-restart", current: PKG_VERSION, latest: targetLabel },
+            });
             res.json({
                 ok: true,
-                message: `已更新到 ${targetLabel}`,
-                restartRequired: true,
+                message: `已开始更新到 ${targetLabel}`,
+                restartRequired: false,
+                detachedUpdate: true,
                 version: targetLabel,
-                serviceRepair: repair.scope ? { repaired: repair.repaired, message: repair.message } : null,
+                logPath: helper.logPath,
             });
+            setTimeout(() => {
+                shutdownForDetachedUpdate();
+            }, 500);
         }
         catch (error) {
             res.status(500).json({ error: getErrorMessage(error, "更新失败。") });
@@ -2187,6 +2197,18 @@ export async function startServer(config, configPath) {
         // Force exit after 5s if graceful shutdown stalls
         setTimeout(() => process.exit(0), 5000);
     }
+    function shutdownForDetachedUpdate() {
+        try {
+            wss.clients.forEach((client) => client.close());
+        }
+        catch {
+            /* noop */
+        }
+        server.close(() => {
+            process.exit(0);
+        });
+        setTimeout(() => process.exit(0), 3000);
+    }
     app.post("/api/restart", async (_req, res) => {
         res.json({ ok: true, message: "服务正在重启..." });
         wsManager.emitEvent({

package/dist/structured-session-manager.d.ts

@@ -32,8 +32,8 @@ export declare function thinkingEffortToSdkBudget(effort: SessionSnapshot["think
  * off → 原 prompt 不变。
  */
 export declare function applyThinkingEffortToPrompt(prompt: string, effort: SessionSnapshot["thinkingEffort"]): string;
-/** Codex CLI 用：把 thinkingEffort 映射到 --reasoning-effort 参数。off → minimal（不显式思考）。 */
-export declare function thinkingEffortToCodexFlag(effort: SessionSnapshot["thinkingEffort"]): string | null;
+/** Codex CLI 用：把 thinkingEffort 映射到 model_reasoning_effort 配置。off → minimal。 */
+export declare function thinkingEffortToCodexReasoningEffort(effort: SessionSnapshot["thinkingEffort"]): string | null;
 export declare class StructuredSessionManager {
     private readonly storage;
     private readonly config;
@@ -110,7 +110,7 @@ export declare class StructuredSessionManager {
     /**
      * Update the thinking-effort level for a structured session. Takes effect on
      * the next spawn / next message (SDK runner injects `thinking`, CLI runner
-     * prepends magic words, codex runner adds --reasoning-effort).
+     * prepends magic words, codex runner overrides `model_reasoning_effort`).
      */
     setSessionThinkingEffort(sessionId: string, effort: SessionSnapshot["thinkingEffort"]): SessionSnapshot;
     /** Toggle auto-approve for the session. */

package/dist/structured-session-manager.js

@@ -74,8 +74,8 @@ export function applyThinkingEffortToPrompt(prompt, effort) {
         return prompt;
     return prefix + trimmed;
 }
-/** Codex CLI 用：把 thinkingEffort 映射到 --reasoning-effort 参数。off → minimal（不显式思考）。 */
-export function thinkingEffortToCodexFlag(effort) {
+/** Codex CLI 用：把 thinkingEffort 映射到 model_reasoning_effort 配置。off → minimal。 */
+export function thinkingEffortToCodexReasoningEffort(effort) {
     switch (effort) {
         case "standard": return "low";
         case "deep": return "medium";
@@ -862,7 +862,7 @@ export class StructuredSessionManager {
     /**
      * Update the thinking-effort level for a structured session. Takes effect on
      * the next spawn / next message (SDK runner injects `thinking`, CLI runner
-     * prepends magic words, codex runner adds --reasoning-effort).
+     * prepends magic words, codex runner overrides `model_reasoning_effort`).
      */
     setSessionThinkingEffort(sessionId, effort) {
         const session = this.requireSession(sessionId);
@@ -1117,10 +1117,12 @@ export class StructuredSessionManager {
         if (modelChoice && modelChoice !== "default") {
             args.push("--model", modelChoice);
         }
-        // 思考深度 → --reasoning-effort（off → minimal，standard → low，deep → medium，max → high）
-        const reasoningFlag = thinkingEffortToCodexFlag(session.thinkingEffort);
-        if (reasoningFlag) {
-            args.push("--reasoning-effort", reasoningFlag);
+        // 思考深度 → model_reasoning_effort（off → minimal，standard → low，deep → medium，max → high）
+        // Newer Codex CLI versions removed the old dedicated exec flag, but still
+        // accept config overrides through `-c`.
+        const reasoningEffort = thinkingEffortToCodexReasoningEffort(session.thinkingEffort);
+        if (reasoningEffort) {
+            args.push("-c", `model_reasoning_effort=${reasoningEffort}`);
         }
         if (session.claudeSessionId) {
             args.push("resume", session.claudeSessionId, "-");

package/dist/types.d.ts

@@ -440,7 +440,7 @@ export interface SessionSnapshot {
     selectedModel?: string | null;
     /**
      * 用户选定的思考深度。
-     *   - off:      不启用思考（SDK: 不传 thinking；CLI: 不插魔法词；Codex: --reasoning-effort minimal）
+     *   - off:      不启用思考（SDK: 不传 thinking；CLI: 不插魔法词；Codex: model_reasoning_effort minimal）
      *   - standard: 标准（SDK: budget 4096；CLI: think；Codex: low）
      *   - deep:    深度（SDK: budget 16000；CLI: think hard；Codex: medium）
      *   - max:     最深（SDK: budget 31999；CLI: ultrathink；Codex: high）

package/dist/update-helper.d.ts

@@ -0,0 +1,18 @@
+export interface DetachedUpdateOptions {
+    installSpec: string;
+    configPath: string;
+    parentPid: number;
+    cliArgs: string[];
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    timeoutMs?: number;
+}
+export interface DetachedUpdateResult {
+    started: boolean;
+    scriptPath: string;
+    logPath: string;
+    pid?: number;
+    message: string;
+}
+export declare function startDetachedUpdateHelper(opts: DetachedUpdateOptions): DetachedUpdateResult;
+export declare function canUseDetachedUpdateHelper(): boolean;