@tea-agent/loop-agent 0.38.0 → 0.38.2

package/dist/worker/console/chat/session-store.js

@@ -17,6 +17,7 @@ import { dispatchOperatorAction } from "../operator-actions.js";
 import { authorizeOperatorChatTool } from "./tools.js";
 import { projectOperationForChat } from "./chat-event-store.js";
 import { scrubSecrets } from "./explore-tools.js";
+import { hashDeferredTurnPayload, parseDeferredTurn, } from "./deferred-turn.js";
 const CHAT_TITLE_MAX_CHARS = 80;
 /** Safe, one-line bounded title used for placeholders and model output. */
 export function cleanChatTitle(value) {
@@ -53,6 +54,7 @@ export class ChatSessionStore {
         const raw = await readJsonIfExists(recordPath(this.appData, sessionId));
         if (!raw || raw.sessionId !== sessionId)
             return undefined;
+        const deferredTurn = parseDeferredTurn(raw.deferredTurn);
         return {
             schemaVersion: 2,
             sessionId,
@@ -67,6 +69,7 @@ export class ChatSessionStore {
             ...(typeof raw.modelProvider === "string" ? { modelProvider: raw.modelProvider } : {}),
             ...(typeof raw.modelId === "string" ? { modelId: raw.modelId } : {}),
             ...(typeof raw.thinkingLevel === "string" ? { thinkingLevel: raw.thinkingLevel } : {}),
+            ...(deferredTurn ? { deferredTurn } : {}),
             messages: Array.isArray(raw.messages) ? raw.messages : [],
             toolInvocations: Array.isArray(raw.toolInvocations) ? raw.toolInvocations : [],
         };
@@ -147,6 +150,7 @@ export class ChatSessionStore {
                 ...(input.targetSessionFile ? { sessionFile: input.targetSessionFile } : { sessionFile: undefined }),
                 createdAt: now,
                 updatedAt: now,
+                deferredTurn: undefined,
                 messages: structuredClone(source.messages),
                 toolInvocations: structuredClone(source.toolInvocations),
             };
@@ -216,6 +220,146 @@ export class ChatSessionStore {
             return true;
         });
     }
+    async putDeferredTurn(sessionId, input) {
+        return this.serialize(sessionId, async () => {
+            const record = await this.get(sessionId);
+            if (!record)
+                return { ok: false, code: "NOT_FOUND" };
+            const clientRequestId = input.clientRequestId.trim();
+            const blockedByTurnId = input.blockedByTurnId.trim();
+            const text = input.text.trim() || (input.images.length > 0 ? "请查看附件图片。" : "");
+            if (!clientRequestId || !blockedByTurnId || !text) {
+                return { ok: false, code: "INVALID_INPUT" };
+            }
+            const payloadHash = hashDeferredTurnPayload({ text, images: input.images });
+            const existing = record.deferredTurn;
+            if (existing) {
+                if (existing.clientRequestId === clientRequestId) {
+                    if (existing.payloadHash !== payloadHash) {
+                        return {
+                            ok: false,
+                            code: "REQUEST_ID_REUSE_CONFLICT",
+                            deferredTurn: existing,
+                        };
+                    }
+                    return { ok: true, deferredTurn: existing, idempotent: true };
+                }
+                if (existing.state !== "queued") {
+                    return {
+                        ok: false,
+                        code: "NOT_REPLACEABLE",
+                        deferredTurn: existing,
+                    };
+                }
+                if (input.expectedRevision !== existing.revision) {
+                    return {
+                        ok: false,
+                        code: "REVISION_CONFLICT",
+                        deferredTurn: existing,
+                    };
+                }
+            }
+            else if (input.expectedRevision !== undefined &&
+                input.expectedRevision !== 0) {
+                return { ok: false, code: "REVISION_CONFLICT" };
+            }
+            const now = new Date().toISOString();
+            const deferredTurn = {
+                schemaVersion: 1,
+                revision: (existing?.revision ?? 0) + 1,
+                clientRequestId,
+                payloadHash,
+                blockedByTurnId,
+                text,
+                images: structuredClone(input.images),
+                state: "queued",
+                createdAt: existing?.createdAt ?? now,
+                updatedAt: now,
+            };
+            record.deferredTurn = deferredTurn;
+            record.updatedAt = now;
+            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            return { ok: true, deferredTurn, idempotent: false };
+        });
+    }
+    async claimDeferredTurn(sessionId, expectedRevision) {
+        return this.serialize(sessionId, async () => {
+            const record = await this.get(sessionId);
+            const existing = record?.deferredTurn;
+            if (!record || !existing)
+                return { ok: false, code: "NOT_FOUND" };
+            if (existing.revision !== expectedRevision) {
+                return { ok: false, code: "REVISION_CONFLICT", deferredTurn: existing };
+            }
+            if (existing.state !== "queued") {
+                return { ok: false, code: "NOT_CLAIMABLE", deferredTurn: existing };
+            }
+            const next = {
+                ...existing,
+                revision: existing.revision + 1,
+                state: "dispatching",
+                updatedAt: new Date().toISOString(),
+            };
+            record.deferredTurn = next;
+            record.updatedAt = next.updatedAt;
+            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            return { ok: true, deferredTurn: next };
+        });
+    }
+    async transitionDeferredTurn(sessionId, input) {
+        return this.serialize(sessionId, async () => {
+            const record = await this.get(sessionId);
+            const existing = record?.deferredTurn;
+            if (!record || !existing || existing.revision !== input.expectedRevision)
+                return undefined;
+            const next = {
+                ...existing,
+                revision: existing.revision + 1,
+                state: input.state,
+                updatedAt: new Date().toISOString(),
+                ...(input.acceptedTurnId ? { acceptedTurnId: input.acceptedTurnId } : {}),
+                ...(input.lastError ? { lastError: input.lastError } : {}),
+            };
+            if (!input.lastError)
+                delete next.lastError;
+            record.deferredTurn = next;
+            record.updatedAt = next.updatedAt;
+            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            return next;
+        });
+    }
+    async deleteDeferredTurn(sessionId, input) {
+        return this.serialize(sessionId, async () => {
+            const record = await this.get(sessionId);
+            const existing = record?.deferredTurn;
+            if (!record || !existing || existing.clientRequestId !== input.clientRequestId) {
+                return { ok: false, code: "NOT_FOUND" };
+            }
+            if (existing.state !== "queued" && existing.state !== "failed") {
+                return { ok: false, code: "NOT_CANCELLABLE", deferredTurn: existing };
+            }
+            if (existing.revision !== input.expectedRevision) {
+                return { ok: false, code: "REVISION_CONFLICT", deferredTurn: existing };
+            }
+            delete record.deferredTurn;
+            record.updatedAt = new Date().toISOString();
+            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            return { ok: true, deferredTurn: existing };
+        });
+    }
+    async clearDeferredTurnForRequest(sessionId, clientRequestId) {
+        return this.serialize(sessionId, async () => {
+            const record = await this.get(sessionId);
+            const existing = record?.deferredTurn;
+            if (!record || !existing || existing.clientRequestId !== clientRequestId) {
+                return undefined;
+            }
+            delete record.deferredTurn;
+            record.updatedAt = new Date().toISOString();
+            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            return { deferredTurn: existing, clearedRevision: existing.revision + 1 };
+        });
+    }
     async appendMessage(sessionId, message) {
         return this.serialize(sessionId, async () => {
             const record = await this.get(sessionId);
@@ -340,10 +484,10 @@ export async function runChatTurn(options) {
             },
         };
     }
-    await store.appendMessage(sessionId, { role: "user", text });
+    const userMessage = await store.appendMessage(sessionId, { role: "user", text });
     const afterUserMessage = await store.get(sessionId);
     if (afterUserMessage)
-        await options.onUserMessagePersisted?.(afterUserMessage);
+        await options.onUserMessagePersisted?.(afterUserMessage, userMessage);
     let turnError;
     // Collect persistence promises so runChatTurn does not resolve before the
     // chat history / audit trail is durably written (also makes the outcome

package/dist/worker/console/chat/turn-process.js

@@ -92,36 +92,25 @@ function sortToolsStable(tools) {
     });
 }
 /**
- * Flush buffered consecutive tools into process items. Semantic operator
- * tools stay as individual activity events; plain tools group into a
- * `tool-group` ("并行调用 · N 项") when two or more land back to back.
+ * Flush buffered consecutive tools into process items (pi-web aligned:
+ * strict sequential flow, no synthetic grouping). Semantic operator tools
+ * stay as individual activity events; plain tools each render as their own
+ * card in stable server order (eventSeq first, createdAt fallback).
  * Thinking/text/activity boundaries break the buffer upstream.
  */
 function flushToolBuffer(processItems, buffer) {
     if (buffer.length === 0)
         return;
     const sorted = sortToolsStable(buffer);
-    let plainGroup = [];
-    const flushPlain = () => {
-        if (plainGroup.length === 1) {
-            processItems.push({ kind: "tool", tool: plainGroup[0] });
-        }
-        else if (plainGroup.length > 1) {
-            processItems.push({ kind: "tool-group", tools: plainGroup });
-        }
-        plainGroup = [];
-    };
     for (const tool of sorted) {
         const activity = semanticActivityForTool(tool);
         if (activity) {
-            flushPlain();
             processItems.push({ kind: "activity", activity });
         }
         else {
-            plainGroup.push(tool);
+            processItems.push({ kind: "tool", tool });
         }
     }
-    flushPlain();
 }
 function emitProcessBlocks(blocks, group, processItems, usedToolIds) {
     let buffer = [];
@@ -227,9 +216,6 @@ export function buildTurnProcessGroups(input) {
             current = startGroup(`assistant-${message.id}`);
         current.assistants.push(message);
     }
-    if (groups.length === 0 && input.toolCalls.length > 0) {
-        groups.push(emptyGroup("orphan-tools"));
-    }
     const assigned = new Set();
     const assistantToGroup = new Map();
     for (const group of groups) {
@@ -276,17 +262,12 @@ export function buildTurnProcessGroups(input) {
             const end = next?.user?.createdAt ?? Number.POSITIVE_INFINITY;
             return tool.createdAt >= start && tool.createdAt < end;
         });
+        // Time window only. Never dump unmatched tools onto the latest group:
+        // that is how a previous turn's bash cards jump under a new prompt.
         if (windowGroup) {
             windowGroup.tools.push(tool);
             assigned.add(tool.id);
         }
-        else {
-            const lastGroup = groups.at(-1);
-            if (lastGroup) {
-                lastGroup.tools.push(tool);
-                assigned.add(tool.id);
-            }
-        }
     }
     for (const group of groups) {
         group.tools.sort((a, b) => {
@@ -303,6 +284,14 @@ export function buildTurnProcessGroups(input) {
     }
     return groups;
 }
+/** Keep the most recent complete turns. Slice groups, never raw messages. */
+export function selectRecentTurnGroups(groups, limit) {
+    if (limit <= 0)
+        return [];
+    if (groups.length <= limit)
+        return [...groups];
+    return groups.slice(-limit);
+}
 export function processGroupSummary(tools, options) {
     const count = tools.length;
     const thinkingCount = options?.thinkingCount ?? 0;
@@ -324,7 +313,7 @@ export function processGroupSummary(tools, options) {
         parts.push("运行中");
     return { count, errorCount, runningCount, stepCount, label: parts.join(" · ") };
 }
-/** Summary over rendered process items (tool-group tools count individually). */
+/** Summary over rendered process items. */
 export function summarizeProcessItems(items) {
     const tools = [];
     let thinkingCount = 0;
@@ -344,10 +333,8 @@ export function summarizeProcessItems(items) {
             else if (item.activity.kind === "progress")
                 activityRunningCount += 1;
         }
-        else if (item.kind === "tool")
-            tools.push(item.tool);
         else
-            tools.push(...item.tools);
+            tools.push(item.tool);
     }
     return processGroupSummary(tools, {
         thinkingCount,

package/dist/worker/console/harness-pi-model-matrix.js

@@ -0,0 +1,137 @@
+/**
+ * harness.json executors.pi LOW/MED/HIGH 模型矩阵的读写与校验。
+ *
+ * 该模块只服务于 Console「模型与认证」页的模型矩阵编辑器：
+ *  - `validatePiModelMatrixTiers`：写入前拒绝空串 / default 哨兵 / 非字符串 /
+ *    畸形 provider/model（如 provider/、/model、a//b）。
+ *  - `readPiModelMatrixProjection`：读全文档并投影三档的 provider/model 或裸
+ *    model id（供 readiness 结构化投影 piModelMatrix 使用）。
+ *  - `writePiModelMatrix`：读全文档 → 校验 → 原子写 tmp + fsync + rename，
+ *    保留 $schema 与其余所有字段。
+ *
+ * 本模块在 worker/console（Node 侧），不得被浏览器静态资源直接 import
+ * （依赖 node:fs / node:crypto / node:path）。
+ */
+import { randomBytes } from "node:crypto";
+import { open, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { normalizeExecutorTierValue } from "../../governance/manifest-types.js";
+export const PI_MODEL_TIERS = ["LOW", "MED", "HIGH"];
+/** 校验单档字符串值，返回错误文案；合法返回 undefined。 */
+export function piModelTierValueError(value) {
+    if (typeof value !== "string")
+        return "模型值必须是字符串";
+    if (value.length === 0)
+        return "模型值不能为空";
+    if (value.trim() !== value)
+        return "模型值不能包含首尾空白";
+    if (value === "default")
+        return "default 是保留哨兵，不能作为模型值";
+    // 比 normalizeExecutorTierValue 更严格：拒绝 provider/、/model、a//b。
+    if (value.startsWith("/") || value.endsWith("/") || value.includes("//")) {
+        return "provider/model 格式非法：不允许 /model、provider/ 或 a//b";
+    }
+    return undefined;
+}
+/**
+ * 写入前校验三档字符串值。任何一档非法即整体拒绝，保证不落盘。
+ */
+export function validatePiModelMatrixTiers(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+        return {
+            ok: false,
+            code: "INVALID_INPUT",
+            message: "模型矩阵必须是 { LOW, MED, HIGH } 对象",
+        };
+    }
+    const record = input;
+    const tiers = {};
+    for (const tier of PI_MODEL_TIERS) {
+        const raw = record[tier];
+        const error = piModelTierValueError(raw);
+        if (error) {
+            return {
+                ok: false,
+                code: "INVALID_INPUT",
+                message: `${tier}: ${error}`,
+                tier,
+            };
+        }
+        tiers[tier] = raw;
+    }
+    return { ok: true, tiers };
+}
+async function readHarnessJson(repoRoot) {
+    try {
+        const raw = await readFile(path.join(repoRoot, "harness.json"), "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * 投影 harness.json executors.pi 三档（provider/model 或裸 model id）。
+ * 缺文件 / 非法 JSON / 未配置档位均优雅降级为缺省，绝不抛错。
+ */
+export async function readPiModelMatrixProjection(repoRoot) {
+    const manifest = await readHarnessJson(repoRoot);
+    const pi = manifest?.executors?.pi;
+    const projection = {};
+    if (!pi || typeof pi !== "object")
+        return projection;
+    for (const tier of PI_MODEL_TIERS) {
+        const selection = normalizeExecutorTierValue(pi[tier]);
+        if (!selection)
+            continue;
+        projection[tier] = {
+            model: selection.model,
+            ...(selection.provider ? { provider: selection.provider } : {}),
+            value: selection.provider
+                ? `${selection.provider}/${selection.model}`
+                : selection.model,
+        };
+    }
+    return projection;
+}
+/**
+ * 原子更新 harness.json executors.pi.LOW/MED/HIGH：
+ * 读全文档 → 校验 → 保留其余字段 → 写 tmp + fsync + rename。
+ */
+export async function writePiModelMatrix(repoRoot, tiers) {
+    const validation = validatePiModelMatrixTiers(tiers);
+    if (!validation.ok) {
+        throw Object.assign(new Error(validation.message), {
+            code: validation.code,
+        });
+    }
+    const file = path.join(repoRoot, "harness.json");
+    const manifest = await readHarnessJson(repoRoot);
+    if (!manifest) {
+        throw Object.assign(new Error("harness.json 不存在或不是合法 JSON"), {
+            code: "HARNESS_NOT_FOUND",
+        });
+    }
+    const executors = (manifest.executors ?? {});
+    const pi = (executors.pi ?? {});
+    const nextPi = { ...pi };
+    for (const tier of PI_MODEL_TIERS) {
+        nextPi[tier] = validation.tiers[tier];
+    }
+    const nextManifest = { ...manifest, executors: { ...executors, pi: nextPi } };
+    const body = `${JSON.stringify(nextManifest, null, 2)}\n`;
+    const tmp = path.join(repoRoot, `.harness.${process.pid}.${randomBytes(4).toString("hex")}.tmp`);
+    await writeFile(tmp, body, { encoding: "utf8" });
+    const handle = await open(tmp, "r+");
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    await rename(tmp, file);
+}

package/dist/worker/console/operator-actions.js

@@ -1,5 +1,5 @@
 import { access, readFile } from "node:fs/promises";
-import { buildOperatorCapabilitiesDocument } from "../../shared/operator/capabilities.js";
+import { buildOperatorCapabilitiesDocument, OFFICIAL_TAIL_ACTION_IDS, } from "../../shared/operator/capabilities.js";
 import { buildOperatorResult, operatorFailed, operatorSucceeded, } from "../../shared/operator/envelope.js";
 import { CANONICAL_TASK_ID_PATTERN, formatLocalBusinessDate, getTaskPaths, loadTaskConfig, } from "../../task/runtime.js";
 import { diffTaskContract, validateDraftForTask, } from "../../task/contract/index.js";
@@ -11,6 +11,7 @@ import { resolveLatestDagRunIdForTask } from "./resolve-dag-run-for-task.js";
 import { repoFingerprintV1 } from "./repo-fingerprint.js";
 import { scheduleOperation, } from "./operation-runner.js";
 import { readinessGateFailure, } from "./pi-readiness.js";
+import { validatePiModelMatrixTiers, writePiModelMatrix, } from "./harness-pi-model-matrix.js";
 import { isAssessmentFreshForDraft } from "./interview/assessment.js";
 import { applyGrillMeAnswer, draftSummary, emptyDraft, isDraftStructurallyComplete, nextGrillMeQuestion, } from "./interview/grill-me.js";
 import { toCanonicalDraftForCli, } from "./draft-store.js";
@@ -671,6 +672,80 @@ export async function dispatchOperatorAction(ctx, req) {
             const body = await runReadCli(ctx, ["dag", "report", "--run-id", runId, "--json"], "dag report");
             return { kind: "sync", status: body.ok ? 200 : 400, body };
         }
+        case "dagDoctor": {
+            const runId = str(p.runId) ?? str(p.dagRunId);
+            const args = ["dag", "doctor"];
+            if (runId)
+                args.push("--run-id", runId);
+            const body = await runReadCli(ctx, args, "dag doctor");
+            return { kind: "sync", status: body.ok ? 200 : 400, body };
+        }
+        case "dagStatus": {
+            const runId = str(p.runId) ?? str(p.dagRunId);
+            if (!runId)
+                return invalid(action, "runId is required");
+            const body = await runReadCli(ctx, ["dag", "status", "--run-id", runId], "dag status");
+            return { kind: "sync", status: body.ok ? 200 : 400, body };
+        }
+        case "workerPoolDoctor": {
+            const taskId = str(p.taskId);
+            const run = ctx.runCommand ??
+                ((args, options) => ctx.client.runExternal
+                    ? ctx.client.runExternal(resolveSiblingAgentWorkerBin(), args, options)
+                    : ctx.client.run(args, options));
+            let result;
+            try {
+                result = await run(["pool", "doctor", "--repo", ctx.repoRoot, "--json"], {
+                    cwd: ctx.repoRoot,
+                    artifactName: "read-pool-doctor",
+                    expectJson: true,
+                });
+            }
+            catch (error) {
+                return {
+                    kind: "error",
+                    status: 400,
+                    body: operatorFailed({
+                        command: action,
+                        outcome: "invalid",
+                        code: "INVALID_INPUT",
+                        message: `cannot read pool doctor facts: ${error instanceof Error ? error.message : String(error)}`,
+                    }),
+                };
+            }
+            if (!result.ok || result.exitCode !== 0 || !result.json) {
+                return {
+                    kind: "error",
+                    status: 400,
+                    body: operatorFailed({
+                        command: action,
+                        outcome: "invalid",
+                        code: "INVALID_INPUT",
+                        message: summarizeReadCliFailure(result),
+                    }),
+                };
+            }
+            const inventory = result.json;
+            if (!taskId) {
+                return {
+                    kind: "sync",
+                    status: 200,
+                    body: operatorSucceeded(action, inventory),
+                };
+            }
+            const v2 = (inventory.v2 ?? []).filter((entry) => entry.taskId === taskId);
+            const legacy = (inventory.legacy ?? []).filter((entry) => entry.taskId === taskId);
+            return {
+                kind: "sync",
+                status: 200,
+                body: operatorSucceeded(action, {
+                    ...inventory,
+                    v2,
+                    legacy,
+                    focusedTaskId: taskId,
+                }),
+            };
+        }
         case "status": {
             const taskId = str(p.taskId);
             if (!taskId) {
@@ -985,7 +1060,7 @@ export async function dispatchOperatorAction(ctx, req) {
             }
             if (operatorAction) {
                 const target = buildOperatorCapabilitiesDocument().actions.find((entry) => entry.action === operatorAction &&
-                    entry.description.startsWith("Official CLI action coverage") &&
+                    OFFICIAL_TAIL_ACTION_IDS.has(entry.action) &&
                     entry.humanConfirmation === "required");
                 if (!target)
                     return invalid(action, "operatorAction must name a required official action");
@@ -2483,12 +2558,61 @@ export async function dispatchOperatorAction(ctx, req) {
                 }),
             };
         }
+        case "savePiModelMatrix": {
+            // 「模型与认证」页模型矩阵编辑器：三档字符串值经校验后原子写入
+            // harness.json executors.pi，并自动重测 readiness。写路径本身由 HTTP
+            // 层 evaluateMutationGate 拦截（cookie + confirmation 头 + origin）。
+            const matrixInput = p.matrix ?? p;
+            const validation = validatePiModelMatrixTiers(matrixInput);
+            if (!validation.ok) {
+                return {
+                    kind: "error",
+                    status: 400,
+                    body: operatorFailed({
+                        command: action,
+                        outcome: "invalid",
+                        code: validation.code,
+                        message: validation.message,
+                        ...(validation.tier ? { details: { tier: validation.tier } } : {}),
+                    }),
+                };
+            }
+            try {
+                await writePiModelMatrix(ctx.repoRoot, validation.tiers);
+            }
+            catch (error) {
+                return {
+                    kind: "error",
+                    status: 500,
+                    body: operatorFailed({
+                        command: action,
+                        outcome: "blocked",
+                        code: "PI_MODEL_MATRIX_WRITE_FAILED",
+                        message: error instanceof Error ? error.message : String(error),
+                    }),
+                };
+            }
+            // 保存成功自动重测 readiness（复用 probePiReadiness），让页面立即
+            // 展示新的 modelsAvailable / modelsMessage / piModelMatrix（AC-4）。
+            const report = ctx.refreshReadiness
+                ? await ctx.refreshReadiness()
+                : ctx.getReadiness?.() ?? ctx.readiness;
+            return {
+                kind: "sync",
+                status: 200,
+                body: operatorSucceeded("savePiModelMatrix", {
+                    tiers: validation.tiers,
+                    readiness: report,
+                }),
+            };
+        }
         default: {
             // M5 official-command coverage uses one generic tail for newly registered
             // CLI actions. It remains inside dispatchOperatorAction (the sole dispatch
             // surface) and only accepts argv arrays declared by the capability schema.
-            const capability = buildOperatorCapabilitiesDocument().actions.find((entry) => entry.action === action &&
-                entry.description.startsWith("Official CLI action coverage"));
+            // 2026-08-18: high-frequency entries got real descriptions; membership is
+            // now derived from OFFICIAL_TAIL_ACTION_IDS, not description prefixes.
+            const capability = buildOperatorCapabilitiesDocument().actions.find((entry) => entry.action === action && OFFICIAL_TAIL_ACTION_IDS.has(entry.action));
             if (capability) {
                 const rawArgs = p.args;
                 if (rawArgs !== undefined &&

package/dist/worker/console/operator-user-error.js

@@ -1,4 +1,19 @@
 import { rewriteRecoveryOperatorError } from "./recovery-error-copy.js";
+/** Mutation-gate raw English messages (worker/console/security.ts) → copy. */
+const MUTATION_GATE_COPY = [
+    {
+        pattern: /invalid (boot capability|confirmation header) token/i,
+        copy: "页面已过期（控制台已重启），请刷新页面（F5）后重试。",
+    },
+    {
+        pattern: /mutation requires boot capability cookie|mutation requires confirmation header token/i,
+        copy: "页面状态异常，请刷新页面（F5）后重试。",
+    },
+    {
+        pattern: /Host header is required for non-loopback/i,
+        copy: "请求主机校验失败：非回环绑定时要求 Host 头，请刷新页面或检查访问地址。",
+    },
+];
 /** Map internal spawn/controller errors to actionable Chinese copy. */
 export function formatOperatorUserError(message) {
     const raw = (message ?? "").trim();
@@ -22,5 +37,9 @@ export function formatOperatorUserError(message) {
     if (/force-required|requires --force/i.test(raw)) {
         return "该终态需要强制 Discard。请确认后勾选强制再试。";
     }
+    for (const entry of MUTATION_GATE_COPY) {
+        if (entry.pattern.test(raw))
+            return entry.copy;
+    }
     return raw;
 }

package/dist/worker/console/pi-readiness.js

@@ -4,6 +4,7 @@
  */
 import path from "node:path";
 import { mapSnapshotAvailableModels, resolveHarnessPiExecutorMatrix, } from "./chat/model-resolver.js";
+import { readPiModelMatrixProjection, } from "./harness-pi-model-matrix.js";
 const SETUP_BLOCKED = Object.freeze([
     "newTask",
     "importPrd",
@@ -221,6 +222,7 @@ export async function discoverPiReadinessProbe(options) {
         authReady,
         modelsAvailable,
         interviewSessionOk,
+        piAvailableModels: availableModels,
         details: {
             sdkMessage: `Pi SDK 0.80.10 contract available (agentDir=${agentDir})`,
             authMessage: authReady
@@ -238,13 +240,18 @@ export async function discoverPiReadinessProbe(options) {
  * override is injected. Tests inject override for determinism.
  */
 export async function probePiReadiness(options) {
+    const repoRoot = options?.repoRoot ?? process.cwd();
+    // 模型矩阵投影与 SDK 探测解耦：即使 SDK 不可用 / 测试注入 override，仍要
+    // 投影 harness.json 三档值供模型矩阵编辑器预填（AC-1 / AC-4）。
+    const piModelMatrix = await readPiModelMatrixProjection(repoRoot);
     if (options?.override) {
-        return buildPiReadinessReport(options.override);
+        return buildPiReadinessReport({ ...options.override, piModelMatrix });
     }
     try {
         const probe = await discoverPiReadinessProbe({
             repoRoot: options?.repoRoot,
         });
+        probe.piModelMatrix = piModelMatrix;
         if (options?.siblingControllerOk && !probe.details) {
             probe.details = {};
         }