@co0ontty/wand 1.30.0 → 1.31.0

package/README.md

@@ -21,12 +21,23 @@
 bash <(curl -Ls https://raw.githubusercontent.com/co0ontty/wand/master/install.sh)
 ```
 
+装完后脚本会询问：
+
+- **1) 装为系统服务（推荐，默认）** — 写入 system-wide systemd（`/etc/systemd/system/wand.service`）或 launchd LaunchDaemon（`/Library/LaunchDaemons/com.wand.web.plist`），后台运行、开机自启、崩了自重启。**需要 sudo**（脚本会自动加）。
+- **2) 单次启动** — 不装服务，之后手动跑 `wand web`。
+
+> 通过管道运行（`bash <(curl ...)`）时 stdin 不是终端，默认走 **1（系统服务）**。想强制单次启动可以 `WAND_INSTALL_MODE=oneshot bash install.sh`。
+>
+> 不想用 sudo？可以装 user-level 版本：`wand service:install --user`（写入 `~/.config/systemd/user/wand.service`，登出会被回收，除非 `loginctl enable-linger $USER`）。
+
 ### 手动安装
 
 ```bash
 npm install -g @co0ontty/wand
 wand init
-wand web
+sudo wand service:install   # 装为系统服务（system-wide, 默认）
+# 或者：wand service:install --user   # 不要 sudo，但登出会被回收
+wand web                    # 没服务时启动新实例；有服务时 attach TUI
 ```
 
 安装完成后打开浏览器访问终端中提示的地址即可。
@@ -41,7 +52,7 @@ bash <(curl -Ls https://raw.githubusercontent.com/co0ontty/wand/master/install.s
 
 > 也可以直接在网页设置里点「更新」按钮，或在 TUI 模式按 `u`，wand 自己会调用同样的清理逻辑。Web 端点击更新后会自动重启服务，无需手动操作。
 
-如果以前装过 systemd 自启服务但还是 `Restart=on-failure`（v1.25.x 前的版本），重新进入 TUI 按一次 `i` 重装服务即可换成 `Restart=always`，自动更新后才能正确拉起新进程。
+如果以前装过 systemd 自启服务但还是 `Restart=on-failure`（v1.25.x 前的版本），重新跑 `sudo wand service:install` 重装服务即可换成 `Restart=always`，自动更新后才能正确拉起新进程。
 
 ## 功能
 
@@ -101,6 +112,32 @@ wand config:set port 9443
 | `password` | (随机生成) | 登录密码 |
 | `language` | `""` | Claude 回复语言偏好 |
 
+## 系统服务
+
+默认走 **system-wide**：Linux 写 `/etc/systemd/system/wand.service`，macOS 写 `/Library/LaunchDaemons/com.wand.web.plist`。开机自启、不依赖 login session、`service wand` / `systemctl status wand` 这些老命令都能用。装/卸需要 sudo。
+
+```bash
+sudo wand service:install   # 注册并启动（首次安装走这里）
+wand service:status         # 查状态（active / inactive / failed） — 读取不要 sudo
+sudo wand service:start     # 启动
+sudo wand service:stop      # 停止
+sudo wand service:restart   # 重启
+wand service:logs           # 看最近日志（--lines N 调整行数）
+sudo wand service:uninstall # 卸载（停服 + 删 unit）
+```
+
+不想用 sudo？传 `--user` 切到 user-level（写 `~/.config/systemd/user/wand.service` 或 `~/Library/LaunchAgents/`）：
+
+```bash
+wand service:install --user
+wand service:status --user
+# ...其他子命令同理
+```
+
+> User-level 版本登出后会被回收，除非跑 `loginctl enable-linger $USER`。
+
+服务装好后，`wand web` 会自动检测正在运行的实例（同一份 `config.json` 下）并以 TUI 模式 **attach 到现有 service**，不会重复启动第二个进程。多份配置（`-c` 指向不同路径）之间彼此隔离，互不影响。
+
 ## 开发
 
 ```bash

package/dist/claude-sdk-runner.d.ts

@@ -0,0 +1,31 @@
+export type ClaudeRunErrorCode = "CLAUDE_CLI_MISSING" | "CLAUDE_TIMEOUT" | "CLAUDE_CLI_FAILED" | "CLAUDE_EMPTY_RESULT";
+export declare class ClaudeRunError extends Error {
+    readonly code: ClaudeRunErrorCode;
+    constructor(message: string, code: ClaudeRunErrorCode);
+}
+export interface RunClaudePrintOptions {
+    cwd?: string;
+    timeoutMs: number;
+}
+/**
+ * 用 `@anthropic-ai/claude-agent-sdk` 跑一次"prompt → 单段纯文本"调用，
+ * 等价以前的 `claude -p --output-format text`。
+ *
+ * 行为对齐 Claude Code 默认：
+ *   - 不指定 model / appendSystemPrompt / agent / mcpServers / hooks 等覆盖项，
+ *     完全由 `~/.claude/settings.json`、OAuth 凭据、`CLAUDE_*` 环境变量等
+ *     用户侧配置接管，与 Claude Code 自身一致。
+ *   - `tools: []` 关掉所有内置工具：这两个调用点（commit message / prompt 优化）
+ *     本质就是"纯文本生成"，关掉工具能 (1) 防止 Claude 随手开个工具卡住权限询问；
+ *     (2) 避免一次性短调用还顺便加载文件 / 跑 bash 这种副作用。
+ *   - `persistSession: false`：这些 ephemeral 调用不应该污染 `~/.claude/projects/`
+ *     的会话历史；用户在 wand UI 里也压根看不到这些"虚拟会话"。
+ *
+ * 选择 SDK 而非以前的 `execFile("claude")`：
+ *   - SDK 包内置各平台 native binary，`pathToClaudeCodeExecutable` 直接指到
+ *     `node_modules` 里，**零** PATH 依赖。systemd / launchd / 双击图标启动
+ *     wand server 时不会再因为 PATH 缺 nvm/npm-global 而报"未找到 claude CLI"。
+ *   - 与现有 `structured-session-manager.ts` 的 SDK 调用路径同源，行为/认证/
+ *     更新策略统一。
+ */
+export declare function runClaudePrint(prompt: string, options: RunClaudePrintOptions): Promise<string>;

package/dist/claude-sdk-runner.js

@@ -0,0 +1,142 @@
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { query as sdkQuery, } from "@anthropic-ai/claude-agent-sdk";
+export class ClaudeRunError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "ClaudeRunError";
+    }
+}
+/**
+ * 判断当前 Linux 是否是 musl 系（Alpine 等）。glibc 系跑不动 musl native binary，
+ * 反之亦然，SDK 默认的优先级与本机不匹配时会抛 "Claude Code native binary not found"。
+ */
+function isMuslSystem() {
+    try {
+        const header = process.report?.getReport()?.header;
+        return !header?.glibcVersionRuntime;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 把 SDK 应使用的 native claude binary 路径解析出来。逻辑与
+ * `structured-session-manager.ts` 的 `resolveSdkClaudeBinary` 保持一致。
+ */
+function resolveSdkClaudeBinary() {
+    if (process.platform !== "linux")
+        return undefined;
+    const musl = isMuslSystem();
+    const arch = process.arch;
+    const require = createRequire(import.meta.url);
+    const candidates = musl
+        ? [
+            `@anthropic-ai/claude-agent-sdk-linux-${arch}-musl/claude`,
+            `@anthropic-ai/claude-agent-sdk-linux-${arch}/claude`,
+        ]
+        : [
+            `@anthropic-ai/claude-agent-sdk-linux-${arch}/claude`,
+            `@anthropic-ai/claude-agent-sdk-linux-${arch}-musl/claude`,
+        ];
+    for (const pkg of candidates) {
+        try {
+            const resolved = require.resolve(pkg);
+            if (existsSync(resolved))
+                return resolved;
+        }
+        catch {
+            // 包不存在，尝试下一个
+        }
+    }
+    return undefined;
+}
+/**
+ * 用 `@anthropic-ai/claude-agent-sdk` 跑一次"prompt → 单段纯文本"调用，
+ * 等价以前的 `claude -p --output-format text`。
+ *
+ * 行为对齐 Claude Code 默认：
+ *   - 不指定 model / appendSystemPrompt / agent / mcpServers / hooks 等覆盖项，
+ *     完全由 `~/.claude/settings.json`、OAuth 凭据、`CLAUDE_*` 环境变量等
+ *     用户侧配置接管，与 Claude Code 自身一致。
+ *   - `tools: []` 关掉所有内置工具：这两个调用点（commit message / prompt 优化）
+ *     本质就是"纯文本生成"，关掉工具能 (1) 防止 Claude 随手开个工具卡住权限询问；
+ *     (2) 避免一次性短调用还顺便加载文件 / 跑 bash 这种副作用。
+ *   - `persistSession: false`：这些 ephemeral 调用不应该污染 `~/.claude/projects/`
+ *     的会话历史；用户在 wand UI 里也压根看不到这些"虚拟会话"。
+ *
+ * 选择 SDK 而非以前的 `execFile("claude")`：
+ *   - SDK 包内置各平台 native binary，`pathToClaudeCodeExecutable` 直接指到
+ *     `node_modules` 里，**零** PATH 依赖。systemd / launchd / 双击图标启动
+ *     wand server 时不会再因为 PATH 缺 nvm/npm-global 而报"未找到 claude CLI"。
+ *   - 与现有 `structured-session-manager.ts` 的 SDK 调用路径同源，行为/认证/
+ *     更新策略统一。
+ */
+export async function runClaudePrint(prompt, options) {
+    const cwd = options.cwd && options.cwd.length > 0 ? options.cwd : undefined;
+    const abortController = new AbortController();
+    const timeoutHandle = setTimeout(() => abortController.abort(), options.timeoutMs);
+    const sdkClaudeBinary = resolveSdkClaudeBinary();
+    const sdkOptions = {
+        abortController,
+        tools: [],
+        persistSession: false,
+        ...(cwd ? { cwd } : {}),
+        ...(sdkClaudeBinary ? { pathToClaudeCodeExecutable: sdkClaudeBinary } : {}),
+    };
+    // 单条 user message → AsyncGenerator，SDK 的 streaming input 协议要求。
+    async function* singleShot() {
+        yield {
+            type: "user",
+            message: {
+                role: "user",
+                content: [{ type: "text", text: prompt }],
+            },
+            parent_tool_use_id: null,
+        };
+    }
+    let resultText = "";
+    let resultError = null;
+    try {
+        for await (const msg of sdkQuery({
+            prompt: singleShot(),
+            options: sdkOptions,
+        })) {
+            if (msg.type !== "result")
+                continue;
+            if (msg.subtype === "success" && typeof msg.result === "string") {
+                resultText = msg.result.trim();
+            }
+            else {
+                const errs = Array.isArray(msg.errors)
+                    ? msg.errors.join("; ")
+                    : msg.subtype;
+                resultError = new ClaudeRunError(`Claude SDK 失败：${errs}`, "CLAUDE_CLI_FAILED");
+            }
+            break; // 一次性调用，拿到 result 即退出
+        }
+    }
+    catch (err) {
+        if (abortController.signal.aborted) {
+            throw new ClaudeRunError("Claude 调用超时。", "CLAUDE_TIMEOUT");
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        // SDK 找不到 native binary 时会抛 "Claude Code native binary not found"。
+        // 极少数情况下也可能透出 ENOENT。两种都归到"CLI_MISSING"，文案给用户。
+        if (/Claude Code native binary not found|ENOENT/i.test(message)) {
+            throw new ClaudeRunError("未找到 claude CLI。", "CLAUDE_CLI_MISSING");
+        }
+        throw new ClaudeRunError(`Claude SDK 失败：${message}`, "CLAUDE_CLI_FAILED");
+    }
+    finally {
+        clearTimeout(timeoutHandle);
+    }
+    if (resultError)
+        throw resultError;
+    if (!resultText) {
+        throw new ClaudeRunError("Claude 返回了空结果。", "CLAUDE_EMPTY_RESULT");
+    }
+    return resultText;
+}

package/dist/cli.js

@@ -136,6 +136,17 @@ async function main() {
             }
             break;
         }
+        case "service:install":
+        case "service:uninstall":
+        case "service:start":
+        case "service:stop":
+        case "service:restart":
+        case "service:status":
+        case "service:logs": {
+            const exitCode = await runServiceCommand(command, args, configPath);
+            process.exitCode = exitCode;
+            break;
+        }
         case "help":
         default: {
             printHelp();
@@ -160,8 +171,21 @@ Commands:
   wand config:show          Print current config
   wand config:set           Update a simple config value
 
+System service (default = system-wide; pass --user for user-level):
+  wand service:install      Register and start the background service (needs sudo for system)
+  wand service:uninstall    Stop and remove the service
+  wand service:start        Start the service
+  wand service:stop         Stop the service
+  wand service:restart      Restart the service
+  wand service:status       Show service status
+  wand service:logs         Tail recent service logs
+
 Options:
   -c, --config <path>       Use a custom config file (default: ~/.wand/config.json)
+  --user                    (service:*) Operate on the user-level service (no root needed)
+  --system                  (service:*) Operate on the system-wide service (default; needs root)
+  --verbose                 (service:*) Print full detail output
+  --lines <N>               (service:logs) Number of log lines (default 80)
 `);
 }
 async function ensureRequiredFiles(configPath, opts = {}) {
@@ -341,6 +365,86 @@ function setConfigValue(config, key, value) {
             throw new Error(`Unsupported config key: ${key}`);
     }
 }
+/**
+ * 把 `wand service:*` 子命令路由到 src/tui/commands.ts 里已有的服务管理实现。
+ *
+ * 这里只做：把 CLI args → ServiceContext，调对应函数，把 CommandResult 打印出来，
+ * 按 ok 决定 exit code。所有平台分支（Linux user-systemd / macOS launchd / 其他不支持）
+ * 都在 tui/commands.ts 内部处理。
+ */
+async function runServiceCommand(command, args, configPath) {
+    const { installService, uninstallService, serviceStart, serviceStop, serviceRestart, serviceStatus, serviceLogs, } = await import("./tui/commands.js");
+    const verbose = args.includes("--verbose");
+    // --user / --system 决定 scope；不传走库里 default（= system）。
+    // 同时传 --user 和 --system 时 --user 胜（更"友好"那一个不需要 root）。
+    const wantUser = args.includes("--user");
+    const wantSystem = args.includes("--system");
+    const scope = wantUser ? "user" : (wantSystem ? "system" : undefined);
+    switch (command) {
+        case "service:install": {
+            const result = installService({ configPath, scope });
+            printServiceResult(result, verbose);
+            if (result.ok && process.platform === "linux") {
+                // 仅 user scope 才需要 linger 提示
+                const installedScope = scope ?? "system";
+                if (installedScope === "user") {
+                    process.stdout.write("[wand] 想保持登出后也运行：loginctl enable-linger $USER\n");
+                }
+            }
+            return result.ok ? 0 : 1;
+        }
+        case "service:uninstall": {
+            const result = uninstallService(scope ? { scope } : undefined);
+            printServiceResult(result, verbose);
+            return result.ok ? 0 : 1;
+        }
+        case "service:start": {
+            const result = serviceStart(scope ? { scope } : undefined);
+            printServiceResult(result, verbose);
+            return result.ok ? 0 : 1;
+        }
+        case "service:stop": {
+            const result = serviceStop(scope ? { scope } : undefined);
+            printServiceResult(result, verbose);
+            return result.ok ? 0 : 1;
+        }
+        case "service:restart": {
+            const result = serviceRestart(scope ? { scope } : undefined);
+            printServiceResult(result, verbose);
+            return result.ok ? 0 : 1;
+        }
+        case "service:status": {
+            const status = serviceStatus(scope ? { scope } : undefined);
+            process.stdout.write(`[wand] ${status.installed ? "installed" : "not installed"} · ${status.state} · ${status.description}\n`);
+            if (verbose && status.raw) {
+                process.stdout.write(status.raw + "\n");
+            }
+            return status.installed && status.state === "active" ? 0 : 1;
+        }
+        case "service:logs": {
+            const linesArg = readFlagValue(args, "--lines");
+            const lines = linesArg ? Math.max(1, Math.min(2000, Number(linesArg) || 80)) : 80;
+            const result = serviceLogs(lines, scope ? { scope } : undefined);
+            if (result.detail) {
+                process.stdout.write(result.detail + "\n");
+            }
+            else {
+                process.stdout.write(`[wand] ${result.message}\n`);
+            }
+            return result.ok ? 0 : 1;
+        }
+        default:
+            process.stderr.write(`[wand] unknown service command: ${command}\n`);
+            return 1;
+    }
+}
+function printServiceResult(result, verbose) {
+    const prefix = result.ok ? "[wand]" : "[wand] ✗";
+    process.stdout.write(`${prefix} ${result.message}\n`);
+    if (verbose && result.detail) {
+        process.stdout.write(result.detail + "\n");
+    }
+}
 main().catch((error) => {
     process.stderr.write(`[wand] ${error instanceof Error ? error.message : String(error)}\n`);
     process.exitCode = 1;

package/dist/git-quick-commit.js

@@ -1,5 +1,6 @@
-import { execFile, execFileSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import { existsSync } from "node:fs";
+import { ClaudeRunError, runClaudePrint } from "./claude-sdk-runner.js";
 const GIT_TIMEOUT_MS = 1500;
 const GIT_PUSH_TIMEOUT_MS = 30_000;
 const MAX_FILE_ENTRIES = 200;
@@ -239,32 +240,23 @@ export class QuickCommitError extends Error {
     }
 }
 // ── AI commit message generation ──
-function callClaudeText(prompt, cwd) {
-    return new Promise((resolve, reject) => {
-        const child = execFile("claude", ["-p", "--output-format", "text"], {
-            cwd,
-            encoding: "utf8",
-            maxBuffer: 4 * 1024 * 1024,
-            timeout: CLAUDE_MESSAGE_TIMEOUT_MS,
-        }, (error, stdout, stderr) => {
-            if (error) {
-                const e = error;
-                if (e.code === "ENOENT") {
-                    reject(new QuickCommitError("未找到 claude CLI。", "CLAUDE_CLI_MISSING"));
-                    return;
-                }
-                if (e.code === "ETIMEDOUT") {
-                    reject(new QuickCommitError("Claude 生成超时，请手动填写 commit message。", "CLAUDE_TIMEOUT"));
-                    return;
-                }
-                const msg = (stderr || "").trim() || e.message || "claude 调用失败";
-                reject(new QuickCommitError(`Claude CLI 失败：${msg}`, "CLAUDE_CLI_FAILED"));
-                return;
+async function callClaudeText(prompt, cwd) {
+    try {
+        return await runClaudePrint(prompt, { cwd, timeoutMs: CLAUDE_MESSAGE_TIMEOUT_MS });
+    }
+    catch (error) {
+        if (error instanceof ClaudeRunError) {
+            // 把通用 ClaudeRunError 翻译成 quick-commit 自己的错误码 + 中文话术。
+            if (error.code === "CLAUDE_TIMEOUT") {
+                throw new QuickCommitError("Claude 生成超时，请手动填写 commit message。", "CLAUDE_TIMEOUT");
             }
-            resolve((stdout || "").trim());
-        });
-        child.stdin?.end(prompt);
-    });
+            if (error.code === "CLAUDE_EMPTY_RESULT") {
+                throw new QuickCommitError("Claude 返回了空的 commit message。", "EMPTY_AI_MESSAGE");
+            }
+            throw new QuickCommitError(error.message, error.code);
+        }
+        throw error;
+    }
 }
 function collectStagedDiff(cwd) {
     let diff;

package/dist/process-manager.d.ts

@@ -52,6 +52,7 @@ export declare class ProcessManager extends EventEmitter {
         reuseId?: string;
         cols?: number;
         rows?: number;
+        thinkingEffort?: SessionSnapshot["thinkingEffort"];
     }): SessionSnapshot;
     list(): SessionSnapshot[];
     /** Return lightweight snapshots for the session list (no output/messages). */
@@ -72,6 +73,12 @@ export declare class ProcessManager extends EventEmitter {
      * the PTY so Claude Code switches on the fly.
      */
     setSessionModel(id: string, model: string | null): SessionSnapshot;
+    /**
+     * Set the thinking-effort level for a PTY session. For interactive Claude PTY
+     * we don't intercept raw key input; the effort is applied only when wand UI
+     * sends a chat-view message (see sendInput → applyThinkingEffortToPrompt).
+     */
+    setSessionThinkingEffort(id: string, effort: SessionSnapshot["thinkingEffort"]): SessionSnapshot;
     sendInput(id: string, input: string, view?: "chat" | "terminal", shortcutKey?: string): SessionSnapshot;
     /** Emit a task event for a session, debounced to avoid flooding */
     private emitTask;

package/dist/process-manager.js

@@ -12,6 +12,7 @@ import { appendWindow, hasExplicitConfirmSyntax, hasPermissionActionContext, nor
 import { buildChildEnv } from "./env-utils.js";
 import { prepareSessionWorktree } from "./git-worktree.js";
 import { getResumeCommandSessionId } from "./resume-policy.js";
+import { applyThinkingEffortToPrompt, normalizeThinkingEffort } from "./structured-session-manager.js";
 function resolveProviderFromCommand(command) {
     return /^codex\b/.test(command.trim()) ? "codex" : "claude";
 }
@@ -634,6 +635,7 @@ export class ProcessManager extends EventEmitter {
             knownClaudeProjectMtimes: knownClaudeProjectMtimes ?? undefined,
             approvalStats: { tool: 0, command: 0, file: 0, total: 0 },
             selectedModel: selectedModel ?? null,
+            thinkingEffort: normalizeThinkingEffort(opts?.thinkingEffort),
             // cols 上限 256：与 @wterm/dom WASM grid 的 maxCols 硬编码一致，
             // 防止服务端按 >256 cols 让 Claude 用 CSI 绝对列定位写到 wterm 实际
             // 渲染不到的列上（表现为"内容神奇复制下行"）。
@@ -926,6 +928,19 @@ export class ProcessManager extends EventEmitter {
         this.emitEvent({ type: "status", sessionId: id, data: { selectedModel: normalized } });
         return this.snapshot(record);
     }
+    /**
+     * Set the thinking-effort level for a PTY session. For interactive Claude PTY
+     * we don't intercept raw key input; the effort is applied only when wand UI
+     * sends a chat-view message (see sendInput → applyThinkingEffortToPrompt).
+     */
+    setSessionThinkingEffort(id, effort) {
+        const record = this.mustGet(id);
+        const normalized = normalizeThinkingEffort(effort);
+        record.thinkingEffort = normalized;
+        this.persist(record);
+        this.emitEvent({ type: "status", sessionId: id, data: { thinkingEffort: normalized } });
+        return this.snapshot(record);
+    }
     sendInput(id, input, view, shortcutKey) {
         const record = this.mustGet(id);
         if (record.status !== "running") {
@@ -949,11 +964,19 @@ export class ProcessManager extends EventEmitter {
             };
             this.logger.appendShortcutLog(id, shortcutKey, tailLines, ctx);
         }
+        // Thinking-depth magic-word injection. Only applied to chat-view submits
+        // (terminal direct keystrokes are pass-through). applyThinkingEffortToPrompt
+        // is safe on empty / lone-\r chunks (returns input unchanged) and won't
+        // double-prefix if the user already wrote the magic word themselves.
+        let effectiveInput = input;
+        if (view === "chat" && record.thinkingEffort && record.thinkingEffort !== "off") {
+            effectiveInput = applyThinkingEffortToPrompt(input, record.thinkingEffort);
+        }
         // Track user input via bridge for Chat mode
         if (record.ptyBridge) {
-            record.ptyBridge.onUserInput(input);
+            record.ptyBridge.onUserInput(effectiveInput);
         }
-        record.ptyProcess.write(input);
+        record.ptyProcess.write(effectiveInput);
         this.persist(record);
         return this.snapshot(record);
     }
@@ -1203,6 +1226,7 @@ export class ProcessManager extends EventEmitter {
             summary: deriveSessionSummary(messages, record.currentTask?.title ?? null),
             currentTaskTitle: record.status === "running" ? record.currentTask?.title ?? undefined : undefined,
             selectedModel: record.selectedModel ?? null,
+            thinkingEffort: record.thinkingEffort ?? null,
             ptyCols: record.ptyCols,
             ptyRows: record.ptyRows,
         };

package/dist/prompt-optimizer.js

@@ -1,4 +1,4 @@
-import { execFile } from "node:child_process";
+import { ClaudeRunError, runClaudePrint } from "./claude-sdk-runner.js";
 const CLAUDE_TIMEOUT_MS = 60_000;
 const MAX_INPUT_LENGTH = 8000;
 export class PromptOptimizeError extends Error {
@@ -9,32 +9,23 @@ export class PromptOptimizeError extends Error {
         this.name = "PromptOptimizeError";
     }
 }
-function callClaudeText(prompt, cwd) {
-    return new Promise((resolve, reject) => {
-        const child = execFile("claude", ["-p", "--output-format", "text"], {
-            cwd: cwd && cwd.length > 0 ? cwd : undefined,
-            encoding: "utf8",
-            maxBuffer: 4 * 1024 * 1024,
-            timeout: CLAUDE_TIMEOUT_MS,
-        }, (error, stdout, stderr) => {
-            if (error) {
-                const e = error;
-                if (e.code === "ENOENT") {
-                    reject(new PromptOptimizeError("未找到 claude CLI。", "CLAUDE_CLI_MISSING"));
-                    return;
-                }
-                if (e.code === "ETIMEDOUT") {
-                    reject(new PromptOptimizeError("Claude 优化超时，请稍后重试。", "CLAUDE_TIMEOUT"));
-                    return;
-                }
-                const msg = (stderr || "").trim() || e.message || "claude 调用失败";
-                reject(new PromptOptimizeError(`Claude CLI 失败：${msg}`, "CLAUDE_CLI_FAILED"));
-                return;
+async function callClaudeText(prompt, cwd) {
+    try {
+        return await runClaudePrint(prompt, { cwd, timeoutMs: CLAUDE_TIMEOUT_MS });
+    }
+    catch (error) {
+        if (error instanceof ClaudeRunError) {
+            // 翻译成 prompt-optimizer 自己的话术 + 错误码（与原文案保持一致）。
+            if (error.code === "CLAUDE_TIMEOUT") {
+                throw new PromptOptimizeError("Claude 优化超时，请稍后重试。", "CLAUDE_TIMEOUT");
+            }
+            if (error.code === "CLAUDE_EMPTY_RESULT") {
+                throw new PromptOptimizeError("Claude 返回了空结果。", "EMPTY_RESULT");
             }
-            resolve((stdout || "").trim());
-        });
-        child.stdin?.end(prompt);
-    });
+            throw new PromptOptimizeError(error.message, error.code);
+        }
+        throw error;
+    }
 }
 function buildOptimizePrompt(userInput, language) {
     const lang = (language || "").trim() || "中文";

package/dist/server-session-routes.js

@@ -144,7 +144,7 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
     });
     app.post("/api/structured-sessions", express.json(), async (req, res) => {
         const body = req.body;
-        console.log("[WAND] POST /api/structured-sessions body:", JSON.stringify({ cwd: body.cwd, mode: body.mode, runner: body.runner, provider: body.provider, worktreeEnabled: body.worktreeEnabled === true, hasPrompt: !!body.prompt, model: body.model }));
+        console.log("[WAND] POST /api/structured-sessions body:", JSON.stringify({ cwd: body.cwd, mode: body.mode, runner: body.runner, provider: body.provider, worktreeEnabled: body.worktreeEnabled === true, hasPrompt: !!body.prompt, model: body.model, thinkingEffort: body.thinkingEffort }));
         try {
             if (body.provider && body.provider !== "claude" && body.provider !== "codex") {
                 res.status(400).json({ error: "结构化会话当前仅支持 Claude 或 Codex provider。" });
@@ -158,6 +158,9 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
                 runner: body.runner ?? (provider === "codex" ? "codex-cli-exec" : "claude-cli-print"),
                 worktreeEnabled: body.worktreeEnabled === true,
                 model: typeof body.model === "string" ? body.model.trim() : undefined,
+                thinkingEffort: typeof body.thinkingEffort === "string"
+                    ? body.thinkingEffort
+                    : undefined,
             });
             console.log("[WAND] structured session created:", JSON.stringify({ id: snapshot.id, sessionKind: snapshot.sessionKind, runner: snapshot.runner, status: snapshot.status }));
             onSessionCreated?.(body.cwd ?? snapshot.cwd);
@@ -196,6 +199,29 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             res.status(400).json({ error: getErrorMessage(error, "切换模型失败。") });
         }
     });
+    // 思考深度切换：与 /model 路由对称。结构化会话立即影响下一条 prompt（CLI/SDK 各自接入
+    // applyThinkingEffortToPrompt / thinking budget），PTY 会话仅影响通过 chat 视图发送的输入。
+    app.post("/api/sessions/:id/thinking-effort", express.json(), (req, res) => {
+        const body = req.body;
+        const raw = typeof body?.thinkingEffort === "string" ? body.thinkingEffort : null;
+        const id = req.params.id;
+        try {
+            if (structured.get(id)) {
+                const updated = structured.setSessionThinkingEffort(id, raw);
+                res.json(updated);
+                return;
+            }
+            if (!processes.get(id)) {
+                res.status(404).json({ error: "未找到该会话。" });
+                return;
+            }
+            const updated = processes.setSessionThinkingEffort(id, raw);
+            res.json(updated);
+        }
+        catch (error) {
+            res.status(400).json({ error: getErrorMessage(error, "切换思考深度失败。") });
+        }
+    });
     app.get("/api/structured-sessions/:id/messages", (req, res) => {
         const snapshot = structured.get(req.params.id);
         if (!snapshot) {

package/dist/server.js

@@ -1813,6 +1813,7 @@ export async function startServer(config, configPath) {
                 model: effectiveModel,
                 cols: reqCols,
                 rows: reqRows,
+                thinkingEffort: body.thinkingEffort ?? undefined,
             });
             recordRecentPath(storage, body.cwd ?? snapshot.cwd);
             res.status(201).json(snapshot);

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

@@ -10,6 +10,8 @@ interface CreateStructuredSessionOptions {
     worktreeEnabled?: boolean;
     /** 用户指定的 Claude 模型（别名或完整 ID）。留空则 spawn 时不加 --model。 */
     model?: string;
+    /** 用户预设的思考深度。留空 / null 视为 off。 */
+    thinkingEffort?: SessionSnapshot["thinkingEffort"];
 }
 /**
  * 把任意外部输入收敛到合法的 thinkingEffort 枚举值。`null` / 非法值都视为