@co0ontty/wand 4.72.2 → 4.75.0-beta.g1d477a2

package/dist/structured-client-protocol.js

@@ -1,4 +1,4 @@
-import { asRecord } from "./structured-content.js";
+import { asRecord, isStructuredImagePart } from "./structured-content.js";
 export const WAND_PROTOCOL_VERSION = 2;
 function text(value) {
     return typeof value === "string" && value ? value : undefined;
@@ -46,6 +46,8 @@ function questionsFromInput(input) {
 /** 派发子 Agent 的工具名：Claude Code 的 Task/Agent，以及 Wand pi 扩展的 subagent。 */
 const SUBAGENT_TOOL_NAMES = new Set(["Task", "Agent"]);
 const PI_SUBAGENT_TOOL_NAME = "Pi/subagent";
+/** pi 的待办扩展工具，经 `piToolName` 映射后带 `Pi/` 前缀。 */
+const PI_TODO_TOOL_NAME = "Pi/todo";
 /**
  * 历史 turn / 非 Claude provider 的子 Agent 工具调用没有 `__subagent` 盖章，
  * 按调用参数现场补一份，让「子 Agent」面板在所有端都拿得到同一份分组。
@@ -121,6 +123,10 @@ function toolResultText(block) {
         return block.content;
     return block.content.map((part) => text(part.text) ?? "").join("");
 }
+const TASK_LIST_TOOL_NAMES = ["TodoWrite", "TaskCreate", "TaskUpdate", "TaskList", PI_TODO_TOOL_NAME];
+function piTodoAction(input) {
+    return text(input.action) ?? "";
+}
 function tasksFromSegment(messages, start, end) {
     let latestTodoWrite = null;
     let targetId = null;
@@ -129,7 +135,7 @@ function tasksFromSegment(messages, start, end) {
         for (const block of messages[i]?.content ?? []) {
             if (block.type === "tool_result")
                 resultByToolId.set(block.tool_use_id, toolResultText(block));
-            if (block.type === "tool_use" && ["TodoWrite", "TaskCreate", "TaskUpdate", "TaskList"].includes(block.name)) {
+            if (block.type === "tool_use" && TASK_LIST_TOOL_NAMES.includes(block.name)) {
                 targetId = block.id;
                 if (block.name === "TodoWrite")
                     latestTodoWrite = block;
@@ -158,31 +164,42 @@ function tasksFromSegment(messages, start, end) {
         for (const block of messages[i]?.content ?? []) {
             if (block.type !== "tool_use")
                 continue;
-            if (block.name === "TaskCreate") {
+            // pi 的待办工具把增删改合成一条 call，靠 `action` 区分，且主键是 `id` 而非 `taskId`。
+            const piAction = block.name === PI_TODO_TOOL_NAME ? piTodoAction(block.input) : null;
+            const isCreate = block.name === "TaskCreate" || piAction === "create";
+            const isUpdate = block.name === "TaskUpdate"
+                || (piAction !== null && piAction !== "list" && piAction !== "get");
+            if (!isCreate && !isUpdate)
+                continue;
+            if (piAction === "clear") {
                 sawTaskTool = true;
+                tasks.clear();
+                continue;
+            }
+            const rawId = isCreate ? "" : String(block.input.taskId ?? block.input.id ?? "");
+            if (!isCreate && !rawId)
+                continue;
+            sawTaskTool = true;
+            let id;
+            if (isCreate) {
                 fallbackId++;
-                const match = resultByToolId.get(block.id)?.match(/#([^\s]+)/);
-                const id = match?.[1] ?? String(fallbackId);
-                tasks.set(id, {
-                    id,
-                    content: text(block.input.subject) ?? text(block.input.description) ?? `Task #${id}`,
-                    status: "pending",
-                    ...(text(block.input.activeForm) ? { activeForm: text(block.input.activeForm) } : {}),
-                });
+                // 结果文本里才有分配到的 id：Claude「Task #7 created …」/ pi「Created #1: …」。
+                id = resultByToolId.get(block.id)?.match(/#([^\s:,]+)/)?.[1] ?? String(fallbackId);
             }
-            else if (block.name === "TaskUpdate") {
-                sawTaskTool = true;
-                const id = String(block.input.taskId ?? "");
-                if (!id)
-                    continue;
-                const previous = tasks.get(id) ?? { id, content: `Task #${id}`, status: "pending" };
-                tasks.set(id, {
-                    ...previous,
-                    ...(text(block.input.subject) ? { content: text(block.input.subject) } : {}),
-                    ...(text(block.input.status) ? { status: text(block.input.status) } : {}),
-                    ...(text(block.input.activeForm) ? { activeForm: text(block.input.activeForm) } : {}),
-                });
+            else {
+                id = rawId;
             }
+            const content = text(block.input.subject) ?? text(block.input.description);
+            const status = text(block.input.status);
+            const activeForm = text(block.input.activeForm);
+            const deleted = piAction === "delete" || status === "deleted";
+            tasks.set(id, {
+                ...tasks.get(id) ?? { id, content: content ?? `Task #${id}`, status: "pending" },
+                ...(content ? { content } : {}),
+                ...(status ? { status } : {}),
+                ...(deleted ? { status: "deleted" } : {}),
+                ...(activeForm ? { activeForm } : {}),
+            });
         }
     }
     return {
@@ -190,11 +207,54 @@ function tasksFromSegment(messages, start, end) {
         targetId,
     };
 }
+/**
+ * 把 tool_result 里的内联 base64 图片换成「按会话取图」的 URL。
+ *
+ * 为什么不能把 base64 直接下发：读一张截图动辄 1–3MB，base64 后更大，会撑爆移动端
+ * 单帧上限（iOS 默认 1MiB）导致反复断连；而且同一张图在每条快照里重复传。换成 URL
+ * 后各端用同一套带鉴权的取图通道按需加载（Web 走 <img>，原生走各自 ImageLoader）。
+ * source 本来就是 url 的图片不动，保持幂等。
+ */
+function rewriteInlineToolImageUrls(messages, sessionId) {
+    return messages.map((turn) => {
+        let turnChanged = false;
+        const content = turn.content.map((block) => {
+            if (block.type !== "tool_result" || !Array.isArray(block.content))
+                return block;
+            let imageIndex = -1;
+            let blockChanged = false;
+            const parts = block.content.map((part) => {
+                if (!isStructuredImagePart(part))
+                    return part;
+                imageIndex += 1;
+                const source = asRecord(part.source);
+                if (source?.type !== "base64" || typeof source.data !== "string")
+                    return part;
+                blockChanged = true;
+                return {
+                    type: "image",
+                    source: {
+                        type: "url",
+                        url: `/api/sessions/${encodeURIComponent(sessionId)}/tool-images/${encodeURIComponent(block.tool_use_id)}/${imageIndex}`,
+                        ...(typeof source.media_type === "string" ? { media_type: source.media_type } : {}),
+                    },
+                };
+            });
+            if (!blockChanged)
+                return block;
+            turnChanged = true;
+            return { ...block, content: parts };
+        });
+        return turnChanged ? { ...turn, content } : turn;
+    });
+}
 /**
  * Add Wand-owned semantics without mutating persisted provider blocks.
  * This is the external interface consumed by every client.
+ *
+ * 传 sessionId 时额外把内联图片改写成取图 URL（见 rewriteInlineToolImageUrls）。
  */
-export function enrichStructuredMessages(messages) {
+export function enrichStructuredMessages(messages, sessionId) {
     const enriched = stampDerivedSubagents(messages).map((turn) => ({
         ...turn,
         content: turn.content.map((block) => {
@@ -231,5 +291,5 @@ export function enrichStructuredMessages(messages) {
         }
         segmentStart = i;
     }
-    return enriched;
+    return sessionId ? rewriteInlineToolImageUrls(enriched, sessionId) : enriched;
 }

package/dist/structured-content.d.ts

@@ -1,7 +1,24 @@
 /** 把 unknown 收敛成普通对象；数组 / null / 原始值都返回 null。 */
 export declare function asRecord(value: unknown): Record<string, unknown> | null;
-/** Preserve both Responses content parts and arbitrary structured tool output. */
-export declare function normalizeStructuredToolResultContent(content: unknown): string | Array<{
+export type StructuredContentPart = {
     type: string;
     [key: string]: unknown;
-}>;
+};
+/**
+ * 各家 provider 的图片 part 形态不同：
+ *   · Anthropic：`{ type:"image", source:{ type:"base64", media_type, data } }` / `source:{ type:"url", url }`
+ *   · OpenAI Responses：`{ type:"image_url", image_url:{ url } }` / `image_url:"…"`
+ *   · Pi：`{ type:"image", data, mimeType }`
+ * 只要带图片语义就算，具体归一化交给 canonicalizeStructuredImagePart。
+ */
+export declare function isStructuredImagePart(value: unknown): boolean;
+/**
+ * 统一成客户端认识的规范形态（Web / Android / iOS / macOS 都按
+ * `{ type:"image", source:{ type:"base64"|"url", … } }` 解析）。识别不了返回 null，
+ * 由调用方原样保留，避免丢信息。
+ */
+export declare function canonicalizeStructuredImagePart(value: unknown): StructuredContentPart | null;
+/** content（字符串 / part 数组）里是否含图片 part。 */
+export declare function contentHasStructuredImage(content: unknown): boolean;
+/** Preserve both Responses content parts and arbitrary structured tool output. */
+export declare function normalizeStructuredToolResultContent(content: unknown): string | StructuredContentPart[];

package/dist/structured-content.js

@@ -4,12 +4,91 @@ export function asRecord(value) {
         ? value
         : null;
 }
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+/**
+ * 各家 provider 的图片 part 形态不同：
+ *   · Anthropic：`{ type:"image", source:{ type:"base64", media_type, data } }` / `source:{ type:"url", url }`
+ *   · OpenAI Responses：`{ type:"image_url", image_url:{ url } }` / `image_url:"…"`
+ *   · Pi：`{ type:"image", data, mimeType }`
+ * 只要带图片语义就算，具体归一化交给 canonicalizeStructuredImagePart。
+ */
+export function isStructuredImagePart(value) {
+    const part = asRecord(value);
+    if (!part)
+        return false;
+    if (part.type === "image_url")
+        return !!imageUrlOf(part);
+    if (part.type !== "image")
+        return false;
+    const source = asRecord(part.source);
+    if (source && (stringValue(source.data) || stringValue(source.url)))
+        return true;
+    return !!(stringValue(part.data) || stringValue(part.url));
+}
+function imageUrlOf(part) {
+    const raw = part.image_url;
+    if (typeof raw === "string")
+        return stringValue(raw);
+    return stringValue(asRecord(raw)?.url);
+}
+/**
+ * 统一成客户端认识的规范形态（Web / Android / iOS / macOS 都按
+ * `{ type:"image", source:{ type:"base64"|"url", … } }` 解析）。识别不了返回 null，
+ * 由调用方原样保留，避免丢信息。
+ */
+export function canonicalizeStructuredImagePart(value) {
+    const part = asRecord(value);
+    if (!part)
+        return null;
+    if (part.type === "image_url") {
+        const url = imageUrlOf(part);
+        return url ? { type: "image", source: { type: "url", url } } : null;
+    }
+    if (part.type !== "image")
+        return null;
+    const source = asRecord(part.source);
+    if (source) {
+        const data = stringValue(source.data);
+        if (source.type === "base64" && data) {
+            return {
+                type: "image",
+                source: { type: "base64", media_type: stringValue(source.media_type) ?? "image/png", data },
+            };
+        }
+        const url = stringValue(source.url);
+        if (url)
+            return { type: "image", source: { type: "url", url } };
+    }
+    const data = stringValue(part.data);
+    if (data) {
+        const mediaType = stringValue(part.mimeType)
+            ?? stringValue(part.mime_type)
+            ?? stringValue(source?.media_type)
+            ?? "image/png";
+        return { type: "image", source: { type: "base64", media_type: mediaType, data } };
+    }
+    const url = stringValue(part.url);
+    if (url)
+        return { type: "image", source: { type: "url", url } };
+    return null;
+}
+/** content（字符串 / part 数组）里是否含图片 part。 */
+export function contentHasStructuredImage(content) {
+    if (!Array.isArray(content))
+        return false;
+    return content.some((part) => isStructuredImagePart(part));
+}
 /** Preserve both Responses content parts and arbitrary structured tool output. */
 export function normalizeStructuredToolResultContent(content) {
     if (typeof content === "string")
         return content;
     if (Array.isArray(content)) {
-        const parts = content.filter((item) => !!item && typeof item === "object" && typeof item.type === "string");
+        const parts = content
+            .filter((item) => !!item && typeof item === "object" && typeof item.type === "string")
+            // 图片 part 归一化后客户端才能跨端渲染；非图片 part 原样保留。
+            .map((part) => canonicalizeStructuredImagePart(part) ?? part);
         if (parts.length === content.length)
             return parts;
         try {

package/dist/structured-exec-host.js

@@ -79,6 +79,12 @@ class InProcessStructuredExecProcess {
             });
         });
         this.child.on("error", () => settleExit({ exitCode: null, signal: null }));
+        this.child.stdin?.on("error", () => {
+            // EPIPE is emitted by stdin, not by ChildProcess. Never claim success
+            // when a child exits before consuming its one-shot prompt.
+            settleExit({ exitCode: -1, signal: null });
+            this.interrupt();
+        });
     }
     get pid() {
         return this.child.pid ?? -1;
@@ -118,9 +124,9 @@ export class InProcessStructuredExecHost {
             env: request.env,
             stdio: wantsStdin ? ["pipe", "pipe", "pipe"] : ["ignore", "pipe", "pipe"],
         });
+        const wrapped = new InProcessStructuredExecProcess(request.runId, child);
         if (wantsStdin)
             child.stdin?.end(request.stdinData);
-        const wrapped = new InProcessStructuredExecProcess(request.runId, child);
         // Keep exited records until forgetRun so a late attach can still answer.
         this.processes.set(request.runId, wrapped);
         return wrapped;

package/dist/structured-exec-pump.js

@@ -80,19 +80,23 @@ export function startStructuredCli(options) {
             env: options.env,
             stdio: wantsStdin ? ["pipe", "pipe", "pipe"] : ["ignore", "pipe", "pipe"],
         });
-        if (wantsStdin)
-            child.stdin?.end(options.stdinData);
         source = { pid: child.pid ?? null, interrupt: () => child.kill("SIGTERM") };
         const stdoutDecoder = createUtf8TextDecoder();
         const stderrDecoder = createUtf8TextDecoder();
         child.stdout?.on("data", (chunk) => handleStdoutText(stdoutDecoder.write(chunk)));
         child.stderr?.on("data", (chunk) => handleStderrText(stderrDecoder.write(chunk)));
         child.on("error", (error) => finish(null, null, error));
+        child.stdin?.on("error", (error) => {
+            finish(null, null, error);
+            child.kill("SIGTERM");
+        });
         child.on("close", (exitCode, signalName) => {
             handleStdoutText(stdoutDecoder.end());
             handleStderrText(stderrDecoder.end());
             finish(exitCode, signalName === null || signalName === undefined ? null : signalName);
         });
+        if (wantsStdin)
+            child.stdin?.end(options.stdinData);
         sourceReady = Promise.resolve();
     }
     return {

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-pi-adapter.js

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { startStructuredCli } from "./structured-exec-pump.js";
-import { asRecord } from "./structured-content.js";
+import { asRecord, normalizeStructuredToolResultContent } from "./structured-content.js";
 import { thinkingEffortToPiLevel } from "./structured-provider-common.js";
 export function isMissingPiSession(error, sessionId) {
     return !!sessionId && !!error?.includes(`No session found matching '${sessionId}'`);
@@ -17,6 +17,22 @@ function textContent(value) {
         return item.text;
     return textContent(item.content);
 }
+/**
+ * Pi 的工具结果是 `{ content: [ text…, image… ] }`。图片 part 不能像以前那样只抽文本
+ * 丢掉——读图 / 截图全靠它，统一交给 normalizeStructuredToolResultContent 归一化。
+ * 纯文本结果仍压成字符串，保持既有形态。
+ */
+function piToolResultContent(value) {
+    const record = asRecord(value);
+    const raw = record && "content" in record ? record.content : value;
+    const normalized = normalizeStructuredToolResultContent(raw);
+    if (typeof normalized === "string")
+        return normalized;
+    if (normalized.length > 0 && normalized.every((part) => part.type === "text" && typeof part.text === "string")) {
+        return normalized.map((part) => part.text).filter(Boolean).join("\n");
+    }
+    return normalized;
+}
 export function buildPiArgs(session, prompt) {
     const args = ["--mode", "json", "--print"];
     const model = session.selectedModel?.trim();
@@ -141,7 +157,7 @@ export function applyPiEvent(state, event) {
     }
     if (event.type === "tool_execution_end") {
         const id = typeof event.toolCallId === "string" ? event.toolCallId : "unknown";
-        state.blocks.push({ type: "tool_result", tool_use_id: id, content: textContent(event.result), is_error: event.isError === true });
+        state.blocks.push({ type: "tool_result", tool_use_id: id, content: piToolResultContent(event.result), is_error: event.isError === true });
     }
     if (event.type === "message_end" || event.type === "turn_end") {
         const message = asRecord(event.message);

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 {};

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/structured-session-manager.d.ts

@@ -155,6 +155,8 @@ export declare class StructuredSessionManager {
      * 本身，flushNext 在另一段时序里读 sessions.get(...) 当前快照，已经天然安全。
      */
     reorderQueuedMessages(sessionId: string, order: number[]): SessionSnapshot;
+    /** Edit only the pending item still identified by both index and original text. */
+    editQueuedMessage(sessionId: string, index: number, expectedText: string, text: string): SessionSnapshot;
     /** Remove a single queued message only while index and text still identify the same item. */
     deleteQueuedMessage(sessionId: string, index: number, expectedText?: string): SessionSnapshot;
     /**

package/dist/structured-session-manager.js

@@ -207,7 +207,7 @@ function buildStructuredOutputPayload(snapshot) {
     return {
         wandProtocolVersion: WAND_PROTOCOL_VERSION,
         output: snapshot.output,
-        messages: snapshot.messages ? enrichStructuredMessages(snapshot.messages) : undefined,
+        messages: snapshot.messages ? enrichStructuredMessages(snapshot.messages, snapshot.id) : undefined,
         queuedMessages: snapshot.queuedMessages,
         queuedMessageSkills: snapshot.queuedMessageSkills,
         sessionKind: "structured",
@@ -259,7 +259,7 @@ function buildIncrementalStructuredPayload(snapshot, cardDefaults) {
     const messages = snapshot.messages ?? [];
     // Derive semantics from the complete current turn before taking the
     // incremental tail; TaskCreate results can live in an earlier provider frame.
-    const clientMessages = enrichStructuredMessages(messages);
+    const clientMessages = enrichStructuredMessages(messages, snapshot.id);
     const lastTurn = clientMessages.length > 0 ? clientMessages[clientMessages.length - 1] : undefined;
     // Streaming turn (index 0 here) is preserved verbatim; truncation only kicks
     // in if the live response is already bigger than the transport threshold,
@@ -678,7 +678,13 @@ export class StructuredSessionManager {
                 continue;
             }
             try {
-                await this.resumeDetachedRun(session, state);
+                // listRuns is metadata-only on Render v2. Fetch the authoritative
+                // paged replay from the owner before feeding any provider reducer.
+                const attached = await this.execHost.attachRun(state.runId);
+                if (!attached || attached.incarnationId !== state.incarnationId) {
+                    throw new Error("Structured run changed owner between inventory and replay");
+                }
+                await this.resumeDetachedRun(session, attached);
             }
             catch (error) {
                 console.error(`[WAND] structured run recovery failed for ${sessionId}:`, error);
@@ -1497,6 +1503,24 @@ export class StructuredSessionManager {
         this.emitStructuredSnapshot(updated);
         return updated;
     }
+    /** Edit only the pending item still identified by both index and original text. */
+    editQueuedMessage(sessionId, index, expectedText, text) {
+        const session = this.requireSession(sessionId);
+        const queue = session.queuedMessages ?? [];
+        if (!Number.isInteger(index) || index < 0 || index >= queue.length || queue[index] !== expectedText) {
+            throw new Error("排队消息已变化，请刷新后重试。");
+        }
+        const trimmed = text.trim();
+        if (!trimmed)
+            throw new Error("排队消息不能为空。");
+        const next = queue.slice();
+        next[index] = trimmed;
+        const updated = { ...session, queuedMessages: next };
+        this.sessions.set(sessionId, updated);
+        this.storage.updateSessionRuntimeMetadata(updated);
+        this.emitStructuredSnapshot(updated);
+        return updated;
+    }
     /** Remove a single queued message only while index and text still identify the same item. */
     deleteQueuedMessage(sessionId, index, expectedText) {
         const session = this.requireSession(sessionId);