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

package/CHANGELOG.md

@@ -33,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/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
   "version": "0.37.0",
-  "gitSha": "4ed797bca2d5bae62dbd6648d7a437848b35188a",
-  "builtAt": "2026-08-21T00:52:48.673Z"
+  "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;
@@ -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";
@@ -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/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/frontend-test-case-quality.js

@@ -1,25 +1,17 @@
 import { readFile, writeFile, mkdir } from "node:fs/promises";
 import path from "node:path";
+import { markdownSection } from "./frontend-test-markdown.js";
 const CASE_ID = /^FE-[A-Za-z0-9]+-\d{3}-(?:core|boundary|flow|backend)$/i;
 const AC_ID = /^AC(?:-[A-Z0-9]+)+$/i;
 const PLACEHOLDER = /\b(?:TODO|TBD|FIXME)\b|结果正确|页面正常|按实际情况处理|验证成功/i;
 const SECTION_ALIASES = {
     purpose: ["Test Purpose", "测试目的", "测试场景"],
     source: ["Source References", "需求依据"],
-    preconditions: ["Preconditions", "前置条件"],
-    steps: ["Steps", "操作步骤"],
+    preconditions: ["Preconditions", "前置条件", "前置条件与重置"],
+    steps: ["Test Steps", "测试步骤", "Steps", "操作步骤"],
     expected: ["Expected Results", "预期结果"],
     automation: ["Automation Notes", "自动化映射", "自动化说明"],
 };
-function section(body, names) {
-    const marker = new RegExp(`^###\\s+(?:${names.map((v) => v.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&")).join("|")})\\s*$`, "mi");
-    const hit = marker.exec(body);
-    if (!hit)
-        return "";
-    const rest = body.slice(hit.index + hit[0].length);
-    const next = /^###\s+/m.exec(rest);
-    return rest.slice(0, next?.index ?? rest.length).trim();
-}
 function hasList(value) { return /^\s*(?:\d+[.)]|[-*+])\s+\S+/m.test(value); }
 function hasAssertion(value) { return /(?:status|状态|包含|显示|等于|为|可见|不可见|跳转|错误|成功|失败|should|expect|assert|must)/i.test(value); }
 export async function validateFrontendCaseContent(input) {
@@ -69,9 +61,9 @@ export async function validateFrontendCaseContent(input) {
         if (PLACEHOLDER.test(body))
             findings.push({ ruleId: "placeholder-wording", caseId: id, detail: "case contains placeholder or non-assertable wording" });
         for (const [key, names] of Object.entries(SECTION_ALIASES))
-            if (!section(body, names))
+            if (!markdownSection(body, names))
                 findings.push({ ruleId: `missing-${key}`, caseId: id, detail: `missing section: ${names.join(" or ")}` });
-        const steps = section(body, SECTION_ALIASES.steps), expected = section(body, SECTION_ALIASES.expected);
+        const steps = markdownSection(body, SECTION_ALIASES.steps), expected = markdownSection(body, SECTION_ALIASES.expected);
         if (!hasList(steps))
             findings.push({ ruleId: "unstructured-steps", caseId: id, detail: "steps should contain numbered or bulleted executable actions" });
         if (!hasList(expected) || !hasAssertion(expected))

package/dist/workflows/dag/frontend-test-environment-probe.js

@@ -0,0 +1,227 @@
+import { spawnSync } from "node:child_process";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+export const FRONTEND_TEST_CONTEXT_REL = "testcase/frontend/rag/context.md";
+export const FRONTEND_TEST_PROBE_REL = "testcase/frontend/rag/environment-probe.json";
+const CONNECTION_REFUSED_HINT = "被测服务未在 baseUrl 监听（connection refused）。请先启动本地前端（例如 scripts/serve.sh 或项目约定的 npm start），确认可访问后再从 materialize-frontend-test-execution-shell 续跑。";
+export function classifyFrontendBaseUrlProbeFailure(input) {
+    if (input.spawnError)
+        return { errorClass: "spawn-error" };
+    const exit = input.curlExit ?? 0;
+    if (exit === 7) {
+        return { errorClass: "connection-refused", hint: CONNECTION_REFUSED_HINT };
+    }
+    if (exit === 6) {
+        return {
+            errorClass: "dns-unresolved",
+            hint: "无法解析 baseUrl 主机名。确认 context.md 中的地址可在本机解析，或改用 127.0.0.1。",
+        };
+    }
+    if (exit === 28) {
+        return {
+            errorClass: "connect-timeout",
+            hint: "连接 baseUrl 超时。确认被测服务已启动且端口可访问。",
+        };
+    }
+    if (exit !== 0)
+        return { errorClass: `curl-exit-${exit}` };
+    if (input.httpStatus && Number.isFinite(input.httpStatus)) {
+        return { errorClass: `http-${input.httpStatus}` };
+    }
+    return { errorClass: "unreachable" };
+}
+function defaultCurlRunner(args) {
+    const result = spawnSync("curl", [...args], { encoding: "utf8" });
+    return {
+        status: result.status,
+        stdout: result.stdout ?? "",
+        stderr: result.stderr ?? "",
+        error: result.error,
+    };
+}
+function redactUrl(value) {
+    try {
+        const parsed = new URL(value);
+        parsed.username = "";
+        parsed.password = "";
+        parsed.search = "";
+        return parsed.toString();
+    }
+    catch {
+        return value.replace(/\/\/[^@\s]+@/g, "//");
+    }
+}
+function resolveBaseUrl(context) {
+    const patterns = [
+        /baseUrl\s*[:=]\s*["'`]?((?:https?):\/\/[^\s"'`<>]+)/i,
+        /base[-_ ]url\s*[:=]\s*["'`]?((?:https?):\/\/[^\s"'`<>]+)/i,
+        /playwright-cli open --browser=chrome\s+((?:https?):\/\/[^\s"'`<>]+)/i,
+        /(https?:\/\/(?:localhost|127\.0\.0\.1)[^\s)}\],"']*)/i,
+    ];
+    for (const pattern of patterns) {
+        const match = context.match(pattern);
+        if (match?.[1])
+            return match[1].replace(/[)}\],"'.`]+$/g, "");
+    }
+    return null;
+}
+async function writeProbe(workspaceRoot, probe) {
+    const probePath = path.join(workspaceRoot, FRONTEND_TEST_PROBE_REL);
+    const contextPath = path.join(workspaceRoot, FRONTEND_TEST_CONTEXT_REL);
+    await mkdir(path.dirname(probePath), { recursive: true });
+    await writeFile(probePath, `${JSON.stringify(probe, null, 2)}\n`, "utf8");
+    let context = "";
+    try {
+        context = await readFile(contextPath, "utf8");
+    }
+    catch {
+        context = "";
+    }
+    const line = `environmentProbe: ${probe.status}${probe.blockedReason ? ` (${probe.blockedReason})` : ""}`;
+    const next = /environmentProbe\s*[:=]/i.test(context)
+        ? context.replace(/environmentProbe\s*[:=]\s*.*/i, line)
+        : `${context.trimEnd()}\n\n${line}\n`;
+    await writeFile(contextPath, next, "utf8");
+}
+export async function probeFrontendTestEnvironment(input) {
+    const curl = input.curl ?? defaultCurlRunner;
+    const contextPath = path.join(input.workspaceRoot, FRONTEND_TEST_CONTEXT_REL);
+    let context;
+    try {
+        context = await readFile(contextPath, "utf8");
+    }
+    catch {
+        return { ok: false, stderr: `missing ${FRONTEND_TEST_CONTEXT_REL}` };
+    }
+    const rawUrl = resolveBaseUrl(context);
+    if (!rawUrl) {
+        return {
+            ok: false,
+            stderr: "frontend-test preflight missing absolute baseUrl from context.md",
+        };
+    }
+    let parsed;
+    try {
+        parsed = new URL(rawUrl);
+    }
+    catch {
+        return { ok: false, stderr: `baseUrl must be absolute http(s): ${rawUrl}` };
+    }
+    if ((parsed.protocol !== "http:" && parsed.protocol !== "https:") ||
+        parsed.username ||
+        parsed.password ||
+        parsed.search ||
+        parsed.hash) {
+        return {
+            ok: false,
+            stderr: `unsafe baseUrl from context.md: ${redactUrl(rawUrl)}`,
+        };
+    }
+    if (/(?:^|\.)(?:www\.)?[^.]*?(?:prod|production)/i.test(parsed.hostname)) {
+        return {
+            ok: false,
+            stderr: `production URL forbidden: ${redactUrl(rawUrl)}`,
+        };
+    }
+    const baseUrl = parsed.toString();
+    const safe = redactUrl(baseUrl);
+    const sourceMatch = context.match(/baseUrlSource\s*[:=]\s*([^\r\n]+)/i);
+    const baseUrlSource = sourceMatch ? sourceMatch[1].trim() : "context.md";
+    const failBlocked = async (reason, extra) => {
+        const probe = {
+            status: "unreachable",
+            blockedReason: reason,
+            baseUrlRedacted: extra.baseUrlRedacted ?? safe,
+            httpStatus: extra.httpStatus ?? null,
+            method: extra.method ?? null,
+            curlExit: extra.curlExit ?? null,
+            errorClass: extra.errorClass ?? null,
+            ...(extra.hint ? { hint: extra.hint } : {}),
+            ...(extra.baseUrlSource ? { baseUrlSource: extra.baseUrlSource } : {}),
+        };
+        await writeProbe(input.workspaceRoot, probe);
+        const payload = {
+            blockedReason: reason,
+            baseUrl: probe.baseUrlRedacted,
+            httpStatus: probe.httpStatus,
+            errorClass: probe.errorClass,
+            ...(probe.hint ? { hint: probe.hint } : {}),
+        };
+        return {
+            ok: false,
+            stderr: `frontend-test preflight blocked: ${JSON.stringify(payload)}`,
+            probe,
+        };
+    };
+    const curlCheck = curl(["--version"]);
+    if (curlCheck.error || curlCheck.status !== 0) {
+        return failBlocked("curl-unavailable", {
+            baseUrlRedacted: safe,
+            errorClass: "curl-missing",
+        });
+    }
+    const probeMethod = (method) => curl([
+        "-sS",
+        "-o",
+        "/dev/null",
+        "-w",
+        "%{http_code}",
+        "--connect-timeout",
+        "3",
+        "--max-time",
+        "8",
+        "-X",
+        method,
+        "-L",
+        "--max-redirs",
+        "3",
+        "--http1.1",
+        "--proto-redir",
+        "=http,https",
+        safe,
+    ]);
+    let used = "HEAD";
+    let result = probeMethod("HEAD");
+    let code = String(result.stdout || "").trim();
+    let statusNum = Number.parseInt(code, 10);
+    const headRejected = result.status !== 0 || !statusNum || statusNum === 405 || statusNum === 501;
+    if (headRejected) {
+        used = "GET";
+        result = probeMethod("GET");
+        code = String(result.stdout || "").trim();
+        statusNum = Number.parseInt(code, 10);
+    }
+    const ok = statusNum >= 200 && statusNum < 400;
+    if (!ok) {
+        const classified = classifyFrontendBaseUrlProbeFailure({
+            spawnError: Boolean(result.error),
+            curlExit: result.status,
+            httpStatus: Number.isFinite(statusNum) ? statusNum : null,
+        });
+        return failBlocked("frontend-base-url-unreachable", {
+            baseUrlRedacted: safe,
+            httpStatus: Number.isFinite(statusNum) ? statusNum : null,
+            method: used,
+            curlExit: result.status,
+            errorClass: classified.errorClass,
+            hint: classified.hint,
+        });
+    }
+    const probe = {
+        status: "reachable",
+        blockedReason: null,
+        baseUrl: safe,
+        baseUrlRedacted: safe,
+        baseUrlSource,
+        httpStatus: statusNum,
+        method: used,
+        curlExit: result.status,
+        errorClass: null,
+    };
+    await writeProbe(input.workspaceRoot, probe);
+    return {
+        ok: true,
+        stdout: `frontend-test-execution-v1 validated contextBaseUrl=${safe} source=${baseUrlSource} probe=reachable method=${used} httpStatus=${statusNum}`,
+        probe,
+    };
+}

package/dist/workflows/dag/frontend-test-markdown.js

@@ -0,0 +1,61 @@
+/**
+ * Bounded ATX section/list parsing for frontend-test case Markdown.
+ * Generator cases use `##` headings; older fixtures use `###`.
+ */
+const ATX_HEADING = /^(#{1,3})\s+(\S.*)$/;
+function headingMatches(title, names) {
+    const normalized = title.trim();
+    return names.some((name) => {
+        if (normalized === name)
+            return true;
+        return (normalized.startsWith(name) &&
+            (normalized.length === name.length ||
+                /[\s:：与(（-]/.test(normalized.charAt(name.length))));
+    });
+}
+export function markdownSection(body, names) {
+    const lines = body.replace(/\r\n/g, "\n").split("\n");
+    let start = -1;
+    let startLevel = 0;
+    for (let index = 0; index < lines.length; index += 1) {
+        const match = ATX_HEADING.exec(lines[index]);
+        if (!match)
+            continue;
+        if (!headingMatches(match[2], names))
+            continue;
+        start = index;
+        startLevel = match[1].length;
+        break;
+    }
+    if (start < 0)
+        return "";
+    const collected = [];
+    for (let index = start + 1; index < lines.length; index += 1) {
+        const match = ATX_HEADING.exec(lines[index]);
+        if (match && match[1].length <= startLevel)
+            break;
+        collected.push(lines[index]);
+    }
+    return collected.join("\n").trim();
+}
+export function markdownList(value) {
+    const items = [];
+    for (const raw of value.replace(/\r\n/g, "\n").split("\n")) {
+        const listed = raw.match(/^\s*(?:\d+[.)]|[-*+])\s+(.*)$/);
+        if (listed) {
+            const text = listed[1].trim();
+            if (text)
+                items.push(text);
+            continue;
+        }
+        const continuation = raw.match(/^\s{2,}(\S.*)$/);
+        if (continuation && items.length > 0) {
+            items[items.length - 1] = `${items[items.length - 1]} ${continuation[1].trim()}`;
+        }
+    }
+    return items;
+}
+export function markdownH1Title(body) {
+    const match = /^#\s+(\S.*)$/m.exec(body.replace(/\r\n/g, "\n"));
+    return match?.[1]?.trim() ?? "";
+}

package/dist/workflows/dag/frontend-test-result-contract.js

@@ -5,6 +5,7 @@ import { z } from "zod";
 import { writeDagRunJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
 import { readPlaywrightCliReceipts, summarizePlaywrightCliReceipts, } from "../../executors/pi-playwright-cli-tool.js";
 import { validateFrontendCaseContent } from "./frontend-test-case-quality.js";
+import { markdownH1Title, markdownList, markdownSection, } from "./frontend-test-markdown.js";
 export const FRONTEND_TEST_RESULT_SCHEMA_ID = "frontend-test-result-v1";
 const safeRelativePathSchema = z.string().min(1).refine((value) => !path.posix.isAbsolute(value) &&
     !path.win32.isAbsolute(value) &&
@@ -220,34 +221,25 @@ async function loadCaseBrowserReceiptSummary(input) {
 function sha256(content) {
     return createHash("sha256").update(content).digest("hex");
 }
-function markdownSection(body, names) {
-    const escaped = names.map((name) => name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
-    const marker = new RegExp(`^###\\s+(?:${escaped})\\s*$`, "mi");
-    const hit = marker.exec(body);
-    if (!hit)
-        return "";
-    const rest = body.slice(hit.index + hit[0].length);
-    const next = /^###\s+/m.exec(rest);
-    return rest.slice(0, next?.index ?? rest.length).trim();
-}
-function markdownList(value) {
-    const items = value.split(/\r?\n/).map((line) => line.replace(/^\s*(?:\d+[.)]|[-*+])\s+/, "").trim()).filter(Boolean);
-    return items;
-}
 /**
  * Read planned case facts from the case Markdown. Recognizes both English and
- * Chinese headings, including `测试点` (test points) and `测试步骤` (planned
- * test steps), alongside the legacy `操作步骤`/`Steps` headings.
+ * Chinese headings at `##` or `###`, including `测试点` (test points) and
+ * `测试步骤` (planned test steps), alongside the legacy `操作步骤`/`Steps`
+ * headings. Numbered and bulleted lists are extracted; a missing 测试目的
+ * falls back to the case H1 title.
  */
 async function readFrontendCaseContent(workspaceRoot, casePath) {
     if (!safeRelativePathSchema.safeParse(casePath).success || !casePath.startsWith("testcase/frontend/cases/")) {
         throw new Error(`unsafe frontend case path: ${casePath}`);
     }
     const body = await readFile(path.resolve(workspaceRoot, casePath), "utf8");
+    const purpose = markdownSection(body, ["Test Purpose", "测试目的", "测试场景"]) ||
+        markdownH1Title(body).replace(/^FE-[^\s：:]+[：:]\s*/, "").trim() ||
+        "未提供测试目的";
     return {
         caseContent: {
-            purpose: markdownSection(body, ["Test Purpose", "测试目的", "测试场景"]) || "未提供测试目的",
-            preconditions: markdownList(markdownSection(body, ["Preconditions", "前置条件"])),
+            purpose,
+            preconditions: markdownList(markdownSection(body, ["Preconditions", "前置条件", "前置条件与重置"])),
             steps: markdownList(markdownSection(body, ["Test Steps", "测试步骤", "Steps", "操作步骤"])),
             expectedResults: markdownList(markdownSection(body, ["Expected Results", "预期结果"])),
         },

package/dist/workflows/dag/frontend-test-standard-scenarios.js

@@ -0,0 +1,68 @@
+import { copyFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+export const FRONTEND_TEST_STANDARD_SCENARIOS_FILENAME = "frontend-test-standard-scenarios.v1.json";
+export const FRONTEND_TEST_STANDARD_SCENARIOS_DEST = "testcase/frontend/rag/standard-scenarios.v1.json";
+const MINIMAL_STANDARD_SCENARIOS = {
+    schemaVersion: 1,
+    id: "frontend-test-standard-scenarios-v1",
+    scenarios: [
+        {
+            id: "STD-FE-SMOKE-ENTRY",
+            title: "入口可打开",
+            category: "smoke",
+            priority: "must",
+            testPoints: ["open"],
+            minCases: 1,
+        },
+    ],
+};
+function isSafeRelativeDir(value) {
+    if (!value || path.isAbsolute(value) || path.win32.isAbsolute(value)) {
+        return false;
+    }
+    return value.split(/[\\/]/).every((part) => part.length > 0 && part !== "." && part !== "..");
+}
+export function listFrontendTestStandardScenarioCandidates(input) {
+    const seen = new Set();
+    const add = (relative) => {
+        const normalized = relative.replaceAll("\\", "/");
+        if (!seen.has(normalized))
+            seen.add(normalized);
+    };
+    add(`docs/templates/${FRONTEND_TEST_STANDARD_SCENARIOS_FILENAME}`);
+    const governanceRoot = input.governanceRoot?.trim().replaceAll("\\", "/").replace(/\/+$/, "");
+    if (governanceRoot && isSafeRelativeDir(governanceRoot)) {
+        add(`${governanceRoot}/templates/${FRONTEND_TEST_STANDARD_SCENARIOS_FILENAME}`);
+    }
+    add(`ai_workspace/loop-agent/templates/${FRONTEND_TEST_STANDARD_SCENARIOS_FILENAME}`);
+    return [...seen];
+}
+async function readGovernanceRoot(workspaceRoot) {
+    try {
+        const raw = JSON.parse(await readFile(path.join(workspaceRoot, "harness.json"), "utf8"));
+        return typeof raw.governanceRoot === "string" ? raw.governanceRoot : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function copyFrontendTestStandardScenarios(input) {
+    const destRel = FRONTEND_TEST_STANDARD_SCENARIOS_DEST;
+    const destAbs = path.join(input.workspaceRoot, destRel);
+    const candidates = listFrontendTestStandardScenarioCandidates({
+        governanceRoot: await readGovernanceRoot(input.workspaceRoot),
+    });
+    await mkdir(path.dirname(destAbs), { recursive: true });
+    for (const relative of candidates) {
+        const sourceAbs = path.join(input.workspaceRoot, relative);
+        try {
+            await copyFile(sourceAbs, destAbs);
+            return { status: "copied", from: relative, to: destRel };
+        }
+        catch {
+            // try the next candidate
+        }
+    }
+    await writeFile(destAbs, `${JSON.stringify(MINIMAL_STANDARD_SCENARIOS, null, 2)}\n`, "utf8");
+    return { status: "fallback", to: destRel };
+}

package/dist/workflows/dag/init-hybrid.js

@@ -4978,15 +4978,11 @@ function buildFrontendTestHybridDag(sources) {
             writeSet: ragWriteSet,
             allowedPaths: [...ragWriteSet],
             forbiddenPaths: forbidden,
-            outputContract: "Write testcase/frontend/rag/standard-scenarios.v1.json for generate-time standard scenario coverage.",
-            subtask_prompt: "Prepare frontend-test package: materialize standard-scenarios.v1.json into the RAG package.",
+            outputContract: "Write testcase/frontend/rag/standard-scenarios.v1.json for generate-time standard scenario coverage. Copy docs/templates or harness.json governanceRoot templates (including ai_workspace/loop-agent/templates) when present; otherwise write the minimal STD-FE-SMOKE-ENTRY fallback.",
+            subtask_prompt: "Prepare frontend-test package: materialize standard-scenarios.v1.json into the RAG package from docs/templates, governanceRoot/templates, or the init-projected ai_workspace/loop-agent/templates path.",
             shell: {
-                commands: [
-                    [
-                        "node -e",
-                        JSON.stringify("const fs=require('fs'),path=require('path');const dest='testcase/frontend/rag/standard-scenarios.v1.json';const candidates=[path.join('docs','templates','frontend-test-standard-scenarios.v1.json')];let src=null;for(const c of candidates){if(fs.existsSync(c)){src=c;break;}}fs.mkdirSync(path.dirname(dest),{recursive:true});if(src){fs.copyFileSync(src,dest);process.stdout.write(JSON.stringify({status:'copied',from:src,to:dest}));}else{const minimal={schemaVersion:1,id:'frontend-test-standard-scenarios-v1',scenarios:[{id:'STD-FE-SMOKE-ENTRY',title:'入口可打开',category:'smoke',priority:'must',testPoints:['open'],minCases:1}]};fs.writeFileSync(dest,JSON.stringify(minimal,null,2)+'\n');process.stdout.write(JSON.stringify({status:'fallback',to:dest}));}"),
-                    ].join(" "),
-                ],
+                commands: [],
+                frontendTestStandardScenarios: {},
                 cwd: ".",
                 timeoutMs: 60_000,
             },
@@ -5022,15 +5018,11 @@ function buildFrontendTestHybridDag(sources) {
             writeSet: ragWriteSet,
             allowedPaths: [...ragWriteSet],
             forbiddenPaths: forbidden,
-            outputContract: "Fail-closed environment preflight: absolute non-production baseUrl + curl HTTP reachability; writes environmentProbe facts; unreachable => blockedReason frontend-base-url-unreachable (node ERROR so generate/map do not run).",
-            subtask_prompt: "Parse the resolved absolute baseUrl from testcase/frontend/rag/context.md, reject production/non-http(s)/credential/query/fragment URLs, then probe it with curl HEAD and GET fallback (connect/max-time; no auth/cookie). 2xx/3xx => reachable and continue. 4xx/5xx/DNS/timeout/connection refused/TLS => blockedReason frontend-base-url-unreachable. Missing curl => blockedReason curl-unavailable. Do not start the app. Fixture/reset remain soft guidance.",
+            outputContract: "Fail-closed environment preflight: absolute non-production baseUrl + curl HTTP reachability; writes environmentProbe facts; unreachable => blockedReason frontend-base-url-unreachable with errorClass (connection-refused / dns-unresolved / connect-timeout / http-N / curl-exit-N). Node ERROR so generate/map do not run. Does not start the app.",
+            subtask_prompt: "Parse the resolved absolute baseUrl from testcase/frontend/rag/context.md, reject production/non-http(s)/credential/query/fragment URLs, then probe it with curl HEAD and GET fallback (connect/max-time; no auth/cookie). 2xx/3xx => reachable and continue. Connection refused (curl 7) records errorClass=connection-refused and tells the operator to start the local app (scripts/serve.sh or npm start) then rerun from this node. 4xx/5xx/DNS/timeout/TLS => blockedReason frontend-base-url-unreachable with a distinct errorClass. Missing curl => blockedReason curl-unavailable. Do not start the app. Fixture/reset remain soft guidance.",
             shell: {
-                commands: [
-                    [
-                        "node -e",
-                        JSON.stringify(`const fs=require('fs');const {spawnSync}=require('child_process');const p='testcase/frontend/rag/context.md';const probePath='testcase/frontend/rag/environment-probe.json';function writeProbe(obj){try{fs.mkdirSync('testcase/frontend/rag',{recursive:true});fs.writeFileSync(probePath,JSON.stringify(obj,null,2)+'\\n');let ctx=fs.existsSync(p)?fs.readFileSync(p,'utf8'):'';const line='environmentProbe: '+obj.status+(obj.blockedReason?(' ('+obj.blockedReason+')'):'');if(/environmentProbe\\s*[:=]/i.test(ctx)){ctx=ctx.replace(/environmentProbe\\s*[:=]\\s*.*/i,line);}else{ctx=ctx.trimEnd()+'\\n\\n'+line+'\\n';}fs.writeFileSync(p,ctx);}catch(e){console.error('probe-write-failed',e&&e.message||e);}}function redactUrl(u){try{const x=new URL(u);x.username='';x.password='';if(x.search){x.search='';}return x.toString();}catch(_){return String(u).replace(/\\/\\/[^@\\s]+@/g,'//');}}function failBlocked(reason,extra){const payload=Object.assign({status:'unreachable',blockedReason:reason,baseUrlRedacted:extra&&extra.baseUrlRedacted||null,httpStatus:extra&&extra.httpStatus||null,method:extra&&extra.method||null,curlExit:extra&&extra.curlExit||null,errorClass:extra&&extra.errorClass||null},extra||{});writeProbe(payload);console.error('frontend-test preflight blocked: '+JSON.stringify({blockedReason:reason,baseUrl:payload.baseUrlRedacted,httpStatus:payload.httpStatus,errorClass:payload.errorClass}));throw new Error('frontend-test preflight blocked: '+reason);}if(!fs.existsSync(p))throw new Error('missing '+p);const s=fs.readFileSync(p,'utf8');const patterns=[/baseUrl\\s*[:=]\\s*["'\\x60]?((?:https?):\\/\\/[^\\s"'\\x60<>]+)/i,/base[-_ ]url\\s*[:=]\\s*["'\\x60]?((?:https?):\\/\\/[^\\s"'\\x60<>]+)/i,/playwright-cli open --browser=chrome\\s+((?:https?):\\/\\/[^\\s"'\\x60<>]+)/i,/(https?:\\/\\/(?:localhost|127\\.0\\.0\\.1)[^\\s)\\}\\],"']*)/i];let baseUrl=null;for(const re of patterns){const m=s.match(re);if(m){baseUrl=m[1];break;}}if(!baseUrl)throw new Error('frontend-test preflight missing absolute baseUrl from context.md');baseUrl=baseUrl.replace(/[)\\}\\],."'\\x60]+$/,'');const sourceMatch=s.match(/baseUrlSource\\s*[:=]\\s*([^\\r\\n]+)/i);const baseUrlSource=sourceMatch?sourceMatch[1].trim():'context.md';let parsed;try{parsed=new URL(baseUrl);}catch(_){throw new Error('baseUrl must be absolute http(s): '+baseUrl);}if((parsed.protocol!=='http:'&&parsed.protocol!=='https:')||parsed.username||parsed.password||parsed.search||parsed.hash)throw new Error('unsafe baseUrl from context.md: '+redactUrl(baseUrl));if(/(?:^|\\.)(?:www\\.)?[^.]*(?:prod|production)/i.test(parsed.hostname))throw new Error('production URL forbidden: '+redactUrl(baseUrl));baseUrl=parsed.toString();const safe=redactUrl(baseUrl);const curlCheck=spawnSync('curl',['--version'],{encoding:'utf8'});if(curlCheck.error||curlCheck.status!==0){failBlocked('curl-unavailable',{baseUrlRedacted:safe,errorClass:'curl-missing'});}function probe(method){const args=['-sS','-o','/dev/null','-w','%{http_code}','--connect-timeout','3','--max-time','8','-X',method,'-L','--max-redirs','3','--http1.1','--proto-redir','=http,https',safe];const r=spawnSync('curl',args,{encoding:'utf8'});return r;}let used='HEAD';let r=probe('HEAD');let code=String(r.stdout||'').trim();let statusNum=parseInt(code,10);const headRejected=r.status!==0||!statusNum||statusNum===405||statusNum===501;if(headRejected){used='GET';r=probe('GET');code=String(r.stdout||'').trim();statusNum=parseInt(code,10);}const ok=statusNum>=200&&statusNum<400;if(!ok){const errClass=r.error?'spawn-error':(r.status!==0?'curl-exit-'+r.status:('http-'+statusNum));failBlocked('frontend-base-url-unreachable',{baseUrlRedacted:safe,httpStatus:statusNum||null,method:used,curlExit:r.status,errorClass:errClass});}writeProbe({status:'reachable',blockedReason:null,baseUrl:safe,baseUrlRedacted:safe,baseUrlSource,httpStatus:statusNum,method:used,curlExit:r.status});console.log('frontend-test-execution-v1 validated contextBaseUrl='+safe+' source='+baseUrlSource+' probe=reachable method='+used+' httpStatus='+statusNum);`),
-                    ].join(" "),
-                ],
+                commands: [],
+                frontendTestEnvironmentProbe: {},
                 cwd: ".",
                 timeoutMs: 60000,
             },

package/dist/workflows/dag/rerun-plan.js

@@ -306,6 +306,9 @@ export function computeResetClosure(spec, effectiveFromNodeId) {
         ...collectReachableDescendants(spec, effectiveFromNodeId),
     ].sort();
 }
+function isNeverStartedNodeStatus(status) {
+    return status === undefined || status === "SKIPPED" || status === "PENDING";
+}
 export function assessResetClosureSafety(spec, resetNodeIds, options = {}) {
     const tasks = taskById(spec);
     const blockingNodes = [];
@@ -314,9 +317,17 @@ export function assessResetClosureSafety(spec, resetNodeIds, options = {}) {
         const task = tasks.get(nodeId);
         if (!task)
             continue;
+        if (options.parentNodes !== undefined &&
+            isNeverStartedNodeStatus(options.parentNodes[nodeId]?.status)) {
+            continue;
+        }
         if (isWriterTask(task, spec)) {
             if (nodeId === options.allowedTransportWriterNodeId)
                 continue;
+            if (nodeId === options.allowedExclusiveShellFromNodeId &&
+                task.executor === "shell") {
+                continue;
+            }
             blockingNodes.push({
                 nodeId,
                 reasonCode: "restart-subgraph-contains-writer",
@@ -594,9 +605,17 @@ export async function evaluateDagRerunPlan(input) {
             blockedReasons.push("ambiguous-skipped-rewrite");
         }
     }
-    const closureSafety = assessResetClosureSafety(input.parentSpec, resetNodeIds, transportWriterRestart && effectiveFromNodeId
-        ? { allowedTransportWriterNodeId: effectiveFromNodeId }
-        : {});
+    const closureSafety = assessResetClosureSafety(input.parentSpec, resetNodeIds, {
+        ...(transportWriterRestart && effectiveFromNodeId
+            ? { allowedTransportWriterNodeId: effectiveFromNodeId }
+            : {}),
+        parentNodes: input.parentState.nodes,
+        ...(effectiveFromNodeId &&
+            effectiveTask?.executor === "shell" &&
+            effectiveRecord?.status === "ERROR"
+            ? { allowedExclusiveShellFromNodeId: effectiveFromNodeId }
+            : {}),
+    });
     blockingNodes.push(...closureSafety.blockingNodes);
     for (const code of closureSafety.reasonCodes) {
         reasonCodes.push(code);

package/dist/workflows/dag/types.js

@@ -427,6 +427,8 @@ export const dagBackendTestPipelineSchema = z.enum([
     "ingest-backend-test-gap",
 ]);
 export const dagFrontendBrowserToolPreflightSchema = z.object({}).strict();
+export const dagFrontendTestStandardScenariosSchema = z.object({}).strict();
+export const dagFrontendTestEnvironmentProbeSchema = z.object({}).strict();
 export const dagFrontendTestEvidenceValidationSchema = z.object({}).strict();
 export const dagFrontendTestCaseChecklistSchema = z.object({}).strict();
 export const dagFrontendTestHtmlReportSchema = z.object({}).strict();
@@ -517,6 +519,8 @@ export const dagShellConfigSchema = z.object({
     frontendReviewContext: dagFrontendReviewContextSchema.optional(),
     frontendTestCaseChecklist: dagFrontendTestCaseChecklistSchema.optional(),
     frontendBrowserToolPreflight: dagFrontendBrowserToolPreflightSchema.optional(),
+    frontendTestStandardScenarios: dagFrontendTestStandardScenariosSchema.optional(),
+    frontendTestEnvironmentProbe: dagFrontendTestEnvironmentProbeSchema.optional(),
     frontendTestEvidenceValidation: dagFrontendTestEvidenceValidationSchema.optional(),
     finalWriteSetApprovalGate: dagFinalWriteSetApprovalGateSchema.optional(),
     frontendTestL5Report: z.object({}).strict().optional(),

package/dist/workflows/dag/validate.js

@@ -465,6 +465,8 @@ function validateShellTaskConfig(task, spec, issues) {
         !shell.backendTestPipeline &&
         !shell.frontendPrewriteGate &&
         !shell.frontendBrowserToolPreflight &&
+        !shell.frontendTestStandardScenarios &&
+        !shell.frontendTestEnvironmentProbe &&
         !shell.frontendVerificationBundle &&
         !shell.frontendReviewContext &&
         !shell.frontendTestCaseChecklist &&

package/docs/templates/agent-dag.schema.json

@@ -356,6 +356,31 @@
           "properties": { "schemaVersion": { "const": 1 }, "requireBaseline": { "const": true } }
         },
         "frontendTestCaseChecklist": { "type": "object", "additionalProperties": false },
+        "frontendBrowserToolPreflight": { "type": "object", "additionalProperties": false },
+        "frontendTestStandardScenarios": { "type": "object", "additionalProperties": false },
+        "frontendTestEnvironmentProbe": { "type": "object", "additionalProperties": false },
+        "frontendTestCaseManifest": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "maxCases": { "type": "integer", "minimum": 1 },
+            "declaredAcIds": { "type": "array", "items": { "type": "string" } }
+          }
+        },
+        "frontendTestResultFinalize": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "declaredAcIds": { "type": "array", "items": { "type": "string" } }
+          }
+        },
+        "frontendTestReports": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "l5": { "type": "boolean" }
+          }
+        },
         "frontendTestEvidenceValidation": { "type": "object", "additionalProperties": false },
         "frontendTestHtmlReport": { "type": "object", "additionalProperties": false },
         "backendTestPipeline": {
@@ -383,6 +408,12 @@
         { "required": ["frontendVerificationBundle"] },
         { "required": ["frontendReviewContext"] },
         { "required": ["frontendTestCaseChecklist"] },
+        { "required": ["frontendBrowserToolPreflight"] },
+        { "required": ["frontendTestStandardScenarios"] },
+        { "required": ["frontendTestEnvironmentProbe"] },
+        { "required": ["frontendTestCaseManifest"] },
+        { "required": ["frontendTestResultFinalize"] },
+        { "required": ["frontendTestReports"] },
         { "required": ["frontendTestEvidenceValidation"] },
         { "required": ["frontendTestHtmlReport"] },
         { "required": ["backendTestPipeline"] }

package/docs/templates/frontend-test-dag.json

@@ -66,12 +66,11 @@
         ".harness/**",
         "artifacts/**"
       ],
-      "outputContract": "Write testcase/frontend/rag/standard-scenarios.v1.json for generate-time standard scenario coverage.",
-      "subtask_prompt": "Materialize frontend-test standard scenarios v1 into the RAG package.",
+      "outputContract": "Write testcase/frontend/rag/standard-scenarios.v1.json for generate-time standard scenario coverage. Copy docs/templates or harness.json governanceRoot templates (including ai_workspace/loop-agent/templates) when present; otherwise write the minimal STD-FE-SMOKE-ENTRY fallback.",
+      "subtask_prompt": "Prepare frontend-test package: materialize standard-scenarios.v1.json into the RAG package from docs/templates, governanceRoot/templates, or the init-projected ai_workspace/loop-agent/templates path.",
       "shell": {
-        "commands": [
-          "node -e \"const fs=require('fs'),path=require('path');const dest='testcase/frontend/rag/standard-scenarios.v1.json';const candidates=[path.join('docs','templates','frontend-test-standard-scenarios.v1.json')];let src=null;for(const c of candidates){if(fs.existsSync(c)){src=c;break;}}fs.mkdirSync(path.dirname(dest),{recursive:true});if(src){fs.copyFileSync(src,dest);process.stdout.write(JSON.stringify({status:'copied',from:src,to:dest}));}else{const minimal={schemaVersion:1,id:'frontend-test-standard-scenarios-v1',scenarios:[{id:'STD-FE-SMOKE-ENTRY',title:'入口可打开',category:'smoke',priority:'must',testPoints:['open'],minCases:1}]};fs.writeFileSync(dest,JSON.stringify(minimal,null,2)+'\\n');process.stdout.write(JSON.stringify({status:'fallback',to:dest}));}"
-        ],
+        "commands": [],
+        "frontendTestStandardScenarios": {},
         "cwd": ".",
         "timeoutMs": 60000
       }
@@ -120,12 +119,11 @@
         ".harness/**",
         "artifacts/**"
       ],
-      "outputContract": "Fail-closed environment preflight: absolute non-production baseUrl + curl HTTP reachability; writes environmentProbe facts; unreachable => blockedReason frontend-base-url-unreachable (node ERROR so generate/map do not run).",
-      "subtask_prompt": "Parse the concrete baseUrl selected by retrieve-frontend-test-context-pi from testcase/frontend/rag/context.md. Reject production, non-http(s), credentials, query and fragment. Probe with curl (HEAD then GET fallback; connect/max-time; no auth/cookie). 2xx/3xx => reachable and continue. 4xx/5xx/DNS/timeout/connection refused/TLS => blockedReason frontend-base-url-unreachable. Missing curl => blockedReason curl-unavailable. Do not start the app. Runtime hybrid generator embeds the authoritative probe script.",
+      "outputContract": "Fail-closed environment preflight: absolute non-production baseUrl + curl HTTP reachability; writes environmentProbe facts; unreachable => blockedReason frontend-base-url-unreachable with errorClass (connection-refused / dns-unresolved / connect-timeout / http-N). Node ERROR so generate/map do not run. Does not start the app.",
+      "subtask_prompt": "Parse the concrete baseUrl selected by retrieve-frontend-test-context-pi from testcase/frontend/rag/context.md. Reject production, non-http(s), credentials, query and fragment. Probe with curl (HEAD then GET fallback; connect/max-time; no auth/cookie). 2xx/3xx => reachable and continue. Connection refused records errorClass=connection-refused and tells the operator to start the local app then rerun from this node. 4xx/5xx/DNS/timeout/TLS => blockedReason frontend-base-url-unreachable. Missing curl => blockedReason curl-unavailable. Do not start the app.",
       "shell": {
-        "commands": [
-          "node -e \"console.log('template placeholder: runtime hybrid DAG embeds curl preflight; do not use this static command as source of truth')\""
-        ],
+        "commands": [],
+        "frontendTestEnvironmentProbe": {},
         "cwd": ".",
         "timeoutMs": 60000
       }

package/docs/templates/frontend-test-dag.retrieve-context.prompt.md

@@ -17,5 +17,5 @@ Do not claim the environment is reachable until preflight completes. Preflight d
 
 ## Standard scenario coverage
 
-- Copy or reference `docs/templates/frontend-test-standard-scenarios.v1.json` into `testcase/frontend/rag/standard-scenarios.v1.json` when available.
+- Copy or reference `docs/templates/frontend-test-standard-scenarios.v1.json`, `harness.json` `governanceRoot`/templates, or the init-projected `ai_workspace/loop-agent/templates/frontend-test-standard-scenarios.v1.json` into `testcase/frontend/rag/standard-scenarios.v1.json` when available.
 - Add `## Standard scenario coverage` to coverage-map.md with planned/n/a for each must scenario.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.39.0-next.25",
+  "version": "0.39.0-next.26",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",

package/skills/codebase-scout/SKILL.md

@@ -10,7 +10,7 @@ description: 用于只读 scout 节点，在实现前定位现有代码、测试
 ## 规则
 
 - 从 repo 指令、task source 与邻近测试入手。
-- 可用时优先 CodeGraph；否则用 `rg` 与聚焦文件阅读。
+- 可用时优先 CodeGraph；否则 Shell 搜索优先 `rg`，按名找文件优先 `fd`，再聚焦阅读文件。
 - 在提议新抽象前，识别现有 helper 与 ownership 边界。
 - 只返回事实，不做编辑。