@tea-agent/loop-agent 0.39.0-next.24 → 0.39.0-next.26

package/CHANGELOG.md

@@ -4,6 +4,8 @@
 
 ### 变更
 
+- 将 `@earendil-works/pi-ai` 与 `@earendil-works/pi-coding-agent` 从可选依赖提升为精确 pin 的运行时依赖 `0.83.0`，将运行时直接导入的 `typebox` 精确声明为 `1.3.7`，并在根包声明 Node.js `>=22.19.0`。安装 `@tea-agent/loop-agent` 会默认装上 Pi SDK（含 `--omit=optional` 场景）；`@cursor/sdk` 仍保持 optional。availability / readiness 探针、隔离 tarball canary、发布包契约测试与安装/本地环境说明同步对齐。
+- backend-test Scenario Partition 仅接受绑定源有限 enum/分类集合的 GET/list query/path 轴；非法 Domain（空/重复/保留 token、无有限域、与 OpenAPI enum 不一致）报 `INVALID_PARTITION_DOMAIN` / `NO_FINITE_DOMAIN` / `PARTITION_SOURCE_MISMATCH` 根因，不再生成空后缀 `TP-SP-...-`、重复 slot，也不再级联 `MISSING_*_SLOT`。N6 对这些根因码 fail-closed；合法源分区缺槽仍阻断。N2 禁止为自由串/主键/required-only/boundary-only 建分区；N5 允许删除无源非法 Partition 及其派生槽位。
 - npm `next` 渠道发布改为提交数节流：main push 仅当距上次 next 发布的 source commit ≥ 5 个 commit 时才自动发布（新增 `scripts/next-publish-gate.mjs`，读已发布 tarball build-stamp 对比 HEAD）；不足阈值时 workflow 绿色跳过，手动 `workflow_dispatch` 不受限（切 release 线前强制出包 / 紧急补发）。发布文档真源 §4.1/§5.1/§7/§12 同步。
 
 ### 新增
@@ -31,6 +33,12 @@
 
 ### 改进
 
+- frontend-test prepare-package 会从 `docs/templates/`、`harness.json` `governanceRoot`/templates 以及 init 投影的 `ai_workspace/loop-agent/templates/` 拷贝标准场景；full init 目标仓不再静默落到仅含 `STD-FE-SMOKE-ENTRY` 的 fallback。
+- frontend-test 环境探测区分 connection-refused（curl 7）与 HTTP 4xx/5xx，并提示先启动本地前端后再从 probe 节点续跑；不再把所有不可达都写成同一句 `frontend-base-url-unreachable`。
+- frontend-test 报告解析用例 Markdown 的 `##`/`###` 标题与有序列表（`测试步骤` / `预期结果` / `前置条件与重置`）；缺 `测试目的` 时回退到用例 H1，避免主 HTML 出现空步骤。
+- `dag rerun --from-node` 把尚未启动的 writer/map 视为首次执行；frontend-test probe 这种失败的 exclusive shell 可以带着下游未跑节点续跑，不必整图 `standaloneTaskRerun`。
+- Pi SDK 节点在 stall watchdog（默认 15 分钟无 provider 活动）触发后，会先 abort 当前等待，并在同一会话自动发送一次「继续」；仅 abort 已确认且尚未调用 write 工具时恢复，失败仍判 timeout。绝对墙钟超时与 CLI 后端不走这条恢复。
+- DAG 节点检查器「执行过程」时间线默认展开原始协议事件（`message_start` / `message_end`），按钮文案为「隐藏原始协议事件」；用户可点选关闭，同会话内选择会保持。
 - Operator Chat 的乐观停止现在把“视觉已停止”和 Turn ownership 分开：Abort 获得可靠终态前明确显示“正在停止”，此时可为原会话保存一条服务端持久化的“停止后发送”消息；后一次覆盖前一次，切换会话、刷新页面或 Console 重启不会丢失，旧 Turn 结束后复用正常 Turn 准入路径自动发送，并以固定 `clientRequestId` 防止重复执行。
 - Operator Chat 修复快速终止时“停止后发送”与普通发送之间的准入空洞：发送路径改读实时 ownership；若 deferred 请求恰好撞上旧 Turn 终态，会先按服务端状态对账，再使用同一 `clientRequestId` 自动转为普通发送，不再要求用户刷新重试或丢失本次提交。
 - `dag rerun-task` 现在会把父 run 最后一轮仍未解决的 `verify-pi` / review 反馈、证据引用和修订轮次带入新完整 DAG；planner、implementer 与 verifier/reviewer 必须修复或举证说明不再适用，不能仅因文件已存在就返回 `already-satisfied`。Console 同步区分「自动修订」「从失败节点恢复」「带反馈重新执行任务」。

package/README.md

@@ -24,6 +24,8 @@
 
 ### 安装
 
+需要 Node.js `>=22.19.0`。建议先运行 `node --version` 确认环境满足要求；启用 npm `engine-strict` 时，旧版本 Node.js 会直接拒绝安装。
+
 ```bash
 npm install -g @tea-agent/loop-agent@latest
 loop-agent --version

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
   "version": "0.37.0",
-  "gitSha": "b89dac83463a5cf86ebac304b93bf894ecc53dc8",
-  "builtAt": "2026-08-20T16:19:50.694Z"
+  "gitSha": "261086956566acadb9df5ed94b528938cf8d058e",
+  "builtAt": "2026-08-21T12:44:01.132Z"
 }

package/dist/executors/pi-executor.js

@@ -408,6 +408,50 @@ export class BoundedTextPreview {
         ].join("\n");
     }
 }
+/**
+ * Normalize provider-specific completion-limit labels to the DAG's canonical
+ * `length` signal. Other terminal reasons remain observable without being
+ * treated as truncation.
+ */
+export function normalizeProviderStopReason(value) {
+    if (typeof value !== "string" || value.trim().length === 0)
+        return undefined;
+    const trimmed = value.trim();
+    const compact = trimmed.toLowerCase().replace(/[\s_-]/g, "");
+    if ([
+        "length",
+        "maxtokens",
+        "maxoutputtokens",
+        "outputlimit",
+        "tokenlimit",
+        "tokenlimitreached",
+    ].includes(compact)) {
+        return "length";
+    }
+    return trimmed;
+}
+/**
+ * Extract a terminal stop reason from the provider event shapes used by Pi
+ * SDK/CLI bridges. Providers disagree on `stop*` versus `finish*`; keep this
+ * boundary centralized so downstream DAG recovery sees one canonical signal.
+ */
+export function extractPiEventStopReason(event) {
+    const nested = [event.message, event.response, event.completion].filter(isRecord);
+    const containers = [...nested, event];
+    for (const container of containers) {
+        for (const key of [
+            "stopReason",
+            "stop_reason",
+            "finishReason",
+            "finish_reason",
+        ]) {
+            const normalized = normalizeProviderStopReason(container[key]);
+            if (normalized)
+                return normalized;
+        }
+    }
+    return undefined;
+}
 export class PiJsonlStreamCollector {
     lineBuffer = "";
     discardUntilNewline = false;
@@ -415,6 +459,7 @@ export class PiJsonlStreamCollector {
     parsedEvents = 0;
     tokensUsed = 0;
     outputTooLarge = false;
+    stopReason;
     subagentTotalCalls = 0;
     subagentFailedCalls = 0;
     subagentModes = new Set();
@@ -454,6 +499,7 @@ export class PiJsonlStreamCollector {
             assistantText: this.assistantText.trim(),
             outputTooLarge: this.outputTooLarge,
             parsedEvents: this.parsedEvents,
+            stopReason: this.stopReason,
             subagentStats: this.formatSubagentStats(),
             tokensUsed: this.tokensUsed,
         };
@@ -472,6 +518,10 @@ export class PiJsonlStreamCollector {
         }
     }
     consumeEvent(event) {
+        const stopReason = extractPiEventStopReason(event);
+        if (stopReason === "length" || !this.stopReason) {
+            this.stopReason = stopReason ?? this.stopReason;
+        }
         const candidate = extractAssistantTextFromEvent(event);
         if (candidate !== undefined) {
             if (candidate.length > MAX_ASSISTANT_TEXT_CHARS) {
@@ -865,6 +915,7 @@ async function executeSingleCliAttempt(options, modelConfig, promptFilePath) {
                 stdoutTruncated: stdoutPreview.truncated,
                 stderrTruncated: stderrPreview.truncated,
                 outputTooLarge: collected.outputTooLarge,
+                stopReason: collected.stopReason,
                 timedOut,
                 tokensUsed: collected.tokensUsed,
                 subagentStats: collected.subagentStats,

package/dist/executors/pi-sdk-executor.js

@@ -1,8 +1,15 @@
 import { appendFile, mkdir } from "node:fs/promises";
 import path from "node:path";
-import { BoundedTextPreview, classifyPiFailure, createPiJsonlStreamCollector, DEFAULT_ABORT_GRACE_MS, DEFAULT_STALL_TIMEOUT_MS, DEFAULT_TIMEOUT_MS, extractAssistantTextFromPiJson, } from "./pi-executor.js";
+import { BoundedTextPreview, classifyPiFailure, createPiJsonlStreamCollector, DEFAULT_ABORT_GRACE_MS, DEFAULT_STALL_TIMEOUT_MS, DEFAULT_TIMEOUT_MS, extractPiEventStopReason, extractAssistantTextFromPiJson, } from "./pi-executor.js";
 import { serializeSessionEvent } from "./pi-event-serializer.js";
 import { PI_RECOMMENDED_COMPACTION, PI_RECOMMENDED_RETRY, } from "../shared/pi-retry-settings.js";
+/** Same-session recovery after a transport stall. Exactly one continue per SDK attempt. */
+export const PI_SDK_STALL_CONTINUE_MAX = 1;
+/**
+ * Fixed follow-up sent after aborting a stalled prompt.
+ * Kept short so the model can resume without repeating the original task payload.
+ */
+export const PI_SDK_STALL_CONTINUE_PROMPT = "继续。上一轮因长时间无 provider 活动已被中止；请从中断处接着完成，不要重复已完成的步骤。若此前没有有效输出，请重新执行原任务。";
 let sdkSessionFactoryOverride;
 let sdkImportOverrideForTests;
 let sdkModuleOverrideForTests;
@@ -44,15 +51,15 @@ export async function resetPiSdkReuseScopeForTests() {
 export function setPiSdkSessionFactoryForTests(factory) {
     sdkSessionFactoryOverride = factory;
 }
-/** Test hook: simulate SDK import success/failure without relying on optionalDependency install state. */
+/** Test hook: simulate SDK import success/failure without relying on installed SDK state. */
 export function setPiSdkImportOverrideForTests(fn) {
     sdkImportOverrideForTests = fn;
 }
-/** Test hook: inject a mock Pi SDK module to exercise resolveSdkSessionFactory without optionalDependency. */
+/** Test hook: inject a mock Pi SDK module to exercise resolveSdkSessionFactory without loading the real SDK. */
 export function setPiSdkModuleOverrideForTests(fn) {
     sdkModuleOverrideForTests = fn;
 }
-/** Check whether the Pi SDK optional dependency satisfies the 0.80.10 runtime contract. */
+/** Check whether the Pi SDK runtime dependency satisfies the 0.83.0 runtime contract. */
 export async function checkPiSdkAvailability(_repoRoot) {
     if (sdkSessionFactoryOverride) {
         return { ok: true, detail: "pi SDK session factory override active" };
@@ -68,10 +75,10 @@ export async function checkPiSdkAvailability(_repoRoot) {
             typeof ModelRuntime?.create !== "function") {
             return {
                 ok: false,
-                detail: "pi SDK incompatible: requires createAgentSession, getAgentDir, and ModelRuntime.create (0.80.10 contract)",
+                detail: "pi SDK incompatible: requires createAgentSession, getAgentDir, and ModelRuntime.create (0.83.0 contract)",
             };
         }
-        return { ok: true, detail: "pi SDK 0.80.10 contract available" };
+        return { ok: true, detail: "pi SDK 0.83.0 contract available" };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -404,25 +411,6 @@ function extractSdkUsageSample(event) {
     const responseKey = responseKeyCandidates.find((value) => typeof value === "string" && value.length > 0);
     return responseKey ? { responseKey, tokens } : { tokens };
 }
-/** Extract a non-empty stop reason from a terminal SDK event.
- * Probes multiple field shapes across SDK versions so a missing field fails
- * open (undefined) rather than misclassifying an attempt. */
-function readStopReason(event) {
-    const message = isRecord(event.message) ? event.message : undefined;
-    const candidates = [
-        message?.stop_reason,
-        message?.stopReason,
-        event.stopReason,
-        event.stop_reason,
-    ];
-    for (const candidate of candidates) {
-        if (typeof candidate === "string" &&
-            candidate.trim().length > 0) {
-            return candidate.trim();
-        }
-    }
-    return undefined;
-}
 function aggregateSdkTokenUsage(samples) {
     const identified = new Map();
     let anonymousMaximum = 0;
@@ -444,6 +432,8 @@ function aggregateSdkTokenUsage(samples) {
  * When reuseScope is active, only shared auth/model resources are reused; each attempt still
  * creates and disposes its own session and resource loader. Session reuse across steps is
  * deferred until a proven reset/isolation strategy exists.
+ * A transport stall may abort the current prompt and send one continue on the
+ * same session; that is in-attempt recovery, not cross-step session reuse.
  */
 export async function executeSingleSdkAttempt(options) {
     const modelConfig = options.modelConfig;
@@ -494,7 +484,7 @@ export async function executeSingleSdkAttempt(options) {
             type === "message_end" ||
             type === "agent_end" ||
             type === "agent_settled") {
-            const candidate = readStopReason(event);
+            const candidate = extractPiEventStopReason(event);
             if (candidate)
                 stopReason = candidate;
         }
@@ -559,16 +549,30 @@ export async function executeSingleSdkAttempt(options) {
         let resolveStall;
         let resolveSettlement;
         let settled = false;
-        const settlementPromise = new Promise((resolve) => {
-            resolveSettlement = resolve;
-        });
-        const stallPromise = stallTimeoutMs > 0
-            ? new Promise((resolve) => {
+        let abortConfirmed = true;
+        const persistRuntimeNote = (event) => {
+            const line = serializeSessionEvent(event);
+            stdoutPreview.append(`${line}\n`);
+            stdoutCollector.append(`${line}\n`);
+            sessionEventAppender?.append(line, event);
+        };
+        const resetSettlement = () => {
+            settled = false;
+            return new Promise((resolve) => {
+                resolveSettlement = resolve;
+            });
+        };
+        const resetStallPromise = () => {
+            if (stallTimeoutMs <= 0) {
+                resolveStall = undefined;
+                return null;
+            }
+            return new Promise((resolve) => {
                 resolveStall = resolve;
-            })
-            : null;
+            });
+        };
         const armStallWatchdog = () => {
-            if (!stallPromise || !resolveStall)
+            if (stallTimeoutMs <= 0 || !resolveStall)
                 return;
             if (stallHandle)
                 clearTimeout(stallHandle);
@@ -609,17 +613,6 @@ export async function executeSingleSdkAttempt(options) {
             stdoutCollector.append(`${line}\n`);
             sessionEventAppender?.append(line, event);
         });
-        const filePrefix = options.attachedFiles
-            .map((file) => `@${file}`)
-            .join(" ");
-        const promptMessage = filePrefix
-            ? `${filePrefix}\n${options.userMessage}`
-            : options.userMessage;
-        const promptPromise = session.prompt(promptMessage);
-        // A settlement event is permitted to win the race while prompt() remains
-        // pending. Observe a later rejection so it never becomes unhandled.
-        void promptPromise.catch(() => { });
-        armStallWatchdog();
         const timeoutPromise = timeoutMs > 0
             ? new Promise((resolve) => {
                 timeoutHandle = setTimeout(() => {
@@ -627,21 +620,79 @@ export async function executeSingleSdkAttempt(options) {
                 }, timeoutMs);
             })
             : null;
-        const raced = await Promise.race([
-            promptPromise.then(() => "done"),
-            settlementPromise,
-            ...(timeoutPromise ? [timeoutPromise] : []),
-            ...(stallPromise ? [stallPromise] : []),
-        ]);
-        if (raced !== "done" && raced !== "settled") {
-            timedOut = true;
-            appendStderr(raced === "stall"
-                ? `pi SDK step stalled after ${stallTimeoutMs}ms with no provider activity`
-                : `pi SDK step timed out after ${timeoutMs}ms`);
-            const abortConfirmed = await runSessionActionWithGrace("abort", () => session.abort());
+        const runTurn = async (userMessage) => {
+            const settlementPromise = resetSettlement();
+            const stallPromise = resetStallPromise();
+            const promptPromise = session.prompt(userMessage);
+            // A settlement event is permitted to win the race while prompt() remains
+            // pending. Observe a later rejection so it never becomes unhandled.
+            void promptPromise.catch(() => { });
+            armStallWatchdog();
+            return Promise.race([
+                promptPromise.then(() => "done"),
+                settlementPromise,
+                ...(timeoutPromise ? [timeoutPromise] : []),
+                ...(stallPromise ? [stallPromise] : []),
+            ]);
+        };
+        const disposeSession = async () => {
             disposeAttempted = true;
             const disposeConfirmed = await runSessionActionWithGrace("dispose", () => session.dispose());
             terminationConfirmed = abortConfirmed && disposeConfirmed;
+        };
+        const failClosedAfterWait = async (reason, extraStderr, abortFirst = true) => {
+            timedOut = true;
+            appendStderr(reason === "stall"
+                ? `pi SDK step stalled after ${stallTimeoutMs}ms with no provider activity`
+                : `pi SDK step timed out after ${timeoutMs}ms`);
+            if (extraStderr)
+                appendStderr(extraStderr);
+            if (abortFirst) {
+                abortConfirmed = await runSessionActionWithGrace("abort", () => session.abort());
+            }
+            await disposeSession();
+        };
+        const filePrefix = options.attachedFiles
+            .map((file) => `@${file}`)
+            .join(" ");
+        const promptMessage = filePrefix
+            ? `${filePrefix}\n${options.userMessage}`
+            : options.userMessage;
+        let continuesSent = 0;
+        let raced = await runTurn(promptMessage);
+        if (raced === "stall") {
+            abortConfirmed = await runSessionActionWithGrace("abort", () => session.abort());
+            const withinAbsoluteTimeout = timeoutMs <= 0 || Date.now() - startedAt < timeoutMs;
+            const canContinue = abortConfirmed &&
+                writeToolCallCount === 0 &&
+                withinAbsoluteTimeout &&
+                continuesSent < PI_SDK_STALL_CONTINUE_MAX;
+            if (canContinue) {
+                // The aborted turn's stopReason must not leak onto a recovered continue.
+                stopReason = undefined;
+                continuesSent += 1;
+                persistRuntimeNote({
+                    type: "loop-agent-stall-continue",
+                    prompt: PI_SDK_STALL_CONTINUE_PROMPT,
+                    maxContinues: PI_SDK_STALL_CONTINUE_MAX,
+                });
+                raced = await runTurn(PI_SDK_STALL_CONTINUE_PROMPT);
+                if (raced !== "done" && raced !== "settled") {
+                    await failClosedAfterWait(raced === "stall" ? "stall" : "absolute-timeout", raced === "stall"
+                        ? "pi SDK stall continue did not recover; treating as timeout"
+                        : "pi SDK stall continue hit the absolute timeout", true);
+                }
+            }
+            else {
+                await failClosedAfterWait("stall", !abortConfirmed
+                    ? undefined
+                    : writeToolCallCount > 0
+                        ? "pi SDK stall continue skipped because write tools already ran"
+                        : "pi SDK stall continue skipped because absolute timeout elapsed", false);
+            }
+        }
+        else if (raced === "absolute-timeout") {
+            await failClosedAfterWait("absolute-timeout");
         }
     }
     catch (error) {

package/dist/executors/shell-executor.js

@@ -15,6 +15,8 @@ import { materializeBackendTestAnalysisContract } from "../workflows/dag/backend
 import { extractBackendTestContractEnvelope } from "../workflows/dag/backend-test-contract-envelope.js";
 import { materializeFrontendImplementationContract } from "../workflows/dag/frontend-implementation-contract.js";
 import { materializeFrontendTestResult, validateFrontendCaseEvidence, } from "../workflows/dag/frontend-test-result-contract.js";
+import { copyFrontendTestStandardScenarios } from "../workflows/dag/frontend-test-standard-scenarios.js";
+import { probeFrontendTestEnvironment } from "../workflows/dag/frontend-test-environment-probe.js";
 import { renderFrontendTestL5Report } from "../workflows/dag/frontend-test-l5-report.js";
 import { validateFrontendCaseChecklist } from "../workflows/dag/frontend-test-case-checklist.js";
 import { materializeFrontendTestCaseManifest } from "../workflows/dag/frontend-test-case-manifest.js";
@@ -704,7 +706,7 @@ async function executeBackendTestPipeline(input, meta) {
                 // coverage findings stay advisory, but a declared filter axis missing
                 // an each-value/omitted slot or its complement slot must block pytest
                 // generation until the Markdown declares the slot.
-                const partitionBlocking = coverage.facts.findings.filter((finding) => /^(?:MISSING_PARTITION|MISSING_PARTITION_SLOT|MISSING_COMPLEMENT_SLOT|MISSING_PARTITION_TABLE)/.test(finding));
+                const partitionBlocking = coverage.facts.findings.filter((finding) => /^(?:MISSING_PARTITION|MISSING_PARTITION_SLOT|MISSING_COMPLEMENT_SLOT|MISSING_PARTITION_TABLE|INVALID_PARTITION_DOMAIN|NO_FINITE_DOMAIN|PARTITION_SOURCE_MISMATCH)/.test(finding));
                 if (partitionBlocking.length > 0) {
                     return {
                         ok: false,
@@ -2061,6 +2063,52 @@ async function executeFrontendTestHtmlReport(input, meta) {
         };
     }
 }
+async function executeFrontendTestStandardScenarios(input) {
+    const started = Date.now();
+    try {
+        const result = await copyFrontendTestStandardScenarios({
+            workspaceRoot: input.cwd,
+        });
+        return {
+            ok: true,
+            stdout: JSON.stringify(result),
+            stderr: "",
+            failureCategory: "success",
+            durationMs: Date.now() - started,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            stdout: "",
+            stderr: error instanceof Error ? error.message : String(error),
+            failureCategory: "invalid-output",
+            durationMs: Date.now() - started,
+        };
+    }
+}
+async function executeFrontendTestEnvironmentProbe(input) {
+    const started = Date.now();
+    const result = await probeFrontendTestEnvironment({
+        workspaceRoot: input.cwd,
+    });
+    if (result.ok) {
+        return {
+            ok: true,
+            stdout: result.stdout,
+            stderr: "",
+            failureCategory: "success",
+            durationMs: Date.now() - started,
+        };
+    }
+    return {
+        ok: false,
+        stdout: "",
+        stderr: result.stderr,
+        failureCategory: "nonzero-exit",
+        durationMs: Date.now() - started,
+    };
+}
 async function executeFrontendTestEvidenceValidation(input) {
     const started = Date.now();
     try {
@@ -2339,6 +2387,12 @@ export async function executeDagShellNode(input, meta) {
             };
         }
     }
+    if (shell?.frontendTestStandardScenarios) {
+        return executeFrontendTestStandardScenarios(input);
+    }
+    if (shell?.frontendTestEnvironmentProbe) {
+        return executeFrontendTestEnvironmentProbe(input);
+    }
     if (shell?.frontendBrowserToolPreflight) {
         const started = Date.now();
         try {

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

@@ -85,7 +85,7 @@ function hasProviderConfig(snapshot) {
 /**
  * Discover live Pi SDK / auth / model readiness via ModelRuntime.
  * Kept inside worker/console (dynamic import) so Worker does not depend on
- * executors; contract matches pi-sdk-executor 0.80.10.
+ * executors; contract matches pi-sdk-executor 0.83.0.
  */
 export async function discoverPiReadinessProbe(options) {
     const repoRoot = options?.repoRoot ?? process.cwd();
@@ -118,7 +118,7 @@ export async function discoverPiReadinessProbe(options) {
             modelsAvailable: false,
             interviewSessionOk: false,
             details: {
-                sdkMessage: "Pi SDK incompatible: requires createAgentSession, getAgentDir, and ModelRuntime.create (0.80.10)",
+                sdkMessage: "Pi SDK incompatible: requires createAgentSession, getAgentDir, and ModelRuntime.create (0.83.0)",
                 authMessage: "skipped (sdk incompatible)",
                 modelsMessage: "skipped (sdk incompatible)",
                 sessionMessage: "skipped (sdk incompatible)",
@@ -159,7 +159,7 @@ export async function discoverPiReadinessProbe(options) {
             modelsAvailable: false,
             interviewSessionOk: false,
             details: {
-                sdkMessage: "Pi SDK 0.80.10 contract available",
+                sdkMessage: "Pi SDK 0.83.0 contract available",
                 authMessage: `ModelRuntime.create failed: ${message}`,
                 modelsMessage: "skipped (runtime init failed)",
                 sessionMessage: "skipped (runtime init failed)",
@@ -224,7 +224,7 @@ export async function discoverPiReadinessProbe(options) {
         interviewSessionOk,
         piAvailableModels: availableModels,
         details: {
-            sdkMessage: `Pi SDK 0.80.10 contract available (agentDir=${agentDir})`,
+            sdkMessage: `Pi SDK 0.83.0 contract available (agentDir=${agentDir})`,
             authMessage: authReady
                 ? `credentials/providers ready (available=${availableCount}, providerConfig=${providerConfigured})`
                 : "no available models and no stored/configured provider credentials (set Pi auth or provider API keys)",

package/dist/worker/observe/static/state.js

@@ -76,8 +76,8 @@ export const uiState = {
 	dagNodeExecutionOutputLoading: false,
 	dagNodeExecutionOutputError: null,
 	dagNodeExecutionOutputKey: null,
-	/** When true,「执行过程」展开 message_start/end 原始协议事件。 */
-	sessionTimelineShowProtocol: false,
+	/** When true,「执行过程」展开 message_start/end 原始协议事件。默认展开，用户可点选隐藏。 */
+	sessionTimelineShowProtocol: true,
 	/** Open <details> keys restored across timeline re-renders. */
 	sessionTimelineOpenDetails: null,
 	lastSnapshot: null,

package/dist/worker/observe/static/views/session-timeline.js

@@ -439,12 +439,25 @@ function ensureOpenDetailsSet() {
 	return uiState.sessionTimelineOpenDetails;
 }
 
-function bindDetailsToggle(details, detailKey) {
+function closedDetailKey(detailKey) {
+	return `${detailKey}::user-closed`;
+}
+
+function bindDetailsToggle(details, detailKey, defaultOpen = false) {
 	const openSet = ensureOpenDetailsSet();
-	if (openSet.has(detailKey)) details.open = true;
+	if (defaultOpen) {
+		if (!openSet.has(closedDetailKey(detailKey))) details.open = true;
+	} else if (openSet.has(detailKey)) {
+		details.open = true;
+	}
 	details.addEventListener("toggle", () => {
-		if (details.open) openSet.add(detailKey);
-		else openSet.delete(detailKey);
+		if (details.open) {
+			openSet.add(detailKey);
+			openSet.delete(closedDetailKey(detailKey));
+		} else {
+			openSet.delete(detailKey);
+			openSet.add(closedDetailKey(detailKey));
+		}
 	});
 }
 
@@ -599,7 +612,7 @@ function renderProtocolCard(item) {
 	const details = document.createElement("details");
 	details.className = "process-timeline-details";
 	details.dataset.detailKey = item.detailKey;
-	bindDetailsToggle(details, item.detailKey);
+	bindDetailsToggle(details, item.detailKey, true);
 	const summary = document.createElement("summary");
 	summary.className = "process-timeline-summary";
 	summary.textContent = `消息收发 · ${item.protocolCount} 条协议事件`;

package/dist/workflows/dag/backend-test-case-coverage-analysis.js

@@ -5,7 +5,7 @@ import path from "node:path";
 import { z } from "zod";
 import YAML from "yaml";
 import { resolveBackendTestLayout, } from "./backend-test-layout.js";
-import { assessScenarioPartitionCoverage, parseScenarioPartitions, } from "./backend-test-scenario-partitions.js";
+import { applyOpenApiPartitionDomainPolicy, assessScenarioPartitionCoverage, parseScenarioPartitions, } from "./backend-test-scenario-partitions.js";
 import { backendTestCaseManifestSchema, computeCaseManifestCoverageSummary, } from "./backend-test-case-manifest.js";
 const CASE_HEADING = /^##\s+(BE-[A-Z0-9_-]+-\d{3})\b.*$/gm;
 const CASE_ID_IN_TEXT = /\bBE-[A-Z0-9_-]+-\d{3}\b/g;
@@ -486,6 +486,55 @@ export async function extractBackendTestOpenApiRules(input) {
     }
     return rules.sort((left, right) => left.ruleKey.localeCompare(right.ruleKey));
 }
+export async function extractBackendTestOpenApiPartitionAxes(input) {
+    const axes = [];
+    const seen = new Set();
+    for (const referencePath of input.sourceBinding.referencePaths) {
+        const physicalPath = resolveBoundSourcePath(input.workspaceRoot, input.sourceBinding.taskId, referencePath);
+        let document;
+        try {
+            const parsed = YAML.parse(await readFile(physicalPath, "utf8"));
+            if (!isRecord(parsed) || !isRecord(parsed.paths))
+                continue;
+            document = parsed;
+        }
+        catch {
+            continue;
+        }
+        for (const [apiPath, pathItem] of Object.entries(document.paths)) {
+            if (!isRecord(pathItem))
+                continue;
+            const operation = pathItem.get;
+            if (!isRecord(operation))
+                continue;
+            const parameterValues = [
+                ...(Array.isArray(pathItem.parameters) ? pathItem.parameters : []),
+                ...(Array.isArray(operation.parameters) ? operation.parameters : []),
+            ];
+            for (const rawParameter of parameterValues) {
+                const parameter = resolveOpenApiSchema(document, rawParameter);
+                if (!parameter || typeof parameter.name !== "string")
+                    continue;
+                const location = parameter.in === "path" ? "path" : parameter.in === "query" ? "query" : undefined;
+                if (!location)
+                    continue;
+                const property = resolveOpenApiSchema(document, parameter.schema);
+                const enumValues = property && Array.isArray(property.enum) ? property.enum.map(String) : null;
+                const identity = `GET ${apiPath}|${location}|${parameter.name}`;
+                if (seen.has(identity))
+                    continue;
+                seen.add(identity);
+                axes.push({
+                    operation: `GET ${apiPath}`,
+                    name: parameter.name,
+                    in: location,
+                    enumValues,
+                });
+            }
+        }
+    }
+    return axes;
+}
 function orderedUnique(values) {
     const result = [];
     const seen = new Set();
@@ -985,8 +1034,11 @@ export async function analyzeBackendTestCaseCoverage(input) {
     // Plan C: deterministic query/filter axis partitions (fail-closed on missing slots).
     const parsedPartitions = parseScenarioPartitions(readme);
     findings.push(...parsedPartitions.issues);
+    const openApiPartitionAxes = await extractBackendTestOpenApiPartitionAxes(input);
+    const partitionedBySource = applyOpenApiPartitionDomainPolicy(parsedPartitions.partitions, openApiPartitionAxes);
+    findings.push(...partitionedBySource.issues);
     const declaredPointUniverse = new Set(cases.flatMap((item) => item.testPoints));
-    const partitionAssessment = assessScenarioPartitionCoverage(parsedPartitions.partitions, declaredPointUniverse);
+    const partitionAssessment = assessScenarioPartitionCoverage(partitionedBySource.partitions, declaredPointUniverse);
     findings.push(...partitionAssessment.findings);
     const [enumValueCount, coveredEnumValueCount] = dimensionCounts(rules, /enum/);
     const [boundaryPointCount, coveredBoundaryPointCount] = dimensionCounts(rules, /boundary|length|numeric/);