@co0ontty/wand 4.73.0 → 4.75.1-beta.gbf7dafd

package/dist/structured-provider-common.js

@@ -1,10 +1,23 @@
-/** 判断任意值是否为合法的 thinking effort 字面量（含 `codex:<level>` 形式）。 */
+const NATIVE_THINKING_EFFORT = /^(claude|codex|opencode|grok|qoder|pi):[a-z0-9][a-z0-9_-]{0,31}$/;
+/** 判断任意值是否为合法的 thinking effort（旧四档，或 `provider:level`）。 */
 export function isThinkingEffort(value) {
     return value === "off"
         || value === "standard"
         || value === "deep"
         || value === "max"
-        || (typeof value === "string" && /^codex:[a-z0-9][a-z0-9_-]{0,31}$/.test(value));
+        || (typeof value === "string" && NATIVE_THINKING_EFFORT.test(value));
+}
+/** 只取本 provider 的原生档位。别的 CLI 的前缀不能串过去。 */
+export function prefixedThinkingEffort(provider, effort) {
+    if (typeof effort !== "string")
+        return null;
+    const separator = effort.indexOf(":");
+    if (separator <= 0)
+        return null;
+    if (effort.slice(0, separator) !== provider)
+        return null;
+    const level = effort.slice(separator + 1);
+    return /^[a-z0-9][a-z0-9_-]{0,31}$/.test(level) ? level : null;
 }
 export function isStructuredRunnerForProvider(provider, runner) {
     if (provider === "claude")
@@ -48,20 +61,24 @@ export function normalizeThinkingEffort(value) {
     const normalized = value.trim().toLowerCase();
     if (normalized === "off" || normalized === "standard" || normalized === "deep" || normalized === "max")
         return normalized;
-    if (/^codex:[a-z0-9][a-z0-9_-]{0,31}$/.test(normalized))
+    if (NATIVE_THINKING_EFFORT.test(normalized))
         return normalized;
     return null;
 }
 export function thinkingEffortToSdkBudget(effort) {
-    if (effort === "standard")
+    const native = prefixedThinkingEffort("claude", effort) ?? effort;
+    if (native === "standard" || native === "low")
         return 4096;
-    if (effort === "deep")
+    if (native === "deep" || native === "medium" || native === "high")
         return 16000;
-    if (effort === "max")
+    if (native === "max" || native === "xhigh" || native === "ultra")
         return 31999;
     return 0;
 }
 export function thinkingEffortToClaudeCliEffort(effort) {
+    const native = prefixedThinkingEffort("claude", effort);
+    if (native)
+        return native;
     if (effort === "standard")
         return "low";
     if (effort === "deep")
@@ -74,8 +91,9 @@ export function thinkingEffortToClaudeSlashEffort(effort) {
     return thinkingEffortToClaudeCliEffort(effort) ?? "auto";
 }
 export function thinkingEffortToCodexReasoningEffort(effort) {
-    if (typeof effort === "string" && effort.startsWith("codex:"))
-        return effort.slice("codex:".length) || null;
+    const native = prefixedThinkingEffort("codex", effort);
+    if (native)
+        return native;
     if (effort === "standard")
         return "low";
     if (effort === "deep")
@@ -84,11 +102,36 @@ export function thinkingEffortToCodexReasoningEffort(effort) {
         return "xhigh";
     return null;
 }
+function thinkingEffortToNamedLevels(provider, effort, legacy) {
+    const native = prefixedThinkingEffort(provider, effort);
+    if (native)
+        return native;
+    if (!effort || effort === "off")
+        return null;
+    if (effort === "standard")
+        return legacy.standard;
+    if (effort === "deep")
+        return legacy.deep;
+    if (effort === "max")
+        return legacy.max;
+    return null;
+}
+/** OpenCode `--variant`。旧四档仍是 low/high/max；`opencode:<level>` 原样传递。 */
+export function thinkingEffortToOpenCodeVariant(effort) {
+    return thinkingEffortToNamedLevels("opencode", effort, { standard: "low", deep: "high", max: "max" });
+}
+/** Qoder `--reasoning-effort`。旧四档仍是 low/high/max；`qoder:<level>` 原样传递。 */
+export function thinkingEffortToQoderEffort(effort) {
+    return thinkingEffortToNamedLevels("qoder", effort, { standard: "low", deep: "high", max: "max" });
+}
 /**
- * OpenCode / Grok / Qoder 三家共用同一套 effort 级别（off/standard/deep/max →
- * null/low/high/max），`codex:<level>` 透传 level。
+ * Grok `--effort`。当前 CLI 接受 xhigh/high/medium/low，不接受 `max`，
+ * 所以旧的「最大」和误存的 `grok:max` 都落到 xhigh。
  */
-function thinkingEffortToLowHighMax(effort) {
+export function thinkingEffortToGrokEffort(effort) {
+    const native = prefixedThinkingEffort("grok", effort);
+    if (native)
+        return native === "max" ? "xhigh" : native;
     if (!effort || effort === "off")
         return null;
     if (effort === "standard")
@@ -96,21 +139,20 @@ function thinkingEffortToLowHighMax(effort) {
     if (effort === "deep")
         return "high";
     if (effort === "max")
-        return "max";
-    return effort.startsWith("codex:") ? effort.slice("codex:".length) || null : null;
+        return "xhigh";
+    return null;
 }
-export const thinkingEffortToOpenCodeVariant = thinkingEffortToLowHighMax;
-export const thinkingEffortToGrokEffort = thinkingEffortToLowHighMax;
-export const thinkingEffortToQoderEffort = thinkingEffortToLowHighMax;
 export function thinkingEffortToPiLevel(effort) {
+    const native = prefixedThinkingEffort("pi", effort);
+    if (native)
+        return native;
     if (!effort || effort === "off")
         return "off";
     if (effort === "standard")
         return "low";
     if (effort === "deep")
         return "high";
-    // Pi uses `max`; `xhigh` is a Codex-only level and makes Pi reject the run.
     if (effort === "max")
         return "max";
-    return effort.startsWith("codex:") ? effort.slice("codex:".length) || null : null;
+    return null;
 }

package/dist/task-types.d.ts

@@ -7,7 +7,8 @@ export declare const DEFAULT_WAND_TASK_PRIORITY: WandTaskPriority;
 /** 任务派发时选择的 CLI 工具；空串表示尚未指定。 */
 export type WandTaskAgentProvider = "claude" | "codex" | "opencode" | "grok" | "qoder" | "pi";
 export type WandTaskAgentModel = string;
-export type WandTaskAgentEffort = "off" | "standard" | "deep" | "max";
+/** 与会话思考档位同一套：旧四档，或 `provider:level` 原生档。 */
+export type WandTaskAgentEffort = "off" | "standard" | "deep" | "max" | `${WandTaskAgentProvider}:${string}`;
 /**
  * 派发时的执行模式，只暴露三种：
  *   - managed：托管，自动确认全部权限并使用完全自主提示词；

package/dist/terminal-daemon-server.js

@@ -493,14 +493,28 @@ export async function runTerminalDaemon(configPath) {
         for (const client of clients)
             client.socket.destroy();
         server.close(() => process.exit(0));
-        cleanupDaemonFiles(paths.socketPath, paths.tokenPath, paths.pidPath);
+        cleanupDaemonFiles(paths, { token, pid: process.pid });
     };
     process.once("SIGINT", shutdown);
     process.once("SIGTERM", shutdown);
 }
-function cleanupDaemonFiles(socketPath, tokenPath, pidPath) {
-    for (const file of [socketPath, tokenPath, pidPath]) {
-        if (process.platform === "win32" && file === socketPath)
+/**
+ * 只清理**自己拥有**的 daemon 文件。
+ *
+ * 升级期/僵尸期可能有两个 daemon 指向同一个 config（老进程端点已被清理、新进程刚接上）：
+ * 老进程退出时无条件 unlink，会把新进程正在使用的 token/pid 一起删掉 —— 新 daemon 随即变成
+ * 「进程活着但凭据不见了」，所有终端永久断联。所以凭据按**内容**判归属，不是自己写的就不动。
+ * socket 仍然照删：它属于本进程的监听（真正被占时 bind 会 EADDRINUSE）。
+ */
+function cleanupDaemonFiles(paths, owner) {
+    if (process.platform !== "win32") {
+        try {
+            unlinkSync(paths.socketPath);
+        }
+        catch { /* already absent */ }
+    }
+    for (const file of [paths.tokenPath, paths.pidPath]) {
+        if (!fileHoldsValue(file, file === paths.tokenPath ? owner.token : String(owner.pid)))
             continue;
         try {
             unlinkSync(file);
@@ -508,6 +522,15 @@ function cleanupDaemonFiles(socketPath, tokenPath, pidPath) {
         catch { /* already absent */ }
     }
 }
+/** 文件内容是否还是本进程写进去的值（读不到/已被别人改写都算「不是自己的」）。 */
+function fileHoldsValue(filePath, expected) {
+    try {
+        return readFileSync(filePath, "utf8").trim() === expected;
+    }
+    catch {
+        return false;
+    }
+}
 export function readTerminalDaemonPid(configPath) {
     try {
         const value = Number(readFileSync(terminalDaemonPaths(configPath).pidPath, "utf8").trim());

package/dist/tui/commands.js

@@ -15,6 +15,10 @@ import { computeRelaunch } from "../relaunch.js";
 import { ensureDatabaseFile, resolveDatabasePath, WandStorage } from "../storage.js";
 import { getErrorMessage } from "../error-utils.js";
 import { readTerminalDaemonPid } from "../terminal-daemon-server.js";
+import { terminalDaemonPaths } from "../terminal-daemon-protocol.js";
+import { renderPaths } from "../render-protocol.js";
+import { resolveRenderBinaryPath } from "../render-binary.js";
+import { compareSemver } from "../version-utils.js";
 import { isPidAlive } from "../pidfile.js";
 // ─── 重启 ────────────────────────────────────────────────────────────────
 /**
@@ -232,13 +236,49 @@ export function serviceLogs(lines = 80, opts) {
         return { ok: false, message: "journalctl 调用失败", detail: r.stderr.trim() || `exit ${r.status}` };
     }
     if (process.platform === "darwin") {
-        return {
-            ok: false,
-            message: "launchd 不直接写日志，请用 Console.app 或在 plist 里配置 StandardOutPath",
-        };
+        // plist 里配了 StandardOutPath/StandardErrorPath（见 installLaunchdService）。
+        // 老安装没有这两项，退回到 Console.app 的提示。
+        const configDir = readLaunchdConfigDir(scope);
+        if (!configDir) {
+            return {
+                ok: false,
+                message: "launchd 不直接写日志，请用 Console.app 或在 plist 里配置 StandardOutPath",
+            };
+        }
+        const sections = ["web.log", "web-error.log"]
+            .map((name) => ({ name, file: path.join(configDir, name) }))
+            .filter(({ file }) => existsSync(file))
+            .map(({ name, file }) => `--- ${name} ---\n${tailLines(file, lines)}`);
+        if (sections.length === 0) {
+            return {
+                ok: false,
+                message: `还没有日志文件（${configDir}/web.log、web-error.log）`,
+                detail: "重新跑一次 `wand service:install` 让 plist 带上 StandardOutPath/StandardErrorPath",
+            };
+        }
+        return { ok: true, message: `读取 ${configDir} 下的服务日志`, detail: sections.join("\n") };
     }
     return unsupported();
 }
+/** 从已安装的 plist 里读 config 路径（ProgramArguments 的第 5 项）；读不到返回 null。 */
+function readLaunchdConfigDir(scope) {
+    const plistPath = servicePathFor(scope);
+    if (!existsSync(plistPath))
+        return null;
+    const result = spawnSync("plutil", ["-extract", "ProgramArguments.4", "raw", "-o", "-", plistPath], { encoding: "utf8", timeout: 5_000 });
+    const configPath = result.status === 0 ? (result.stdout || "").trim() : "";
+    return configPath ? path.dirname(path.resolve(configPath)) : null;
+}
+/** 文件末尾 N 行（整个文件读进内存：服务日志本来就是小文件）。 */
+function tailLines(filePath, lines) {
+    try {
+        const all = readFileSync(filePath, "utf8").split("\n");
+        return all.slice(Math.max(0, all.length - lines)).join("\n").trim();
+    }
+    catch (error) {
+        return `读取失败：${getErrorMessage(error)}`;
+    }
+}
 /** systemctl 调用根据 scope 决定要不要 --user。system scope 也意味着调用方需要 root。 */
 function systemctlBaseArgs(scope) {
     return scope === "user" ? ["--user"] : [];
@@ -607,6 +647,118 @@ function hasLiveTerminalDaemon(configPath) {
     const pid = readTerminalDaemonPid(configPath);
     return pid !== null && isPidAlive(pid);
 }
+/** 按 config 派生两套 daemon 的端点（socket 在 /tmp、pid 在 config 目录旁边）。 */
+function daemonEndpointStates(configPath) {
+    const render = renderPaths(configPath);
+    const terminal = terminalDaemonPaths(configPath);
+    return [
+        { label: "Render", pidPath: render.pidPath, socketPath: render.socketPath },
+        { label: "terminald", pidPath: terminal.pidPath, socketPath: terminal.socketPath },
+    ].map(({ label, pidPath, socketPath }) => {
+        const pid = readDaemonPidFile(pidPath);
+        return {
+            label,
+            pid,
+            pidAlive: pid !== null && isPidAlive(pid),
+            socketPath,
+            socketExists: existsSync(socketPath),
+        };
+    });
+}
+function readDaemonPidFile(pidPath) {
+    try {
+        const pid = Number(readFileSync(pidPath, "utf8").trim());
+        return Number.isSafeInteger(pid) && pid > 0 ? pid : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 清掉「进程活着但端点没了」的僵尸 daemon。
+ *
+ * 这种 daemon 对任何客户端都已不可达（`/tmp` 下的 socket 文件被临时目录清理器删掉，
+ * 它抱着一个已经无名的 inode），却会让 `wand web` 启动判定「pid 活着但 socket 不可用」
+ * 而拒绝启动 —— 表现是整个服务起不回来，只能人工 kill。
+ *
+ * 自愈版 daemon（Node/Rust 两侧都有 recovery）会在 1s 内 rebind，所以先等一会儿
+ * 复查，真的还是不可达才动手；杀掉后由服务（terminald 有 unit/plist，Render 由 Server
+ * 启动时拉起）重新起一份新进程。
+ */
+function reapZombieDaemons(configPath) {
+    const actions = [];
+    const suspects = daemonEndpointStates(configPath).filter((state) => state.pidAlive && !state.socketExists);
+    if (suspects.length === 0)
+        return actions;
+    // 给自愈看门狗一点时间：端点丢得比这里早得多的话，下一轮就直接判死。
+    sleepSync(1_500);
+    for (const state of daemonEndpointStates(configPath)) {
+        if (!state.pidAlive || state.socketExists)
+            continue;
+        try {
+            process.kill(state.pid, "SIGKILL");
+            actions.push(`${state.label} daemon pid ${state.pid} 进程活着但端点已丢失（${state.socketPath}），已清理`);
+        }
+        catch (error) {
+            actions.push(`${state.label} daemon pid ${state.pid} 清理失败：${getErrorMessage(error)}`);
+        }
+    }
+    return actions;
+}
+/**
+ * 「正在跑的 daemon 比装好的二进制旧」的提示（没有这种情形时返回 null）。
+ *
+ * npm 升级 / service:install 都不重启 daemon（那里可能挂着用户的 shell），所以升级完
+ * 很容易一直在跑旧代码 —— 2026-09-24 的终端全断就是这么来的（9/23 补的端点自愈
+ * 在 9/19 启的 terminald 里根本不存在）。service:install 的输出不带 --verbose 时
+ * 看不到 detail，所以这句拼进 message 里。
+ */
+function staleDaemonNote(configPath) {
+    const render = renderPaths(configPath);
+    const pid = readDaemonPidFile(render.pidPath);
+    if (pid === null || !isPidAlive(pid))
+        return null;
+    const daemonVersion = (() => {
+        try {
+            const meta = JSON.parse(readFileSync(render.metaPath, "utf8"));
+            return typeof meta.version === "string" && meta.version ? meta.version : null;
+        }
+        catch {
+            return null;
+        }
+    })();
+    const binaryPath = resolveRenderBinaryPath(configPath);
+    if (!binaryPath)
+        return null;
+    const binaryVersion = (() => {
+        try {
+            const sidecar = readFileSync(`${binaryPath}.version`, "utf8").trim();
+            if (/^\d+\.\d+\.\d+/.test(sidecar))
+                return sidecar;
+        }
+        catch { /* 没有 sidecar 就跑一次 --version */ }
+        const result = spawnSync(binaryPath, ["--version"], { encoding: "utf8", timeout: 5_000 });
+        const match = /(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.]+)?)/.exec(result.stdout ?? "");
+        return match?.[1] ?? null;
+    })();
+    if (!binaryVersion)
+        return null;
+    if (daemonVersion && compareSemver(daemonVersion, binaryVersion) >= 0)
+        return null;
+    const shown = daemonVersion ? `Render ${daemonVersion}` : "Render daemon";
+    return `；但 ${shown} 仍在跑（装好的二进制是 ${binaryVersion}），它要重启才会用上新代码：./start.sh --restart-daemons`;
+}
+/** daemon 端点状态摘要，给服务命令的 detail 用。 */
+function describeDaemonEndpoints(configPath) {
+    return daemonEndpointStates(configPath)
+        .map((state) => {
+        const pid = state.pid ?? "-";
+        const alive = state.pidAlive ? "alive" : "-";
+        const socket = state.socketExists ? "endpoint ok" : "endpoint MISSING";
+        return `  ${state.label}: pid ${pid} (${alive}), ${socket} ${state.socketPath}`;
+    })
+        .join("\n");
+}
 /** 读取已安装服务 unit / plist 的入口命令；未安装或平台不支持时返回 null。 */
 export function readServiceEntrypoint(scope) {
     const servicePath = servicePathFor(scope);
@@ -762,6 +914,9 @@ function readFileStat(targetPath) {
 function installSystemdService(ctx, scope) {
     const unitPath = servicePathFor(scope);
     const terminalUnitPath = terminalServicePathFor(scope);
+    // 先清掉会阻塞启动的僵尸 daemon（pid 活着但端点没了），否则下一步 `wand web` 会
+    // 因为「活着但 socket 不可用」直接拒绝启动。
+    const daemonNotes = reapZombieDaemons(ctx.configPath);
     const wandBin = resolveWandBin(ctx);
     const nodeBin = process.execPath;
     const nodeBinDir = path.dirname(nodeBin);
@@ -868,6 +1023,9 @@ function installSystemdService(ctx, scope) {
         `scope: ${scope}`,
         `unit: ${unitPath}`,
         `terminal unit: ${terminalUnitPath}`,
+        ...daemonNotes,
+        "daemons:",
+        describeDaemonEndpoints(ctx.configPath),
         `daemon-reload: ${reload.status === 0 ? "ok" : `failed (${reload.stderr.trim()})`}`,
         `terminal enable${terminalAlreadyLive ? " (kept existing daemon)" : " --now"}: ${enableTerminal.status === 0 ? "ok" : `failed (${enableTerminal.stderr.trim()})`}`,
         `enable --now: ${enable.status === 0 ? "ok" : `failed (${enable.stderr.trim()})`}`,
@@ -883,7 +1041,9 @@ function installSystemdService(ctx, scope) {
     }
     return {
         ok: true,
-        message: `已注册 systemd ${scope === "user" ? "用户" : "系统"}服务: ${unitPath}`,
+        message: `已注册 systemd ${scope === "user" ? "用户" : "系统"}服务: ${unitPath}` +
+            (daemonNotes.length > 0 ? `（已清理 ${daemonNotes.length} 个僵尸 daemon）` : "") +
+            (staleDaemonNote(ctx.configPath) ?? ""),
         detail,
     };
 }
@@ -917,6 +1077,8 @@ function uninstallSystemdService(scope) {
 function installLaunchdService(ctx, scope) {
     const plistPath = servicePathFor(scope);
     const terminalPlistPath = terminalServicePathFor(scope);
+    // 同 systemd：先例行清理僵尸 daemon，否则新起的 web 会因为端点缺失而拒绝启动。
+    const daemonNotes = reapZombieDaemons(ctx.configPath);
     const wandBin = resolveWandBin(ctx);
     const nodeBin = process.execPath;
     const nodeBinDir = path.dirname(nodeBin);
@@ -925,6 +1087,12 @@ function installLaunchdService(ctx, scope) {
     const runHome = scope === "system" ? homeForUser(runUser, fallbackHome) : fallbackHome;
     // 与 systemd 同理：launchd 默认 PATH 极简，spawn 出的 claude 会找不到。
     const servicePath = buildServicePath(nodeBinDir, runHome);
+    // launchd 默认把 stdout/stderr 丢进 /dev/null：线上出问题时连“daemon 活着但端点没了”
+    // 这种一行告警都看不到（只能靠 lsof / 系统日志反推）。写进 config 目录旁边，
+    // `wand service:logs` 直接读。
+    const configDir = path.dirname(path.resolve(ctx.configPath));
+    const logFields = (out, err) => `  <key>StandardOutPath</key><string>${path.join(configDir, out)}</string>\n` +
+        `  <key>StandardErrorPath</key><string>${path.join(configDir, err)}</string>\n`;
     const userNameField = scope === "system"
         ? `  <key>UserName</key><string>${runUser}</string>\n`
         : "";
@@ -949,7 +1117,7 @@ ${userNameField}  <key>WorkingDirectory</key><string>${runHome}</string>
     <key>HOME</key><string>${runHome}</string>
   </dict>
   <key>RunAtLoad</key><true/>
-  <key>KeepAlive</key><true/>
+${logFields("web.log", "web-error.log")}  <key>KeepAlive</key><true/>
 </dict>
 </plist>
 `;
@@ -973,12 +1141,13 @@ ${userNameField}  <key>WorkingDirectory</key><string>${runHome}</string>
     <key>HOME</key><string>${runHome}</string>
   </dict>
   <key>RunAtLoad</key><true/>
-  <key>KeepAlive</key><true/>
+${logFields("terminald.log", "terminald-error.log")}  <key>KeepAlive</key><true/>
 </dict>
 </plist>
 `;
     try {
         mkdirSync(path.dirname(plistPath), { recursive: true });
+        mkdirSync(configDir, { recursive: true });
         writeFileSync(terminalPlistPath, terminalPlist, "utf8");
         writeFileSync(plistPath, plist, "utf8");
     }
@@ -1023,8 +1192,12 @@ ${userNameField}  <key>WorkingDirectory</key><string>${runHome}</string>
     }
     return {
         ok: true,
-        message: `已注册 launchd ${scope === "user" ? "用户代理" : "系统守护"}: ${plistPath}`,
-        detail: [terminalDetail, started.detail].filter(Boolean).join("\n"),
+        message: `已注册 launchd ${scope === "user" ? "用户代理" : "系统守护"}: ${plistPath}` +
+            (daemonNotes.length > 0 ? `（已清理 ${daemonNotes.length} 个僵尸 daemon）` : "") +
+            (staleDaemonNote(ctx.configPath) ?? ""),
+        detail: [terminalDetail, started.detail, ...daemonNotes, "daemons:", describeDaemonEndpoints(ctx.configPath)]
+            .filter(Boolean)
+            .join("\n"),
     };
 }
 function uninstallLaunchdService(scope) {
@@ -1057,4 +1230,4 @@ function uninstallLaunchdService(scope) {
     };
 }
 // ─── 工具 ────────────────────────────────────────────────────────────────
-// compareSemver 已统一到 ../version-utils.ts
+// compareSemver 已统一到 ../version-utils.ts（上方已按需 import）

package/dist/types.d.ts

@@ -161,8 +161,12 @@ export interface WandConfig {
     commitModel?: string;
     /** 快捷提交生成 commit message / tag 时使用 CLI 或直连 API。 */
     commitAiSource?: CommitAiSource;
-    /** Wand 自身轻量 AI 功能与 Commit 直连模式复用的 API 配置。 */
+    /** Wand 自身轻量 AI 功能与 Commit 直连模式复用的 API 配置。enabled 表示系统 AI 优先使用 API。 */
     systemAi?: SystemAiConfig;
+    /** 系统 AI 使用 CLI 模式时的专用工具；未配置时沿用当前会话工具（兼容旧设置）。 */
+    systemAiCli?: SessionProvider;
+    /** 系统 AI 专用 CLI 模型；留空跟随该工具的新会话默认模型。 */
+    systemAiModel?: string;
     /** 新建会话时默认使用的思考深度。 */
     defaultThinkingEffort?: ThinkingEffort;
     /** 结构化会话使用的 runner: "cli"（默认，spawn claude -p）或 "sdk"（@anthropic-ai/claude-agent-sdk）。 */
@@ -222,10 +226,10 @@ interface ReasoningEffortInfo {
     description?: string;
 }
 /**
- * 旧的四档值需要继续兼容已有会话。Codex 动态档位加 provider 前缀，
- * 避免 `max`（旧值代表 xhigh）与 Codex 新增的原生 max 档位冲突。
+ * 旧的四档值需要继续兼容已有会话。CLI 动态档位加 provider 前缀，
+ * 避免 `max`（旧值，各家含义不同）和 CLI 新增的原生档位冲突。
  */
-export type ThinkingEffort = "off" | "standard" | "deep" | "max" | `codex:${string}`;
+export type ThinkingEffort = "off" | "standard" | "deep" | "max" | `${"claude" | "codex" | "opencode" | "grok" | "qoder" | "pi"}:${string}`;
 export interface WorktreeInfo {
     branch: string;
     path: string;
@@ -625,11 +629,9 @@ export interface SessionSnapshot {
     selectedModel?: string | null;
     /**
      * 用户选定的思考深度。
-     *   - off:      不覆盖默认思考深度（SDK: 不传 thinking；Claude CLI: auto/default；Codex: 使用模型默认值）
-     *   - standard: 标准（SDK: budget 4096；Claude CLI: low；Codex: low）
-     *   - deep:    深度（SDK: budget 16000；Claude CLI: medium；Codex: medium）
-     *   - max:     旧版最深档（SDK: budget 31999；Claude CLI: max；Codex: xhigh）
-     *   - codex:*: Codex CLI 动态声明的原生推理档位
+     *   - off:      不覆盖默认思考深度
+     *   - standard / deep / max: 旧四档，按各 CLI 当时的低、中、高档换算
+     *   - provider:level: 该 CLI 自己报出来的原生档位，原样传给对应 flag
      */
     thinkingEffort?: ThinkingEffort | null;
     /** 当前 PTY 列宽，由最近一次 resize 决定。前端用它来判断本端 fit 是否需要校准。 */

package/dist/wand-task-sync.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { getErrorMessage } from "./error-utils.js";
 import { provisionalTaskTitleFromDescription } from "./task-title.js";
 import { isSessionProvider } from "./session-provider.js";
+import { isThinkingEffort } from "./structured-provider-common.js";
 import { isClosedWandTaskStatus, normalizeWandTaskAgentMode } from "./task-types.js";
 import { firstLayoutTabId } from "./layout-tree.js";
 /** 未命名任务的占位名；服务端新建时写入，自动命名成功后被真实标题覆盖。 */
@@ -97,7 +98,7 @@ function agentFromSession(session) {
     return {
         provider: session.provider,
         model: session.selectedModel || session.structuredState?.model || "default",
-        thinkingEffort: effort === "standard" || effort === "deep" || effort === "max" ? effort : "off",
+        thinkingEffort: isThinkingEffort(effort) ? effort : "off",
         mode: normalizeWandTaskAgentMode(session.provider, session.mode),
         // 会话形态按会话自身的 sessionKind 还原，PTY 会话不会在「再指派」时被误当结构化。
         kind: (session.sessionKind ?? "pty") === "structured" ? "structured" : "pty",