@co0ontty/wand 4.73.0 → 4.75.1-beta.gbf7dafd

package/dist/render-host.js

@@ -6,10 +6,76 @@ import { getErrorMessage } from "./error-utils.js";
 import { isExecutableFile, readRenderBinaryVersion, resolveRenderBinaryPath } from "./render-binary.js";
 import { connectExistingRenderClient } from "./render-daemon-client.js";
 import { renderPaths } from "./render-protocol.js";
+import { compareSemver } from "./version-utils.js";
 import { connectExistingTerminalHost, createTerminalHost, TerminalDaemonClient } from "./terminal-daemon-client.js";
 import { InProcessTerminalHost, } from "./terminal-host.js";
 /** Render 的 socket/token 就绪等待窗口，与 legacy daemon 保持一致。 */
 const RENDER_READY_TIMEOUT_MS = 5_000;
+/** 自愈 revive 的最小间隔：重连退避可能很密集，窗口内只 spawn 一次。 */
+const RENDER_REVIVE_BACKOFF_MS = 5_000;
+/** 空闲 daemon 升级时等它退出的上限（超过就当升级失败，交给上层决定）。 */
+const RENDER_SHUTDOWN_TIMEOUT_MS = 5_000;
+/** 陈留 socket 的二次确认间隔（避开「刚 bind、还没 accept」的启动窗口）。 */
+const RENDER_STALE_PROBE_DELAY_MS = 250;
+/**
+ * 运行时自愈：没有活着的 owner、且端点不可用时，起一个 detached Render。
+ * 返回 true 表示起了新进程（调用方应立刻重连）。
+ *
+ * 覆盖两种「重试永远不会好」的形状（都是同一个后果：终端一直断、只能重启整个服务）：
+ * - daemon 没了，socket 文件也被清掉（临时目录清理器，线上真发生过）；
+ * - daemon 被 kill -9 / 崩溃，socket 文件作为陈留文件留了下来（没有监听者）。
+ *
+ * 保守之处：pid 文件里还有活进程就不插手（那个 daemon 会自己重建端点，
+ * docs/render-protocol.md §6 single instance）；能连上监听者也不插手；同一个窗口只 spawn 一次。
+ */
+export function createRenderDaemonReviver(configPath, binaryPath) {
+    let inFlight = null;
+    let lastSpawnAt = 0;
+    return () => {
+        if (inFlight)
+            return inFlight;
+        inFlight = (async () => {
+            if (process.platform === "win32")
+                return false;
+            const paths = renderPaths(configPath);
+            // 有活着的 owner 就不插手：端点要么还在，要么它自己会重建
+            // （旧版 daemon 没有看门狗，但也不能开第二个 daemon —— 协议 §6 single instance）。
+            if (readLiveRenderPid(paths.pidPath) !== null)
+                return false;
+            if (await isSocketListening(paths.socketPath))
+                return false;
+            // 端点文件还在但没人监听 = 崩溃留下的陈留 socket。它可能是「刚 bind、 还没 accept」
+            // 的启动窗口，隔一下再确认一次；确认真死了就把陈留文件交给新 daemon 自己的
+            // prepare_socket_path 去判定（它只删本用户的 0600 socket，不碰别人的路径）。
+            if (existsSync(paths.socketPath)) {
+                await new Promise((resolve) => setTimeout(resolve, RENDER_STALE_PROBE_DELAY_MS));
+                if (await isSocketListening(paths.socketPath))
+                    return false;
+            }
+            if (Date.now() - lastSpawnAt < RENDER_REVIVE_BACKOFF_MS)
+                return false;
+            const resolved = binaryPath && isExecutableFile(binaryPath) ? binaryPath : resolveRenderBinaryPath(configPath);
+            if (!resolved)
+                return false;
+            lastSpawnAt = Date.now();
+            const pid = spawnDetachedRenderProcess(configPath, resolved);
+            const deadline = Date.now() + RENDER_READY_TIMEOUT_MS;
+            while (Date.now() < deadline) {
+                // 新 daemon 先 bind 再写 pid：pid 文件里出现活 pid 才算它真正接管了这个端点。
+                if (readLiveRenderPid(paths.pidPath) !== null && await isSocketListening(paths.socketPath)) {
+                    process.stderr.write(`[wand] Restarted Render daemon (pid ${pid ?? "?"}); reconnecting.\n`);
+                    return true;
+                }
+                await new Promise((resolve) => setTimeout(resolve, 50));
+            }
+            // 起了却没就绪（二进制不对/卡在启动/端点被别人占着）：回收自己生的进程，
+            // 不留占着 socket 名字的孤儿 daemon。
+            reapUnreadyRender(pid ?? undefined);
+            return false;
+        })().finally(() => { inFlight = null; });
+        return inFlight;
+    };
+}
 /**
  * 升级期无损路由：旧会话留在 legacy terminald，新会话一律进 Render。
  * MIGRATION-COMPAT: 旧 PTY/Render v1 路由须保留到用户另行要求删除；
@@ -167,17 +233,23 @@ export async function createUpgradeAwareTerminalHost(configPath, options = {}) {
  * 不另起第二个 daemon；协议版本不符 → 明确抛错，**不做降级运行**。
  */
 export async function createRenderTerminalHost(configPath, options = {}) {
+    const binaryPath = options.binaryPath ?? resolveRenderBinaryPath(configPath);
+    // adopt 到的是已经在跑的 daemon：它可能是 npm 升级前启动的旧二进制。
+    const adopt = (client) => upgradeRenderDaemonIfIdle(configPath, binaryPath, options.knownSessionIds, client);
     const paths = renderPaths(configPath);
     const endpointExists = process.platform !== "win32" && existsSync(paths.socketPath);
+    // 已经 adopt 过的客户端需要能自己把 daemon 拉回来：adopt 完 binaryPath 就丢了，
+    // 所以这里把解析结果一次性算好交给它。
+    const reviveDaemon = createRenderDaemonReviver(configPath, binaryPath);
     if (endpointExists) {
-        const adopted = await connectExistingRenderClient(configPath, options.knownSessionIds);
+        const adopted = await connectExistingRenderClient(configPath, options.knownSessionIds, reviveDaemon);
         if (adopted)
-            return adopted;
+            return adopt(adopted);
         if (await isSocketListening(paths.socketPath)) {
             // 有人监听却拒绝 adopt（协议版本不符 / token 不符）：这是错误配置，必须报出来而不是绕开。
-            const starting = await waitForRender(configPath, RENDER_READY_TIMEOUT_MS, options.knownSessionIds);
+            const starting = await waitForRender(configPath, RENDER_READY_TIMEOUT_MS, options.knownSessionIds, reviveDaemon);
             if (starting)
-                return starting;
+                return adopt(starting);
             throw new Error(`A Render daemon is listening on ${paths.socketPath} but rejected adoption. Refusing to spawn a competing Render; ` +
                 "check the protocol version/token of the running binary, or stop it first.");
         }
@@ -194,21 +266,82 @@ export async function createRenderTerminalHost(configPath, options = {}) {
     // 绝不另起第二个 daemon（协议 §6 single instance）。
     const livePid = readLiveRenderPid(paths.pidPath);
     if (livePid !== null) {
-        const starting = await waitForRender(configPath, RENDER_READY_TIMEOUT_MS, options.knownSessionIds);
+        const starting = await waitForRender(configPath, RENDER_READY_TIMEOUT_MS, options.knownSessionIds, reviveDaemon);
         if (starting)
-            return starting;
+            return adopt(starting);
         throw new Error(`Render process ${livePid} is alive but its socket ${paths.socketPath} is unavailable; refusing to spawn a second daemon.`);
     }
-    const binaryPath = options.binaryPath ?? resolveRenderBinaryPath(configPath);
     if (!binaryPath)
         throw new Error("wand-render binary is required to start Render");
-    return spawnDetachedRender(configPath, binaryPath, options.knownSessionIds);
+    return spawnDetachedRender(configPath, binaryPath, options.knownSessionIds, reviveDaemon);
 }
-/** detached spawn（stdio 忽略、unref），并等 socket + token 就绪。 */
-export async function spawnDetachedRender(configPath, binaryPath, knownSessionIds) {
-    const paths = renderPaths(configPath);
-    // `-c <configPath>` 是按 config 隔离的既定约定（docs/render-protocol.md §6）：
-    // socket / token / pid / meta 全部由它派生。
+/**
+ * 该不该把正在跑的 daemon 换成装好的二进制：只有「装好的更新」且「daemon 空闲」才换。
+ * 纯决策，便于单测；daemon 持有 PTY 时绝不能动它（会杀掉用户的 shell）。
+ */
+export function shouldUpgradeRenderDaemon(daemonVersion, binaryVersion, sessionCount) {
+    if (!daemonVersion || !binaryVersion)
+        return false;
+    if (compareSemver(daemonVersion, binaryVersion) >= 0)
+        return false;
+    return sessionCount === 0;
+}
+/**
+ * 装好的二进制比正在跑的 daemon 新时怎么办。
+ *
+ * npm 升级 / `./start.sh` 都不会重启正在跑的 daemon（不能杀别人的 PTY），所以升级后
+ * 一直在跑旧代码 —— 2026-09-24 的线上事故就是这么来的：端点自愈是 9/23 21:26 补上的，
+ * 但 terminald 是 9/19 启的老进程、Render 是 9/23 10:49 的老二进制，socket 被临时目录
+ * 清理器删掉后永远回不来。
+ *
+ * 所以：daemon 空闲（没有 PTY）就直接把它换到新二进制上 —— 升级完就好；
+ * 还有会话就只大声告警，让人在会话结束后跑 `./start.sh --restart-daemons`。
+ */
+async function upgradeRenderDaemonIfIdle(configPath, binaryPath, knownSessionIds, client) {
+    if (!binaryPath)
+        return client;
+    const daemonVersion = client.version;
+    if (!daemonVersion)
+        return client;
+    const binaryVersion = await readRenderBinaryVersion(binaryPath);
+    if (!binaryVersion || compareSemver(daemonVersion, binaryVersion) >= 0)
+        return client;
+    const sessions = client.sessionCount;
+    if (!shouldUpgradeRenderDaemon(daemonVersion, binaryVersion, sessions)) {
+        process.stderr.write(`[wand] WARNING: Render daemon ${daemonVersion} is older than the installed binary ${binaryVersion} but still owns ` +
+            `${sessions} PTY session(s); it keeps running the old code. Restart it when those sessions are done: ./start.sh --restart-daemons\n`);
+        return client;
+    }
+    try {
+        await client.requestShutdownNow();
+        client.disconnect();
+        await waitForRenderProcessExit(renderPaths(configPath).pidPath, RENDER_SHUTDOWN_TIMEOUT_MS);
+        const upgraded = await spawnDetachedRender(configPath, binaryPath, knownSessionIds);
+        process.stderr.write(`[wand] Render daemon upgraded ${daemonVersion} -> ${binaryVersion} (it was idle).\n`);
+        return upgraded;
+    }
+    catch (error) {
+        // 已经让它收摊了：回不去旧 client，报清楚并让上层（auto 模式）回退 legacy。
+        throw new Error(`Render daemon ${daemonVersion} was stopped for an upgrade to ${binaryVersion} but the replacement did not come up: ` +
+            getErrorMessage(error));
+    }
+}
+/** 等旧 daemon 真的退出（新 daemon 会因为 pid 活着而拒绝启动）。 */
+async function waitForRenderProcessExit(pidPath, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (readLiveRenderPid(pidPath) === null)
+            return;
+        await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+}
+/**
+ * detached spawn（stdio 忽略、unref），返回子进程 pid。
+ *
+ * `-c <configPath>` 是按 config 隔离的既定约定（docs/render-protocol.md §6）：
+ * socket / token / pid / meta 全部由它派生。
+ */
+export function spawnDetachedRenderProcess(configPath, binaryPath) {
     const child = spawn(binaryPath, ["-c", configPath], {
         detached: true,
         stdio: "ignore",
@@ -219,20 +352,26 @@ export async function spawnDetachedRender(configPath, binaryPath, knownSessionId
         process.stderr.write(`[wand] Failed to spawn wand-render: ${getErrorMessage(error)}\n`);
     });
     child.unref();
-    const client = await waitForRender(configPath, RENDER_READY_TIMEOUT_MS, knownSessionIds);
+    return typeof child.pid === "number" ? child.pid : null;
+}
+/** spawn 并等 socket + token 就绪（启动路径用）。 */
+export async function spawnDetachedRender(configPath, binaryPath, knownSessionIds, reviveDaemon = null) {
+    const paths = renderPaths(configPath);
+    const pid = spawnDetachedRenderProcess(configPath, binaryPath);
+    const client = await waitForRender(configPath, RENDER_READY_TIMEOUT_MS, knownSessionIds, reviveDaemon);
     if (!client) {
         // 自己生的进程自己收：就位超时（选错了二进制、二进制是 stub、或者它卡在启动）
         // 时如果不回收，就会留下一个永久孤儿 daemon —— 它占着 socket 名字、下次启动会被
         // 当成「活着但不接受领养」而直接阻塞启动。收尾是 best-effort，失败不影响报错。
-        reapUnreadyRender(child.pid);
+        reapUnreadyRender(pid ?? undefined);
         throw new Error(`Spawned ${binaryPath} but its socket/token (${paths.socketPath}) did not become ready within ${RENDER_READY_TIMEOUT_MS}ms.`);
     }
     return client;
 }
-async function waitForRender(configPath, timeoutMs, knownSessionIds) {
+async function waitForRender(configPath, timeoutMs, knownSessionIds, reviveDaemon = null) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
-        const client = await connectExistingRenderClient(configPath, knownSessionIds);
+        const client = await connectExistingRenderClient(configPath, knownSessionIds, reviveDaemon);
         if (client)
             return client;
         await new Promise((resolve) => setTimeout(resolve, 50));

package/dist/server-session-routes.js

@@ -577,7 +577,15 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             res.status(404).json({ error: "未找到该结构化会话。" });
             return;
         }
-        res.json({ id: snapshot.id, messages: snapshot.messages ?? [] });
+        const all = snapshot.messages ?? [];
+        const offset = parseBoundedInteger(req.query.offset, Math.max(0, all.length - 40), 0, all.length);
+        const limit = parseBoundedInteger(req.query.limit, 40, 1, 200);
+        res.json({
+            id: snapshot.id,
+            messages: truncateMessagesForTransport(all.slice(offset, offset + limit), config.cardDefaults ?? {}),
+            offset,
+            total: all.length,
+        });
     });
     app.post("/api/structured-sessions/:id/messages", asyncRoute(async (req, res) => {
         const input = String(req.body?.input ?? "");
@@ -1061,6 +1069,25 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
         }
         res.json({ ok: true, deleted, failed });
     });
+    app.get("/api/sessions/:id/pty-history", asyncRoute(async (req, res) => {
+        const snapshot = sessions.get(req.params.id);
+        if (!snapshot || (snapshot.sessionKind ?? "pty") !== "pty") {
+            res.status(404).json({ error: "未找到 PTY 会话。" });
+            return;
+        }
+        const before = Number(req.query.before);
+        const revision = Number(req.query.revision);
+        if (!Number.isSafeInteger(before) || !Number.isSafeInteger(revision) || before < 1 || revision < 0) {
+            res.status(400).json({ error: "无效的终端历史游标。" });
+            return;
+        }
+        const page = await processes.getTerminalHistoryPage(snapshot.id, before, revision);
+        if (!page) {
+            res.status(409).json({ error: "终端历史已变化，请重新同步。" });
+            return;
+        }
+        res.json(page);
+    }));
     app.get("/api/sessions/:id", (req, res) => {
         const snapshot = sessions.get(req.params.id);
         if (!snapshot) {
@@ -1071,8 +1098,8 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             ? processes.getPtyTranscript(snapshot.id) ?? snapshot.output
             : snapshot.output;
         if (req.query.format === "chat") {
-            // 客户端带 blockBudget（iOS）走块级窗口：只回最近 N 个块（必要时切掉最旧 turn 的头部），
-            // 根治「单条 turn 上百块/1MB」的长任务打开慢。Web/Android 不带该参数，走原 turn 级窗口。
+            // 客户端带 blockBudget（Web/iOS）走块级窗口：只回最近 N 个块（必要时切掉最旧 turn 的头部），
+            // 根治「单条 turn 上百块/1MB」的长任务打开慢；未启用的客户端保持 turn 级窗口。
             const rawBudget = req.query.blockBudget;
             if (typeof rawBudget === "string" && /^\d+$/.test(rawBudget) && Number(rawBudget) > 0) {
                 const blockBudget = parseBoundedInteger(rawBudget, 1, 1, 2_000);
@@ -1110,6 +1137,18 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
         }
         const all = enrichStructuredMessages(snapshot.messages ?? [], snapshot.id);
         const total = all.length;
+        // Web history: fetch at most one block window *before* the currently
+        // displayed turn. A 40-turn page can contain a single multi-MB assistant
+        // turn, defeating the initial block budget entirely.
+        if (typeof req.query.before === "string" && /^\d+$/.test(req.query.before)
+            && typeof req.query.blockBudget === "string" && /^\d+$/.test(req.query.blockBudget)) {
+            const before = parseBoundedInteger(req.query.before, total, 0, total);
+            const budget = parseBoundedInteger(req.query.blockBudget, 60, 1, 200);
+            const windowed = blockWindowMessagesForTransport(all.slice(0, before), config.cardDefaults ?? {}, budget);
+            res.json({ wandProtocolVersion: WAND_PROTOCOL_VERSION, ...windowed,
+                offset: windowed.messageOffset, total });
+            return;
+        }
         // 块级翻页（iOS）：?turn=<i>&blockOffset=<当前 leading 偏移>&blockLimit=<N>
         // 取该 turn 的 [start, blockOffset) 段（start = max(0, blockOffset - blockLimit)）。
         const rawTurn = parseInt(String(req.query.turn ?? ""), 10);

package/dist/server-task-routes.js

@@ -10,9 +10,9 @@ import { resolveSystemAiContext } from "./session-ai-context.js";
 import { DEFAULT_WAND_TASK_AGENT_KIND, DEFAULT_WAND_TASK_AGENT_MODE, DEFAULT_WAND_TASK_PRIORITY, isWandTaskAgentKind, isWandTaskAgentMode, normalizeWandTaskAgentMode, WAND_MILESTONE_NAME_MAX_LENGTH } from "./task-types.js";
 import { archiveBoardTask, ensureWorkspaceTaskForBoardTask, isAutoNameableBoardTask, moveSessionToWorkspaceTask, syncClosedBoardTask, syncUngroupedSessionsToBoard, syncWorkspaceTaskToBoard, taskAutoNameSignature, taskAutoNameSourceText } from "./wand-task-sync.js";
 import { isSessionProvider, providerCliCommand } from "./session-provider.js";
+import { isThinkingEffort } from "./structured-provider-common.js";
 const STATUSES = new Set(["todo", "doing", "done", "archived"]);
 const PRIORITIES = new Set(["none", "low", "medium", "high", "urgent"]);
-const AGENT_EFFORTS = new Set(["off", "standard", "deep", "max"]);
 const TASK_BOARD_LAST_AGENT_KEY = "pref:taskBoardLastAgent";
 function defaultTaskBoardAgent() {
     return { provider: "claude", model: "default", thinkingEffort: "off", mode: DEFAULT_WAND_TASK_AGENT_MODE, kind: DEFAULT_WAND_TASK_AGENT_KIND };
@@ -130,8 +130,8 @@ export function parseTaskAgent(value, fallbackMode = DEFAULT_WAND_TASK_AGENT_MOD
     const model = text(body.model) || "default";
     if (model.length > 128)
         throw new Error("模型名称过长。");
-    const thinkingEffort = (text(body.thinkingEffort) || "off");
-    if (!AGENT_EFFORTS.has(thinkingEffort))
+    const thinkingEffort = text(body.thinkingEffort) || "off";
+    if (!isThinkingEffort(thinkingEffort))
         throw new Error("思考深度无效。");
     const rawMode = body.mode === undefined || body.mode === null || body.mode === "" ? fallbackMode : body.mode;
     if (!isWandTaskAgentMode(rawMode))

package/dist/server.js

@@ -17,7 +17,7 @@ import { ModelCatalogService } from "./models.js";
 import { ProcessManager } from "./process-manager.js";
 import { SessionLogger } from "./session-logger.js";
 import { SessionRegistry } from "./session-registry.js";
-import { resolveSessionAiContext, resolveSystemAiContext } from "./session-ai-context.js";
+import { resolveSystemAiContext } from "./session-ai-context.js";
 import { StructuredSessionManager } from "./structured-session-manager.js";
 import { recordRecentPath, registerFileRoutes } from "./server-file-routes.js";
 import { registerLocalPreviewRoutes } from "./server-local-preview-routes.js";
@@ -80,7 +80,8 @@ const AVATAR_CONTENT_TYPES = {
 };
 // ── Update check cache ──
 const CACHE_TTL_MS = 10 * 60 * 1000; // 10 minutes
-const MODEL_CATALOG_AUTO_REFRESH_INTERVAL_MS = 30 * 60 * 1000;
+/** CLI 模型目录和思考档位的探测间隔。页面另有更密的快照拉取。 */
+const MODEL_CATALOG_AUTO_REFRESH_INTERVAL_MS = 10 * 60 * 1000;
 /** Cached update result broadcast to new clients on connect. */
 let cachedUpdateInfo = null;
 const packageUpdateCache = new Map();
@@ -695,8 +696,7 @@ export async function startServer(config, configPath, options = {}) {
                 selectedModel: null,
                 thinkingEffort: config.defaultThinkingEffort,
             };
-            const cli = resolveSessionAiContext(defaultSession, config);
-            ai = config.systemAi?.enabled ? { ...cli, systemAi: config.systemAi } : cli;
+            ai = resolveSystemAiContext(defaultSession, config);
         }
         try {
             const optimized = await optimizePrompt(text, config.language ?? "", cwd, ai);
@@ -966,6 +966,14 @@ export async function startServer(config, configPath, options = {}) {
     }
     // Model discovery runs exclusively in the server. Its first result is
     // persisted; later checks only write when catalog content changes.
+    // 变化后通知已连接的页面，下拉不用等用户点「刷新模型列表」。
+    modelCatalog.onChanged((result) => {
+        wsManager.emitEvent({
+            type: "notification",
+            sessionId: "__system__",
+            data: { kind: "models", revision: result.revision, refreshedAt: result.refreshedAt },
+        });
+    });
     let modelCatalogRefreshTimer = null;
     if (!testMode) {
         void modelCatalog.refresh().catch(() => { });

package/dist/session-ai-context.d.ts

@@ -16,6 +16,6 @@ export declare function resolveSessionProvider(snapshot: Pick<SessionSnapshot, "
 /** Build the provider-specific settings used by session-adjacent AI actions. */
 export declare function resolveSessionAiContext(snapshot: Pick<SessionSnapshot, "provider" | "structuredState" | "runner" | "command" | "selectedModel" | "thinkingEffort">, config: Pick<WandConfig, "defaultModel" | "defaultCodexModel" | "defaultOpenCodeModel" | "defaultGrokModel" | "defaultQoderModel" | "defaultPiModel" | "defaultThinkingEffort" | "inheritEnv">): SessionAiContext;
 /** Build the source order for Wand-owned AI features such as titles. */
-export declare function resolveSystemAiContext(snapshot: Parameters<typeof resolveSessionAiContext>[0], config: Parameters<typeof resolveSessionAiContext>[1] & Pick<WandConfig, "systemAi">): SessionAiContext;
+export declare function resolveSystemAiContext(snapshot: Parameters<typeof resolveSessionAiContext>[0], config: Parameters<typeof resolveSessionAiContext>[1] & Pick<WandConfig, "systemAi" | "systemAiCli" | "systemAiModel">): SessionAiContext;
 /** Build the AI context for quick-commit actions from their global preferences. */
 export declare function resolveCommitAiContext(snapshot: Pick<SessionSnapshot, "provider" | "structuredState" | "runner" | "command" | "selectedModel" | "thinkingEffort">, config: Pick<WandConfig, "defaultModel" | "defaultCodexModel" | "defaultOpenCodeModel" | "defaultGrokModel" | "defaultQoderModel" | "defaultPiModel" | "defaultThinkingEffort" | "inheritEnv" | "commitAiSource" | "systemAi">, discoverApis?: typeof discoverCliSystemAiConfigs): SessionAiContext;

package/dist/session-ai-context.js

@@ -39,10 +39,21 @@ export function resolveSessionAiContext(snapshot, config) {
 /** Build the source order for Wand-owned AI features such as titles. */
 export function resolveSystemAiContext(snapshot, config) {
     const sessionContext = resolveSessionAiContext(snapshot, config);
-    const directApi = config.systemAi ? usableSystemAi(config.systemAi) : undefined;
-    return directApi && config.systemAi?.enabled
-        ? { ...sessionContext, systemAi: directApi }
-        : sessionContext;
+    if (config.systemAi?.enabled) {
+        const directApi = usableSystemAi(config.systemAi);
+        return directApi ? { ...sessionContext, systemAi: directApi } : sessionContext;
+    }
+    // Older installations without a system AI CLI preference still follow the
+    // current session. A chosen CLI must never inherit another provider's model.
+    if (!isSessionProvider(config.systemAiCli))
+        return sessionContext;
+    return {
+        ...sessionContext,
+        provider: config.systemAiCli,
+        model: normalizeModel(config.systemAiModel)
+            ?? normalizeModel(getDefaultModelForProvider(config, config.systemAiCli)),
+        thinkingEffort: config.defaultThinkingEffort,
+    };
 }
 /** Build the AI context for quick-commit actions from their global preferences. */
 export function resolveCommitAiContext(snapshot, config, discoverApis = discoverCliSystemAiConfigs) {

package/dist/session-logger.d.ts

@@ -70,6 +70,8 @@ export declare class SessionLogger {
     appendPtyOutput(sessionId: string, chunk: string): void;
     /** Read the full PTY transcript including rotated logs, oldest first. */
     readPtyOutput(sessionId: string): string | null;
+    /** Only read the tail needed by the transport, including rotated files. */
+    readPtyOutputTail(sessionId: string, maxBytes?: number): string | null;
     /** Append a native mode NDJSON event */
     appendStreamEvent(sessionId: string, event: unknown): void;
     /** Append raw stdout chunk from a structured-mode child process. */

package/dist/session-logger.js

@@ -1,4 +1,4 @@
-import { mkdirSync, rmSync, appendFileSync, writeFileSync, readFileSync, existsSync, statSync, renameSync, unlinkSync } from "node:fs";
+import { mkdirSync, rmSync, appendFileSync, writeFileSync, readFileSync, existsSync, statSync, renameSync, unlinkSync, openSync, readSync, closeSync } from "node:fs";
 import path from "node:path";
 import process from "node:process";
 // ── Constants ──
@@ -148,6 +148,49 @@ export class SessionLogger {
             return null;
         }
     }
+    /** Only read the tail needed by the transport, including rotated files. */
+    readPtyOutputTail(sessionId, maxBytes = 256 * 1024) {
+        try {
+            this.flushSession(sessionId);
+            const dir = this.ensureDir(sessionId);
+            const parts = [];
+            let remaining = Math.max(1, Math.min(maxBytes, 1024 * 1024));
+            for (let index = 0; index <= this.ptyLogMaxRotations && remaining > 0; index++) {
+                const file = path.join(dir, index ? `pty-output.log.${index}` : "pty-output.log");
+                const size = tryStatSize(file);
+                if (!size)
+                    continue;
+                const length = Math.min(remaining, size);
+                const buffer = Buffer.allocUnsafe(length);
+                const fd = openSync(file, "r");
+                try {
+                    let read = 0;
+                    while (read < length) {
+                        const count = readSync(fd, buffer, read, length - read, size - length + read);
+                        if (!count)
+                            break;
+                        read += count;
+                    }
+                    parts.unshift(buffer.subarray(0, read));
+                    remaining -= read;
+                }
+                finally {
+                    closeSync(fd);
+                }
+            }
+            if (!parts.length)
+                return null;
+            const tail = Buffer.concat(parts);
+            // A byte-range may begin inside a multibyte scalar; don't inject U+FFFD.
+            let start = 0;
+            while (start < tail.length && (tail[start] & 0xc0) === 0x80)
+                start++;
+            return tail.subarray(start).toString("utf8");
+        }
+        catch {
+            return null;
+        }
+    }
     /** Append a native mode NDJSON event */
     appendStreamEvent(sessionId, event) {
         if (this.disposed)

package/dist/structured-grok-adapter.js

@@ -53,7 +53,29 @@ function grokToolName(event) {
 function grokToolInput(event) {
     return asRecord(event.rawInput) ?? asRecord(event.input) ?? {};
 }
+/** Grok bash `rawOutput.output` is a byte array; the readable text is `output_for_prompt`. */
+function grokByteText(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return "";
+    const bytes = [];
+    for (const item of value) {
+        if (typeof item !== "number" || !Number.isInteger(item) || item < 0 || item > 255)
+            return "";
+        bytes.push(item);
+    }
+    return Buffer.from(bytes).toString("utf8");
+}
 function grokToolOutput(event) {
+    const raw = asRecord(event.rawOutput);
+    if (raw) {
+        if (typeof raw.output_for_prompt === "string" && raw.output_for_prompt)
+            return raw.output_for_prompt;
+        const fromBytes = grokByteText(raw.output);
+        if (fromBytes)
+            return fromBytes;
+        if (typeof raw.output === "string" && raw.output)
+            return raw.output;
+    }
     const fromRaw = grokText(event.rawOutput);
     if (fromRaw)
         return fromRaw;

package/dist/structured-provider-common.d.ts

@@ -1,22 +1,24 @@
 import type { SessionProvider, SessionRunner, SessionSnapshot, StructuredSessionState, WandConfig } from "./types.js";
-/** 判断任意值是否为合法的 thinking effort 字面量（含 `codex:<level>` 形式）。 */
+/** 判断任意值是否为合法的 thinking effort（旧四档，或 `provider:level`）。 */
 export declare function isThinkingEffort(value: unknown): value is NonNullable<SessionSnapshot["thinkingEffort"]>;
+/** 只取本 provider 的原生档位。别的 CLI 的前缀不能串过去。 */
+export declare function prefixedThinkingEffort(provider: SessionProvider, effort: SessionSnapshot["thinkingEffort"]): string | null;
 export declare function isStructuredRunnerForProvider(provider: SessionProvider, runner: unknown): runner is SessionRunner;
 export declare function defaultStructuredRunner(provider: SessionProvider, configuredClaudeRunner?: WandConfig["structuredRunner"]): SessionRunner;
 export declare function resolveStructuredRunner(provider: SessionProvider, requestedRunner: unknown, configuredClaudeRunner?: WandConfig["structuredRunner"]): SessionRunner;
 export declare function defaultStructuredState(provider: SessionProvider, runner?: SessionRunner): StructuredSessionState;
 export declare function normalizeThinkingEffort(value: unknown): SessionSnapshot["thinkingEffort"];
 export declare function thinkingEffortToSdkBudget(effort: SessionSnapshot["thinkingEffort"]): number;
-export declare function thinkingEffortToClaudeCliEffort(effort: SessionSnapshot["thinkingEffort"]): "low" | "medium" | "max" | null;
+export declare function thinkingEffortToClaudeCliEffort(effort: SessionSnapshot["thinkingEffort"]): string | null;
 export declare function thinkingEffortToClaudeSlashEffort(effort: SessionSnapshot["thinkingEffort"]): string;
 export declare function thinkingEffortToCodexReasoningEffort(effort: SessionSnapshot["thinkingEffort"]): string | null;
+/** OpenCode `--variant`。旧四档仍是 low/high/max；`opencode:<level>` 原样传递。 */
+export declare function thinkingEffortToOpenCodeVariant(effort: SessionSnapshot["thinkingEffort"]): string | null;
+/** Qoder `--reasoning-effort`。旧四档仍是 low/high/max；`qoder:<level>` 原样传递。 */
+export declare function thinkingEffortToQoderEffort(effort: SessionSnapshot["thinkingEffort"]): string | null;
 /**
- * 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。
  */
-declare function thinkingEffortToLowHighMax(effort: SessionSnapshot["thinkingEffort"]): string | null;
-export declare const thinkingEffortToOpenCodeVariant: typeof thinkingEffortToLowHighMax;
-export declare const thinkingEffortToGrokEffort: typeof thinkingEffortToLowHighMax;
-export declare const thinkingEffortToQoderEffort: typeof thinkingEffortToLowHighMax;
+export declare function thinkingEffortToGrokEffort(effort: SessionSnapshot["thinkingEffort"]): string | null;
 export declare function thinkingEffortToPiLevel(effort: SessionSnapshot["thinkingEffort"]): string | null;
-export {};