@tea-agent/loop-agent 0.39.0-next.28 → 0.39.0-next.29

package/CHANGELOG.md

@@ -4,6 +4,10 @@
 
 ### 重点更新
 
+- frontend-test `passed` 回执链改按 dispatch 序号判序（B-HASH-01）：`summarizePlaywrightCliReceipts` 先按 `sequence` 排序再判 open→find→cleanup 连续链；并行 `find`/`screenshot` 按完成时间落盘导致的乱序不再误杀执行已通过的 case（Wave 1 实测 4 条 passed 被改判 `browser-command-evidence-missing`）。真 gap / 重复序号仍 fail-closed。
+- `tool-policy` 失败归一为 `executor`（B-REC-03）：前端 preflight 能力拒绝（缺 `@playwright/cli` JS entry、allowlist 拒绝）不再落 `unknown`→`manual-review`+`humanRequired`；`dag report` 给出 `rerun-after-fix`，Console `standaloneTaskRerun` 的 R2 gate 放行 run-failed 同 task 整单重跑，无需人工决策门或 sibling task。
+- Operator Chrome Band1 模式切换入口补显式 `aria-label`（B-FIND-01，方案 A）：`操作`/`观测` mode link 原为 inline-flex 裸文本节点，不参与 name-from-content，a11y snapshot 序列化为无名 link，`find` 无法断言；补 `aria-label` 后实测 `find "观测"` 1 命中、click 后 `find "运行总览"` 1 命中，AC-FE-CHROME-003 恢复可见断言路径。
+
 - `next-release.yml` 防重复发布守卫补充幂等语义：`mode=recover`（dist-tags.next 已指向出自本 HEAD 的 tarball）时，手动 `workflow_dispatch` 重入不再撞 duplicate publish 硬失败，改为写 summary 后干净退出（§5.1 规则 4）；非 recover 的重复发布仍硬失败。
 
 - frozen repair 工具审计改为按 attempt 段扫描（B1）：`session-events.jsonl` 跨 attempt 共享追加，attempt>1 的 `auditRepairAttemptToolUse` 现在只审本 attempt 字节段（newline 对齐），planner attempt 1 的 ls/find 不再被误判给 repair 轮；repair prompt 显式声明 read-only 工具契约与 allowlist 边界（B2），并内嵌 openspec-citations 输出格式正例；`LOOP_AGENT_IGNORE_STALE_DIST=1` 环境变量旁路 stale-dist guard（B3），Console spawn 的 sibling CLI 可继承。
@@ -39,6 +43,8 @@
 
 ### 改进
 
+- DAG 节点检查器「执行过程」按执行器分流：Pi 仍看 session-events；有命令的 shell 展示 `shell-command-receipt` 与 stdout/stderr；`frontendBrowserToolPreflight` 等内部处理器展示步骤回执（历史 run 可从 capability / attempt 产物合成）。空态不再把 shell/static 误说成「暂无过程日志」。节点输入补充 named handler 名称。脚本仍属于节点输入，不假装已执行。
+- DAG 节点检查器「节点输出」在整段内容为完整 JSON 对象或数组时改为缩进代码块展示，不再把紧凑 `JSON.stringify` 挤成一段 Markdown 段落；截断或非法 JSON、普通 Markdown 仍走原阅读器。
 - frontend DAG 的 materialized source references 恢复统一的有界 excerpt 与按需 read 指针，不再把 requirement/acceptance 文档全文复制进每个相关节点，也不再强制 contract/plan 重读全部绑定源文件，降低长需求在多节点中的重复上下文占用。
 - 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`。
@@ -82,6 +88,7 @@
 
 ### 修复
 
+- backend-test 用例覆盖分析的 payload 形状提取在无 `python` 可执行文件的环境（现代 macOS 只有 `python3`）静默降级为空结果，导致 payload 观测路径全空、`PAYLOAD_SHAPE_MISMATCH` 误报；解释器解析改为 POSIX 优先 `python3`、Windows 优先 `python`（与 scenario-param 语法校验一致），仅在解释器缺失时尝试下一候选，分析输入自身的失败不再重试。
 - Inspector「执行过程」时间轴按「执行分次」选择过滤：session-events 是跨 attempt 共享追加的单文件，此前所有次执行的事件重合显示、切换顶部分次不生效；现在按 `agent_start` 边界分段，选中第 N 次执行只显示该段并标注「已按第 N 次执行过滤 · 共 M 次执行」，单次执行与 pass 选择保持全量展示，检测不到边界时显式提示并回退全量。
 - 前端 plan/revision 的 `openspec-citations` fence 提取改为行锚定正则：直接闭合的空 fence（无候选行、紧跟关闭 fence）此前被判定为「不存在 citation 块」而进入格式重试循环，现在计为合法的唯一 citation 块；重复、损坏或非唯一的 fence 仍被拒绝。
 - `npm test` 前置段失败导致后续段（io-heavy / integration）被跳过时，`scripts/run-tests.mjs` 显式输出警告与补跑命令，不再静默跳过（此前失败汇总会被误读为全量覆盖）。

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
   "version": "0.38.3",
-  "gitSha": "8440f2c71f99959bd1ccd91ec4e48b3e37733d6f",
-  "builtAt": "2026-08-22T06:33:22.850Z"
+  "gitSha": "a757f2e56597122ab0be09e7524038ad14a576bb",
+  "builtAt": "2026-08-22T10:37:15.456Z"
 }

package/dist/executors/pi-playwright-cli-tool.js

@@ -111,6 +111,13 @@ export async function readPlaywrightCliReceipts(runDir, nodeId) {
     }
 }
 export function summarizePlaywrightCliReceipts(receipts) {
+    // Sequence numbers are assigned at dispatch time, which is the controller's
+    // causal order. Receipt lines are appended when each command COMPLETES, so
+    // concurrent commands (e.g. parallel find calls issued in one turn) persist
+    // out of sequence order. Judge chain contiguity on the dispatch order by
+    // sorting on `sequence` first; a genuinely missing receipt (gap) or a
+    // duplicated sequence still fails the contiguity check below.
+    const orderedReceipts = [...receipts].sort((a, b) => a.sequence - b.sequence);
     let hasSuccessfulOpen = false;
     let hasInteractionOrAssertion = false;
     let hasMeaningfulAssertion = false;
@@ -122,7 +129,7 @@ export function summarizePlaywrightCliReceipts(receipts) {
     let hasContiguousControllerSequence = true;
     let previousSequence = 0;
     const caseIds = new Set();
-    for (const receipt of receipts) {
+    for (const receipt of orderedReceipts) {
         caseIds.add(receipt.caseId);
         const succeeded = receipt.exitCode === 0 && !receipt.timedOut;
         const ordered = receipt.sequence === previousSequence + 1;

package/dist/executors/shell-executor.js

@@ -2386,7 +2386,76 @@ async function executeFrontendLintBaseline(input, meta) {
         };
     }
 }
-export async function executeDagShellNode(input, meta) {
+async function writeShellPresetProcessReceipt(input) {
+    await writeDagNodeJsonArtifact(input.runDir, input.nodeId, "process-receipt.json", {
+        schemaVersion: 1,
+        kind: "shell-preset",
+        preset: input.preset,
+        ok: input.ok,
+        durationMs: input.durationMs,
+        steps: input.steps,
+    });
+}
+async function ensureShellPresetProcessReceipt(input) {
+    const receiptPath = path.join(input.runDir, input.nodeId, "process-receipt.json");
+    if (existsSync(receiptPath))
+        return;
+    if (existsSync(path.join(input.runDir, input.nodeId, "shell-command-receipt.json"))) {
+        return;
+    }
+    const detail = input.result.ok ? input.result.stdout : input.result.stderr;
+    await writeShellPresetProcessReceipt({
+        runDir: input.runDir,
+        nodeId: input.nodeId,
+        preset: input.preset,
+        ok: input.result.ok,
+        durationMs: input.result.durationMs,
+        steps: [
+            {
+                id: "run",
+                label: input.preset,
+                ok: input.result.ok,
+                detail: detail?.slice(0, 8 * 1024),
+                durationMs: input.result.durationMs,
+            },
+        ],
+    });
+}
+function namedShellHandler(shell) {
+    if (!shell)
+        return null;
+    const record = shell;
+    for (const key of [
+        "finalWriteSetApprovalGate",
+        "frontendTestStandardScenarios",
+        "frontendTestEnvironmentProbe",
+        "frontendBrowserToolPreflight",
+        "frontendPrewriteGate",
+        "frontendLintBaseline",
+        "frontendVerificationBundle",
+        "frontendReviewContext",
+        "frontendTestCaseChecklist",
+        "frontendTestCaseManifest",
+        "frontendTestEvidenceValidation",
+        "frontendTestResultFinalize",
+        "frontendTestL5Report",
+        "frontendTestHtmlReport",
+        "frontendTestReports",
+        "backendTestPipeline",
+        "jsonArtifactGate",
+        "projectGovernanceGate",
+        "requirementCoverageGate",
+        "verdictGate",
+        "verifyEvidence",
+        "repairArtifactGate",
+        "jacocoCoverage",
+    ]) {
+        if (record[key] != null)
+            return key;
+    }
+    return null;
+}
+async function executeDagShellNodeInner(input, meta) {
     const shell = input.task.shell;
     if (shell?.finalWriteSetApprovalGate) {
         const started = Date.now();
@@ -2433,28 +2502,81 @@ export async function executeDagShellNode(input, meta) {
     }
     if (shell?.frontendBrowserToolPreflight) {
         const started = Date.now();
+        const steps = [];
+        const finish = async (result) => {
+            await writeShellPresetProcessReceipt({
+                runDir: meta.runDir,
+                nodeId: input.task.id,
+                preset: "frontendBrowserToolPreflight",
+                ok: result.ok,
+                durationMs: result.durationMs,
+                steps: steps.length > 0
+                    ? steps
+                    : [
+                        {
+                            id: "run",
+                            label: "浏览器工具能力探测",
+                            ok: result.ok,
+                            detail: result.ok ? result.stdout : result.stderr,
+                            durationMs: result.durationMs,
+                        },
+                    ],
+            });
+            return result;
+        };
         try {
             if (resolvePiBackend() === "cli-only") {
+                steps.push({
+                    id: "pi-backend",
+                    label: "Pi SDK 后端可用",
+                    ok: false,
+                    detail: "CODE_AGENT_PI_BACKEND=cli-only",
+                });
                 throw new Error("browser-command-capability-unavailable: CODE_AGENT_PI_BACKEND=cli-only rejects SDK-only playwright_cli");
             }
+            steps.push({
+                id: "pi-backend",
+                label: "Pi SDK 后端可用",
+                ok: true,
+            });
             const sdkCapability = await checkPiSdkCustomToolCapability(input.cwd);
             if (!sdkCapability.ok) {
+                steps.push({
+                    id: "sdk-custom-tool",
+                    label: "Pi SDK custom-tool 能力",
+                    ok: false,
+                    detail: sdkCapability.detail,
+                });
                 throw new Error(`browser-command-capability-unavailable: ${sdkCapability.detail}`);
             }
+            steps.push({
+                id: "sdk-custom-tool",
+                label: "Pi SDK custom-tool 能力",
+                ok: true,
+            });
             const toolProbe = await createPlaywrightCliTool({
                 repoRoot: input.cwd,
                 runDir: meta.runDir,
                 nodeId: input.task.id,
                 caseId: "frontend-browser-preflight",
                 evidenceDir: "testcase/frontend/evidence/frontend-browser-preflight",
-                // Capability-only registration probe. The tested URL is selected later by
-                // retrieve-frontend-test-context-pi and validated by the environment shell.
                 baseUrl: "http://localhost:5173/",
                 inputRoot: "testcase/frontend/fixtures",
             });
             if (toolProbe.name !== "playwright_cli") {
+                steps.push({
+                    id: "structured-tool",
+                    label: "注册 playwright_cli",
+                    ok: false,
+                    detail: toolProbe.name,
+                });
                 throw new Error("browser-command-capability-unavailable: structured playwright_cli tool registration failed");
             }
+            steps.push({
+                id: "structured-tool",
+                label: "注册 playwright_cli",
+                ok: true,
+            });
             const launcher = resolvePlaywrightCliLauncher(input.cwd);
             const result = await defaultPlaywrightCliCommandRunner({
                 executable: launcher.executable,
@@ -2467,8 +2589,19 @@ export async function executeDagShellNode(input, meta) {
             if (result.exitCode !== 0 ||
                 result.timedOut ||
                 !["open", "close", "find", "snapshot", "click"].every((command) => new RegExp(`\\b${command}\\b`, "i").test(help))) {
+                steps.push({
+                    id: "playwright-cli-help",
+                    label: "playwright-cli --help 合同",
+                    ok: false,
+                    detail: help.slice(0, 8 * 1024),
+                });
                 throw new Error("playwright-cli-contract-incompatible");
             }
+            steps.push({
+                id: "playwright-cli-help",
+                label: "playwright-cli --help 合同",
+                ok: true,
+            });
             const capability = {
                 schemaVersion: 1,
                 status: "ready",
@@ -2479,22 +2612,28 @@ export async function executeDagShellNode(input, meta) {
                 targetUrlAuthority: "retrieve-context-and-environment-probe",
             };
             await writeDagNodeJsonArtifact(meta.runDir, input.task.id, "frontend-browser-capability.json", capability);
-            return {
+            steps.push({
+                id: "capability-artifact",
+                label: "写出 frontend-browser-capability.json",
+                ok: true,
+                detail: JSON.stringify(capability, null, 2),
+            });
+            return await finish({
                 ok: true,
                 stdout: JSON.stringify(capability),
                 stderr: "",
                 failureCategory: "success",
                 durationMs: Date.now() - started,
-            };
+            });
         }
         catch (error) {
-            return {
+            return await finish({
                 ok: false,
                 stdout: "",
                 stderr: `playwright-cli-unavailable: ${error instanceof Error ? error.message : String(error)}`,
                 failureCategory: "tool-policy",
                 durationMs: Date.now() - started,
-            };
+            });
         }
     }
     if (shell?.frontendPrewriteGate) {
@@ -3151,3 +3290,16 @@ export async function executeDagShellNode(input, meta) {
         ...{ commandResults },
     };
 }
+export async function executeDagShellNode(input, meta) {
+    const handler = namedShellHandler(input.task.shell);
+    const result = await executeDagShellNodeInner(input, meta);
+    if (handler) {
+        await ensureShellPresetProcessReceipt({
+            runDir: meta.runDir,
+            nodeId: input.task.id,
+            preset: handler,
+            result,
+        });
+    }
+    return result;
+}

package/dist/worker/observe/node-input.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { redactSecrets, truncateUtf8Preview } from "../../shared/preview.js";
 import { resolveDagNodeSkills } from "../../workflows/dag/skills.js";
 import { resolveDagNodePromptRedacted, resolveDagRunArtifact, resolveDagRunJson, } from "./dag-run-artifacts.js";
+import { namedShellHandlers } from "./shell-handler-keys.js";
 export const NODE_INPUT_SCHEMA_VERSION = 1;
 export const NODE_INPUT_PREVIEW_MAX_BYTES = 64 * 1024;
 const SHELL_GATE_KEYS = [
@@ -217,6 +218,7 @@ function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, piExt
                 : null,
             failFast: typeof shellRaw.failFast === "boolean" ? shellRaw.failFast : null,
             gates: shellGateNames(shellRaw),
+            handlers: namedShellHandlers(shellRaw),
         }
         : null;
     const staticPreview = staticRaw && typeof staticRaw.resultMarkdown === "string"

package/dist/worker/observe/node-process.js

@@ -0,0 +1,377 @@
+import { readFile } from "node:fs/promises";
+import { redactSecrets, truncateUtf8Preview } from "../../shared/preview.js";
+import { isSafeObservabilityIdentifier } from "../observability/event-store.js";
+import { parseExecutionOutputKey, } from "./dag-node-execution-output.js";
+import { resolveDagRunArtifact, resolveDagRunJson, } from "./dag-run-artifacts.js";
+import { namedShellHandlers } from "./shell-handler-keys.js";
+export const NODE_PROCESS_SCHEMA_VERSION = 1;
+export const NODE_PROCESS_FIELD_MAX_BYTES = 16 * 1024;
+function boundField(value) {
+    if (value == null || value === "")
+        return { text: null, truncated: false };
+    const redacted = redactSecrets(value);
+    const truncated = truncateUtf8Preview(redacted, NODE_PROCESS_FIELD_MAX_BYTES);
+    return {
+        text: truncated,
+        truncated: truncated !== redacted,
+    };
+}
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return value;
+}
+function asString(value) {
+    return typeof value === "string" && value.trim() ? value : null;
+}
+function asNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function asBoolean(value) {
+    return value === true;
+}
+async function readJsonArtifact(repoRoot, dagRunId, segments) {
+    const resolved = resolveDagRunArtifact(repoRoot, dagRunId, segments);
+    if (!resolved.ok)
+        return null;
+    try {
+        const raw = await readFile(resolved.result.absolutePath, "utf8");
+        const parsed = JSON.parse(raw);
+        return asRecord(parsed);
+    }
+    catch {
+        return null;
+    }
+}
+async function readTextArtifact(repoRoot, dagRunId, segments) {
+    const resolved = resolveDagRunArtifact(repoRoot, dagRunId, segments);
+    if (!resolved.ok)
+        return { text: null, truncated: false };
+    try {
+        const raw = await readFile(resolved.result.absolutePath, "utf8");
+        return boundField(raw);
+    }
+    catch {
+        return { text: null, truncated: false };
+    }
+}
+function emptyBody(dagRunId, nodeId, kind, emptyReason, extras = {}) {
+    return {
+        schemaVersion: NODE_PROCESS_SCHEMA_VERSION,
+        dagRunId,
+        nodeId,
+        kind,
+        executor: extras.executor ?? null,
+        handler: extras.handler ?? null,
+        emptyReason,
+        key: extras.key ?? null,
+        commands: extras.commands ?? [],
+        steps: extras.steps ?? [],
+    };
+}
+function classifyKind(task) {
+    const executor = asString(task.executor);
+    const shell = asRecord(task.shell);
+    const handlers = namedShellHandlers(shell);
+    const handler = handlers[0] ?? null;
+    const commands = shell?.commands;
+    const commandsDeclared = Array.isArray(commands) &&
+        commands.some((item) => typeof item === "string" && item.trim());
+    if (executor === "static" || task.static) {
+        return { kind: "static", executor: executor ?? "static", handler, commandsDeclared };
+    }
+    if (executor === "shell" || shell) {
+        if (commandsDeclared) {
+            return { kind: "shell-commands", executor: executor ?? "shell", handler, commandsDeclared };
+        }
+        if (handler) {
+            return { kind: "shell-preset", executor: executor ?? "shell", handler, commandsDeclared };
+        }
+        return { kind: "shell-commands", executor: executor ?? "shell", handler, commandsDeclared };
+    }
+    return {
+        kind: "pi-session",
+        executor: executor ?? "pi",
+        handler,
+        commandsDeclared,
+    };
+}
+function receiptAttemptSegments(nodeId, parsed) {
+    if (parsed?.kind === "attempt") {
+        return [nodeId, `attempt-${parsed.index}`, "shell-command-receipt.json"];
+    }
+    return [nodeId, "shell-command-receipt.json"];
+}
+async function loadShellCommands(repoRoot, dagRunId, nodeId, parsed) {
+    const preferred = await readJsonArtifact(repoRoot, dagRunId, receiptAttemptSegments(nodeId, parsed));
+    const receipt = preferred ??
+        (parsed
+            ? await readJsonArtifact(repoRoot, dagRunId, [
+                nodeId,
+                "shell-command-receipt.json",
+            ])
+            : null);
+    if (!receipt)
+        return null;
+    const rawCommands = Array.isArray(receipt.commands) ? receipt.commands : [];
+    const commands = [];
+    for (let i = 0; i < rawCommands.length; i += 1) {
+        const entry = asRecord(rawCommands[i]) ?? {};
+        const stdout = await readTextArtifact(repoRoot, dagRunId, [
+            nodeId,
+            "commands",
+            `${i + 1}.stdout.txt`,
+        ]);
+        const stderr = await readTextArtifact(repoRoot, dagRunId, [
+            nodeId,
+            "commands",
+            `${i + 1}.stderr.txt`,
+        ]);
+        const commandBound = boundField(asString(entry.command) ?? "");
+        commands.push({
+            index: i + 1,
+            command: commandBound.text ?? "(command)",
+            ok: asBoolean(entry.ok),
+            exitCode: asNumber(entry.exitCode),
+            failureCategory: asString(entry.failureCategory),
+            startedAt: asString(entry.startedAt),
+            finishedAt: asString(entry.finishedAt),
+            durationMs: asNumber(entry.wallDurationMs) ??
+                asNumber(entry.executionDurationMs) ??
+                null,
+            reused: asBoolean(entry.reused),
+            stdout: stdout.text,
+            stderr: stderr.text,
+            truncated: commandBound.truncated || stdout.truncated || stderr.truncated,
+        });
+    }
+    return commands;
+}
+function handlerLabel(handler) {
+    if (handler === "frontendBrowserToolPreflight")
+        return "浏览器工具能力探测";
+    if (handler === "frontendTestStandardScenarios")
+        return "标准场景物化";
+    if (handler === "frontendTestEnvironmentProbe")
+        return "前端环境探测";
+    if (handler === "frontendTestCaseChecklist")
+        return "用例清单校验";
+    if (handler === "frontendTestCaseManifest")
+        return "用例清单物化";
+    if (handler === "frontendTestEvidenceValidation")
+        return "证据校验";
+    if (handler === "frontendTestResultFinalize")
+        return "结果定稿";
+    if (handler === "frontendTestReports" || handler === "frontendTestL5Report" || handler === "frontendTestHtmlReport") {
+        return "测试报告";
+    }
+    if (handler === "frontendPrewriteGate")
+        return "前端预写门禁";
+    if (handler === "finalWriteSetApprovalGate")
+        return "writeSet 终态批准";
+    return handler;
+}
+async function loadPresetSteps(repoRoot, dagRunId, nodeId, handler, parsed) {
+    const written = await readJsonArtifact(repoRoot, dagRunId, [
+        nodeId,
+        "process-receipt.json",
+    ]);
+    if (written && Array.isArray(written.steps)) {
+        return written.steps.flatMap((item, index) => {
+            const step = asRecord(item);
+            if (!step)
+                return [];
+            const detail = boundField(asString(step.detail));
+            return [
+                {
+                    id: asString(step.id) ?? `step-${index + 1}`,
+                    label: asString(step.label) ?? handlerLabel(handler ?? "preset"),
+                    ok: asBoolean(step.ok),
+                    detail: detail.text,
+                    durationMs: asNumber(step.durationMs),
+                    truncated: detail.truncated,
+                },
+            ];
+        });
+    }
+    const capability = await readJsonArtifact(repoRoot, dagRunId, [
+        nodeId,
+        "frontend-browser-capability.json",
+    ]);
+    if (capability && handler === "frontendBrowserToolPreflight") {
+        const detail = boundField(JSON.stringify(capability, null, 2));
+        return [
+            {
+                id: "capability",
+                label: handlerLabel(handler),
+                ok: asString(capability.status) !== "failed",
+                detail: detail.text,
+                durationMs: null,
+                truncated: detail.truncated,
+            },
+        ];
+    }
+    const attemptIndex = parsed?.kind === "attempt" ? parsed.index : 1;
+    const attempt = await readJsonArtifact(repoRoot, dagRunId, [
+        nodeId,
+        `attempt-${attemptIndex}.json`,
+    ]);
+    if (attempt) {
+        const ok = asBoolean(attempt.ok);
+        const detail = boundField(ok
+            ? (asString(attempt.stdout) ?? asString(attempt.assistantText))
+            : (asString(attempt.stderr) ?? asString(attempt.stdout)));
+        return [
+            {
+                id: "run",
+                label: handlerLabel(handler ?? "preset"),
+                ok,
+                detail: detail.text,
+                durationMs: asNumber(attempt.durationMs),
+                truncated: detail.truncated,
+            },
+        ];
+    }
+    return [];
+}
+export async function loadDagNodeProcess(repoRoot, dagRunId, nodeId, rawKey) {
+    if (!isSafeObservabilityIdentifier(dagRunId) ||
+        !isSafeObservabilityIdentifier(nodeId)) {
+        return {
+            status: 400,
+            body: { error: "Invalid dag run or node identifier", reason: "invalid-id" },
+        };
+    }
+    let parsedKey = null;
+    if (rawKey != null && String(rawKey).trim() !== "") {
+        const parsed = parseExecutionOutputKey(rawKey);
+        if (!parsed.ok) {
+            return {
+                status: 400,
+                body: {
+                    error: "Invalid execution key (expected attempt-N or pass-N)",
+                    reason: "invalid-key",
+                },
+            };
+        }
+        parsedKey = parsed;
+    }
+    const runResolved = resolveDagRunJson(repoRoot, dagRunId);
+    if (!runResolved.ok) {
+        if (runResolved.reason === "invalid-id") {
+            return {
+                status: 400,
+                body: { error: "Invalid dag run or node identifier", reason: "invalid-id" },
+            };
+        }
+        if (runResolved.reason === "ambiguous") {
+            return {
+                status: 409,
+                body: { error: "Ambiguous dag run lifecycle", reason: "ambiguous" },
+            };
+        }
+        return {
+            status: 404,
+            body: { error: "DAG run not found", reason: "not-found" },
+        };
+    }
+    let spec = {};
+    try {
+        const raw = JSON.parse(await readFile(runResolved.result.absolutePath, "utf8"));
+        spec = asRecord(raw) ?? {};
+    }
+    catch {
+        return {
+            status: 404,
+            body: { error: "run.json is unreadable", reason: "not-found" },
+        };
+    }
+    const tasks = Array.isArray(spec.tasks) ? spec.tasks : [];
+    const task = tasks
+        .map((item) => asRecord(item))
+        .find((item) => item && asString(item.id) === nodeId);
+    if (!task) {
+        return {
+            status: 200,
+            body: emptyBody(dagRunId, nodeId, "none", "not-executed"),
+        };
+    }
+    const classified = classifyKind(task);
+    const key = parsedKey?.key ?? null;
+    if (classified.kind === "pi-session") {
+        return {
+            status: 200,
+            body: emptyBody(dagRunId, nodeId, "pi-session", "pi-session", {
+                executor: classified.executor,
+                key,
+            }),
+        };
+    }
+    if (classified.kind === "static") {
+        return {
+            status: 200,
+            body: emptyBody(dagRunId, nodeId, "static", "static-no-process", {
+                executor: classified.executor,
+                key,
+            }),
+        };
+    }
+    if (classified.kind === "shell-commands" || classified.kind === "shell-preset") {
+        const commands = await loadShellCommands(repoRoot, dagRunId, nodeId, parsedKey);
+        if (commands && commands.length > 0) {
+            return {
+                status: 200,
+                body: {
+                    schemaVersion: NODE_PROCESS_SCHEMA_VERSION,
+                    dagRunId,
+                    nodeId,
+                    kind: "shell-commands",
+                    executor: classified.executor,
+                    handler: classified.handler,
+                    emptyReason: null,
+                    key,
+                    commands,
+                    steps: [],
+                },
+            };
+        }
+        if (classified.handler || classified.kind === "shell-preset") {
+            const steps = await loadPresetSteps(repoRoot, dagRunId, nodeId, classified.handler, parsedKey);
+            if (steps.length > 0) {
+                return {
+                    status: 200,
+                    body: {
+                        schemaVersion: NODE_PROCESS_SCHEMA_VERSION,
+                        dagRunId,
+                        nodeId,
+                        kind: "shell-preset",
+                        executor: classified.executor,
+                        handler: classified.handler,
+                        emptyReason: null,
+                        key,
+                        commands: [],
+                        steps,
+                    },
+                };
+            }
+        }
+        return {
+            status: 200,
+            body: emptyBody(dagRunId, nodeId, classified.kind, classified.kind === "shell-preset"
+                ? "shell-preset-pending"
+                : "shell-receipt-missing", {
+                executor: classified.executor,
+                handler: classified.handler,
+                key,
+            }),
+        };
+    }
+    return {
+        status: 200,
+        body: emptyBody(dagRunId, nodeId, "none", "not-executed", {
+            executor: classified.executor,
+            handler: classified.handler,
+            key,
+        }),
+    };
+}

package/dist/worker/observe/routes.js

@@ -16,6 +16,7 @@ import { isAllowedArtifactTextPath, resolveArtifactPath, resolveRepoFilePreview,
 import { extractSpecEvidence, extractSpecReadContent, } from "./spec-evidence.js";
 import { buildDagNodeInput } from "./node-input.js";
 import { loadDagNodeExecutionOutput } from "./dag-node-execution-output.js";
+import { loadDagNodeProcess } from "./node-process.js";
 import { buildObserveHealthV1 } from "./health.js";
 import { buildNightJobDetail, buildNightJobsDoctor, buildNightJobsList, buildNightJobsMorning, } from "./night-jobs.js";
 const ARTIFACT_PREVIEW_MAX_BYTES = 64 * 1024;
@@ -100,6 +101,11 @@ export const ROUTES = [
         pattern: /^\/api\/dag-runs\/([^/]+)\/nodes\/([^/]+)\/execution-output$/,
         handler: handleDagNodeExecutionOutput,
     },
+    {
+        method: "GET",
+        pattern: /^\/api\/dag-runs\/([^/]+)\/nodes\/([^/]+)\/process$/,
+        handler: handleDagNodeProcess,
+    },
     {
         method: "GET",
         pattern: /^\/api\/dag-runs\/([^/]+)\/nodes\/([^/]+)\/spec-evidence$/,
@@ -570,6 +576,24 @@ async function handleDagNodeExecutionOutput(_req, res, match, ctx) {
     const result = await loadDagNodeExecutionOutput(ctx.repoRoot, dagRunId, nodeId, key);
     sendJson(res, result.status, result.body);
 }
+async function handleDagNodeProcess(_req, res, match, ctx) {
+    const dagRunId = match.params.id;
+    const nodeId = match.params.sub;
+    if (!isSafeObservabilityIdentifier(dagRunId) ||
+        !isSafeObservabilityIdentifier(nodeId)) {
+        sendJson(res, 400, { error: "Invalid dag run or node identifier" });
+        return;
+    }
+    if (match.query.has("path") || match.query.has("artifactPath")) {
+        sendJson(res, 400, {
+            error: "Artifact path is not accepted; use optional key=attempt-N|pass-N",
+            reason: "path-not-allowed",
+        });
+        return;
+    }
+    const result = await loadDagNodeProcess(ctx.repoRoot, dagRunId, nodeId, match.query.get("key"));
+    sendJson(res, result.status, result.body);
+}
 async function handleDagNodeSessionEvents(_req, res, match, ctx) {
     const dagRunId = match.params.id;
     const nodeId = match.params.sub;

package/dist/worker/observe/shell-handler-keys.js

@@ -0,0 +1,34 @@
+/**
+ * Allowlist of in-process shell handlers (preset/gate flags on task.shell).
+ * Observe projects these names; the executor writes process receipts for them.
+ */
+export const SHELL_NAMED_HANDLER_KEYS = [
+    "verdictGate",
+    "projectGovernanceGate",
+    "requirementCoverageGate",
+    "jsonArtifactGate",
+    "frontendPrewriteGate",
+    "frontendLintBaseline",
+    "frontendVerificationBundle",
+    "frontendReviewContext",
+    "frontendTestCaseChecklist",
+    "frontendBrowserToolPreflight",
+    "frontendTestStandardScenarios",
+    "frontendTestEnvironmentProbe",
+    "frontendTestEvidenceValidation",
+    "finalWriteSetApprovalGate",
+    "frontendTestL5Report",
+    "frontendTestHtmlReport",
+    "frontendTestCaseManifest",
+    "frontendTestResultFinalize",
+    "frontendTestReports",
+    "backendTestPipeline",
+    "jacocoCoverage",
+    "verifyEvidence",
+    "repairArtifactGate",
+];
+export function namedShellHandlers(shell) {
+    if (!shell)
+        return [];
+    return SHELL_NAMED_HANDLER_KEYS.filter((key) => shell[key] != null);
+}

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

@@ -77,6 +77,14 @@ export async function fetchDagNodeInput(runId, nodeId) {
 	return fetchJsonResult(url);
 }
 
+export async function fetchDagNodeProcess(runId, nodeId, key) {
+	const params = new URLSearchParams();
+	if (key) params.set("key", String(key));
+	const qs = params.toString();
+	const url = `/api/dag-runs/${encodeURIComponent(runId)}/nodes/${encodeURIComponent(nodeId)}/process${qs ? `?${qs}` : ""}`;
+	return fetchJsonResult(url);
+}
+
 /**
  * Fetch a spec-evidence file preview (binding source or successful read).
  * Resolves to the parsed JSON body, or throws an Error carrying the HTTP

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

@@ -53,7 +53,14 @@ export const UI_TEXT = {
 	inputError: "加载节点输入失败。",
 	inputFrozenLabel: "冻结 DAG 节点定义",
 	inputFingerprintNote: "仅保存 assembled prompt 指纹，全文未持久化",
-	noSessionEvents: "该节点暂无过程日志",
+	noSessionEvents: "该 Pi 节点暂无过程日志（可能尚未执行、走 CLI 路径，或为历史 run）",
+	noShellProcess: "该 shell 节点尚未留下命令回执。",
+	noPresetProcess: "该内部处理器尚未留下过程回执。",
+	staticNoProcess: "静态节点没有逐步执行过程，请查看节点输出。",
+	processLoading: "正在加载执行过程…",
+	processError: "加载执行过程失败。",
+	shellCommandsHeading: "Shell 命令",
+	shellPresetHeading: "内部处理器",
 	noArtifacts: "暂无产物记录。",
 	noActiveCommand: "当前没有正在执行的命令。",
 	noFailures: "当前没有异常 Task。",

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

@@ -345,3 +345,26 @@ export function formatRepoPathDisplay(repoRoot) {
 		.replace(/^\/Users\/[^/]+/, "~")
 		.replace(/^\/home\/[^/]+/, "~");
 }
+
+/**
+ * If `text` is a complete JSON object or array, return pretty-printed JSON.
+ * Primitives, JSONL, truncated/invalid JSON, and markdown return null so
+ * callers can fall back to Markdown rendering.
+ */
+export function prettyJsonBlock(text) {
+	if (typeof text !== "string") return null;
+	const trimmed = text.trim();
+	if (trimmed.length < 2) return null;
+	const start = trimmed[0];
+	const end = trimmed[trimmed.length - 1];
+	if (!((start === "{" && end === "}") || (start === "[" && end === "]"))) {
+		return null;
+	}
+	try {
+		const value = JSON.parse(trimmed);
+		if (value === null || typeof value !== "object") return null;
+		return JSON.stringify(value, null, 2);
+	} catch {
+		return null;
+	}
+}

package/dist/worker/observe/static/markdown-render.js

@@ -1,6 +1,10 @@
 /** Shared safe Markdown → DOM rendering for Observe UI. */
 import { el } from "./dom.js";
-import { parseMarkdownBlocks, markdownLinkHref } from "./format.js";
+import {
+	parseMarkdownBlocks,
+	markdownLinkHref,
+	prettyJsonBlock,
+} from "./format.js";
 
 export function appendInlineMarkdown(target, text) {
 	const tokenPattern = /(`[^`]*`|\*\*[^*]+\*\*|\*[^*]+\*|\[[^\]]+\]\([^)]+\))/g;
@@ -49,6 +53,21 @@ export function appendParagraphMarkdown(target, text) {
 	}
 }
 
+export function renderInspectorDocument(content) {
+	const pretty = prettyJsonBlock(content);
+	if (pretty != null) {
+		const article = el("article", "markdown-output json-output");
+		const pre = document.createElement("pre");
+		const code = document.createElement("code");
+		code.dataset.language = "json";
+		code.textContent = pretty;
+		pre.appendChild(code);
+		article.appendChild(pre);
+		return article;
+	}
+	return renderMarkdown(content);
+}
+
 export function renderMarkdown(content) {
 	const article = el("article", "markdown-output");
 	for (const block of parseMarkdownBlocks(content)) {

package/dist/worker/observe/static/operator-chrome.js

@@ -436,6 +436,10 @@ export function mountOperatorChrome(root, config = {}) {
 			const a = el("a", `och-mode-btn${btn.active ? " och-on" : ""}`);
 			a.href = btn.href;
 			a.dataset.mode = btn.id;
+			// 2026-08-22: inline-flex 布局下裸文本节点不参与 name-from-content，
+			// a11y snapshot 序列化为无名 link；显式 aria-label 保证「操作/观测」
+			// 对 find/读屏稳定可断言（frontend-test passed 权威依赖可见 find）。
+			a.setAttribute("aria-label", btn.label);
 			if (btn.active) a.setAttribute("aria-current", "page");
 			a.appendChild(makeIcon(btn.id === "operate" ? "zap" : "eye"));
 			a.appendChild(document.createTextNode(btn.label));

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

@@ -61,6 +61,12 @@ export const uiState = {
 	dagNodeInputData: null,
 	dagNodeInputError: null,
 	dagNodeInputLoading: false,
+	/** Node-process request identity ("<dagRunId>:<nodeId>:<key>#<seq>"). */
+	dagNodeProcessIdentity: null,
+	dagNodeProcessRequestSeq: 0,
+	dagNodeProcessData: null,
+	dagNodeProcessError: null,
+	dagNodeProcessLoading: false,
 	/**
 	 * Execution-output request identity ("<dagRunId>:<nodeId>:<key>#<seq>").
 	 * Stale async responses are rejected when this no longer matches.
@@ -222,6 +228,11 @@ export function makeDagNodeInputIdentity(dagRunId, nodeId) {
 	return `${dagRunId}:${nodeId}#${uiState.dagNodeInputRequestSeq}`;
 }
 
+export function makeDagNodeProcessIdentity(dagRunId, nodeId, key) {
+	uiState.dagNodeProcessRequestSeq += 1;
+	return `${dagRunId}:${nodeId}:${key ?? "latest"}#${uiState.dagNodeProcessRequestSeq}`;
+}
+
 /** Build a fresh execution-output identity token (includes key). */
 export function makeDagNodeExecutionOutputIdentity(dagRunId, nodeId, key) {
 	uiState.dagNodeExecutionOutputRequestSeq += 1;

package/dist/worker/observe/static/styles.css

@@ -2111,6 +2111,9 @@ body.is-resizing-dag-graph {
 	background: transparent;
 	color: inherit;
 }
+.markdown-output.json-output pre {
+	white-space: pre;
+}
 .markdown-output a {
 	color: var(--orange-active);
 	text-decoration-color: var(--orange);

package/dist/worker/observe/static/views/dag-inspector.js

@@ -11,14 +11,15 @@ import {
 } from "../constants.js";
 import { clearNode, el } from "../dom.js";
 import { attemptFailureLabel } from "../dag-history-labels.js";
-import { fetchJson, fetchSpecEvidenceFile, fetchDagNodeInput } from "../api.js";
-import { badge, formatMs } from "../format.js";
-import { renderMarkdown } from "../markdown-render.js";
+import { fetchJson, fetchSpecEvidenceFile, fetchDagNodeInput, fetchDagNodeProcess } from "../api.js";
+import { badge, formatMs, prettyJsonBlock } from "../format.js";
+import { renderMarkdown, renderInspectorDocument } from "../markdown-render.js";
 import {
 	uiState,
 	makeSessionEventIdentity,
 	makeDagNodeInputIdentity,
 	makeDagNodeExecutionOutputIdentity,
+	makeDagNodeProcessIdentity,
 	getDagNodeExecutionOutputCache,
 	setDagNodeExecutionOutputCache,
 	clearDagNodeExecutionOutputCache,
@@ -68,6 +69,10 @@ function resetInspectorNodeSelection(dagRunId, nodeId) {
 	uiState.dagNodeInputData = null;
 	uiState.dagNodeInputError = null;
 	uiState.dagNodeInputLoading = false;
+	uiState.dagNodeProcessData = null;
+	uiState.dagNodeProcessError = null;
+	uiState.dagNodeProcessLoading = false;
+	uiState.dagNodeProcessIdentity = null;
 	// Drop execution-output cache/identity so node A's bodies never leak into B.
 	clearDagNodeExecutionOutputCache();
 	// Bump the session-event identity token so any in-flight response for the
@@ -748,6 +753,12 @@ function renderDagNodeInputDetail(content, data) {
 				(shell.gates ?? []).join(", ") || "(none)",
 				null,
 			);
+			appendMetaRow(
+				shellDl,
+				"handlers",
+				(shell.handlers ?? []).join(", ") || "(none)",
+				null,
+			);
 			section.appendChild(shellDl);
 			if ((shell.commands ?? []).length > 0) {
 				const list = el("ol", "node-input-command-list");
@@ -1305,7 +1316,7 @@ function appendOutputBody(content, outputText, errorText, options = null) {
 		content.appendChild(el("p", "empty", UI_TEXT.noOutput));
 		return;
 	}
-	if (outputText) content.appendChild(renderMarkdown(outputText));
+	if (outputText) content.appendChild(renderInspectorDocument(outputText));
 	// Truncation note only for full/cached execution-output bodies (AC-003);
 	// preview path never invents truncated/maxBytes.
 	if (options?.truncated === true) {
@@ -1321,7 +1332,7 @@ function appendOutputBody(content, outputText, errorText, options = null) {
 	if (errorText) {
 		const error = el("section", "markdown-error");
 		error.appendChild(el("p", "markdown-error-title", "错误输出"));
-		error.appendChild(renderMarkdown(errorText));
+		error.appendChild(renderInspectorDocument(errorText));
 		content.appendChild(error);
 	}
 }
@@ -1455,6 +1466,228 @@ function repaintOutputTabBody(content, dagRunId, node) {
 	restoreInspectorContentScroll(content, dagRunId, node.nodeId, "output");
 }
 
+function processEmptyMessage(body) {
+	const reason = body?.emptyReason;
+	if (reason === "static-no-process") return UI_TEXT.staticNoProcess;
+	if (reason === "shell-receipt-missing") return UI_TEXT.noShellProcess;
+	if (reason === "shell-preset-pending") return UI_TEXT.noPresetProcess;
+	if (reason === "pi-session") return UI_TEXT.noSessionEvents;
+	return UI_TEXT.noSessionEvents;
+}
+
+function formatProcessBlock(text) {
+	if (!text) return "";
+	return prettyJsonBlock(text) ?? text;
+}
+
+function appendProcessPre(parent, text) {
+	if (!text) return;
+	const pre = el("pre", "process-timeline-code");
+	pre.textContent = formatProcessBlock(text);
+	parent.appendChild(pre);
+}
+
+function renderProcessCommandCard(command) {
+	const failed = command.ok === false;
+	const card = el(
+		"div",
+		`process-timeline-card process-timeline-tool-card${failed ? " is-error" : ""}`,
+	);
+	const details = document.createElement("details");
+	details.className = "process-timeline-details";
+	details.open = failed;
+	const summary = el("summary", "process-timeline-summary");
+	summary.appendChild(
+		el("span", "process-timeline-summary-title", command.command || "command"),
+	);
+	summary.appendChild(
+		el(
+			"span",
+			`process-timeline-summary-status status-${failed ? "failed" : "succeeded"}`,
+			failed ? "失败" : command.reused ? "复用" : "成功",
+		),
+	);
+	details.appendChild(summary);
+	const body = el("div", "process-timeline-card-body");
+	const meta = [
+		command.exitCode != null ? `exit ${command.exitCode}` : null,
+		command.durationMs != null ? `耗时 ${formatMs(command.durationMs)}` : null,
+		command.failureCategory ? command.failureCategory : null,
+	].filter(Boolean);
+	if (meta.length > 0) {
+		body.appendChild(el("div", "process-timeline-section-label", meta.join(" · ")));
+	}
+	if (command.stdout) {
+		body.appendChild(el("div", "process-timeline-section-label", "stdout"));
+		appendProcessPre(body, command.stdout);
+	}
+	if (command.stderr) {
+		body.appendChild(el("div", "process-timeline-section-label", "stderr"));
+		appendProcessPre(body, command.stderr);
+	}
+	if (command.truncated) {
+		body.appendChild(el("p", "muted", "内容过长，已截断。"));
+	}
+	details.appendChild(body);
+	card.appendChild(details);
+	return card;
+}
+
+function renderProcessStepCard(step) {
+	const failed = step.ok === false;
+	const card = el(
+		"div",
+		`process-timeline-card process-timeline-tool-card${failed ? " is-error" : ""}`,
+	);
+	const details = document.createElement("details");
+	details.className = "process-timeline-details";
+	details.open = true;
+	const summary = el("summary", "process-timeline-summary");
+	summary.appendChild(
+		el("span", "process-timeline-summary-title", step.label || step.id || "step"),
+	);
+	summary.appendChild(
+		el(
+			"span",
+			`process-timeline-summary-status status-${failed ? "failed" : "succeeded"}`,
+			failed ? "失败" : "成功",
+		),
+	);
+	details.appendChild(summary);
+	const body = el("div", "process-timeline-card-body");
+	if (step.durationMs != null) {
+		body.appendChild(
+			el("div", "process-timeline-section-label", `耗时 ${formatMs(step.durationMs)}`),
+		);
+	}
+	if (step.detail) appendProcessPre(body, step.detail);
+	if (step.truncated) {
+		body.appendChild(el("p", "muted", "内容过长，已截断。"));
+	}
+	details.appendChild(body);
+	card.appendChild(details);
+	return card;
+}
+
+function renderNonPiProcess(content, body) {
+	content.classList.add("process-timeline-scroll");
+	if (!body || body.emptyReason || ((body.commands ?? []).length === 0 && (body.steps ?? []).length === 0)) {
+		content.appendChild(el("p", "empty", processEmptyMessage(body)));
+		return;
+	}
+	const heading =
+		body.kind === "shell-preset"
+			? UI_TEXT.shellPresetHeading
+			: UI_TEXT.shellCommandsHeading;
+	if (body.handler) {
+		content.appendChild(
+			el("p", "process-timeline-note", `${heading} · ${body.handler}`),
+		);
+	}
+	const ul = el("ul", "process-timeline process-timeline-rich");
+	const items = (body.commands ?? []).length > 0 ? body.commands : body.steps ?? [];
+	for (let index = 0; index < items.length; index += 1) {
+		const item = items[index];
+		const failed = item.ok === false;
+		const li = el(
+			"li",
+			`process-timeline-item process-timeline-tool-end${failed ? " is-error" : ""}${index === 0 ? " is-first" : ""}${index === items.length - 1 ? " is-last" : ""}`,
+		);
+		const rail = el("span", "process-timeline-rail");
+		rail.appendChild(el("span", "process-timeline-dot"));
+		li.appendChild(rail);
+		const cardBody = el("div", "process-timeline-body");
+		cardBody.appendChild(
+			body.kind === "shell-preset"
+				? renderProcessStepCard(item)
+				: renderProcessCommandCard(item),
+		);
+		li.appendChild(cardBody);
+		ul.appendChild(li);
+	}
+	content.appendChild(ul);
+}
+
+export async function mergeNodeProcess(dagRunId, node) {
+	if (!dagRunId || !node?.nodeId) return;
+	const nodeId = node.nodeId;
+	const key = effectiveExecutionKey(dagRunId, node);
+	const identity = makeDagNodeProcessIdentity(dagRunId, nodeId, key);
+	uiState.dagNodeProcessIdentity = identity;
+	uiState.dagNodeProcessLoading = true;
+	const result = await fetchDagNodeProcess(dagRunId, nodeId, key);
+	if (uiState.dagNodeProcessIdentity !== identity) return;
+	if (!result.ok || !result.body) {
+		uiState.dagNodeProcessError =
+			result.body?.error || UI_TEXT.processError;
+		uiState.dagNodeProcessData = {
+			schemaVersion: 1,
+			dagRunId,
+			nodeId,
+			kind: "none",
+			executor: node.executor ?? null,
+			handler: null,
+			emptyReason: "not-executed",
+			key: key ?? null,
+			commands: [],
+			steps: [],
+		};
+		uiState.dagNodeProcessLoading = false;
+		return;
+	}
+	uiState.dagNodeProcessError = null;
+	uiState.dagNodeProcessData = result.body;
+	uiState.dagNodeProcessLoading = false;
+}
+
+function renderExecutorAwareTimeline(content, dagRunId, node) {
+	content.dataset.dagRunId = String(dagRunId ?? "");
+	content.dataset.nodeId = String(node.nodeId ?? "");
+	const key = effectiveExecutionKey(dagRunId, node);
+	const cached = uiState.dagNodeProcessData;
+	const sameNode =
+		cached &&
+		cached.dagRunId === dagRunId &&
+		cached.nodeId === node.nodeId &&
+		(cached.key ?? null) === (key ?? null);
+	if (sameNode && uiState.dagNodeProcessError) {
+		content.appendChild(el("p", "empty", uiState.dagNodeProcessError));
+		return;
+	}
+	if (sameNode && cached.kind === "pi-session") {
+		renderSessionTimeline(content, node.nodeId, {
+			executionKey: effectiveExecutionKey(dagRunId, node),
+		});
+		return;
+	}
+	if (sameNode && cached.kind !== "pi-session") {
+		renderNonPiProcess(content, cached);
+		return;
+	}
+	if ((node.executor ?? "pi") === "pi") {
+		renderSessionTimeline(content, node.nodeId, {
+			executionKey: effectiveExecutionKey(dagRunId, node),
+		});
+		return;
+	}
+	if (uiState.dagNodeProcessError && sameNode) {
+		content.appendChild(el("p", "empty", uiState.dagNodeProcessError));
+		return;
+	}
+	const loading = el("p", "muted", UI_TEXT.processLoading);
+	loading.setAttribute("role", "status");
+	content.appendChild(loading);
+	void mergeNodeProcess(dagRunId, node).then(() => {
+		if (
+			uiState.dagInspectorTab === "timeline" &&
+			uiState.selectedDagNodeId === node.nodeId &&
+			uiState.currentDagRunId === dagRunId
+		) {
+			renderDagInspectorForCurrent();
+		}
+	});
+}
+
 function fillDagInspectorContent(content, dagRunId, node) {
 	const previousRenderedNode = content.dataset.dagNodeId ?? "";
 	const previousRenderedRun = content.dataset.dagRunId ?? "";
@@ -1504,9 +1737,7 @@ function fillDagInspectorContent(content, dagRunId, node) {
 	} else if (activeTab === "timeline") {
 		const attemptBuilt = buildAttemptBar(dagRunId, node);
 		if (attemptBuilt?.bar) content.appendChild(attemptBuilt.bar);
-		renderSessionTimeline(content, node.nodeId, {
-			executionKey: effectiveExecutionKey(dagRunId, node),
-		});
+		renderExecutorAwareTimeline(content, dagRunId, node);
 	} else if (activeTab === "input") {
 		void renderDagNodeInput(content, dagRunId, node);
 	} else {
@@ -1659,7 +1890,14 @@ function dagInspectorSignature(dagRunId, node) {
 					uiState.dagNodeExecutionOutputLoading ? "loading" : "idle",
 				]
 			: tab === "timeline"
-				? [uiState.sessionEventOffset]
+				? [
+						uiState.sessionEventOffset,
+						uiState.dagNodeProcessData?.kind ?? "",
+						uiState.dagNodeProcessData?.emptyReason ?? "",
+						(uiState.dagNodeProcessData?.commands ?? []).length,
+						(uiState.dagNodeProcessData?.steps ?? []).length,
+						uiState.dagNodeProcessLoading ? "loading" : "idle",
+					]
 				: [node.status ?? ""];
 	// Attempt dimension: selection identity + history shape. Poll refreshes keep
 	// the DOM while selection/history are unchanged; switching attempt or a

package/dist/worker/observe/static/views/dag.js

@@ -90,6 +90,7 @@ import {
 	closeDagInspector,
 	selectDagNode,
 	renderDagInspector,
+	mergeNodeProcess,
 } from "./dag-inspector.js";
 import { mergeSessionEvents } from "./session-timeline.js";
 
@@ -451,13 +452,19 @@ export async function renderDagDetail(dagRunId, initial = true) {
 	nodesEl.scrollLeft = nodesScrollLeft;
 
 	if (uiState.dagInspectorOpen && uiState.selectedDagNodeId) {
+		const selectedNode = nodes.find(
+			(node) => node.nodeId === uiState.selectedDagNodeId,
+		);
 		if (!uiState.sessionEventIdentity) {
 			uiState.sessionEventIdentity = makeSessionEventIdentity(
 				dagRunId,
 				uiState.selectedDagNodeId,
 			);
 		}
-		await mergeSessionEvents(dagRunId, uiState.selectedDagNodeId);
+		await Promise.all([
+			mergeSessionEvents(dagRunId, uiState.selectedDagNodeId),
+			selectedNode ? mergeNodeProcess(dagRunId, selectedNode) : Promise.resolve(),
+		]);
 	}
 	renderDagInspector(
 		dagRunId,

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

@@ -1500,8 +1500,26 @@ print(json.dumps(out,ensure_ascii=True))
     // Windows Python may expose stdin as GBK; decoding generated Chinese/emoji
     // source through that locale can create surrogateescape code points and make
     // ast.parse fail with "surrogates not allowed".
-    const result = spawnSync("python", ["-c", program], { input: Buffer.from(source, "utf8"), encoding: "utf8", maxBuffer: 4 * 1024 * 1024, windowsHide: true });
-    if (result.status !== 0 || !result.stdout.trim())
+    // POSIX images usually expose only `python3` (modern macOS has no `python`);
+    // Windows often has a real `python` plus a Microsoft Store `python3` stub.
+    // A missing interpreter must not silently degrade to empty payload shapes.
+    const interpreterCandidates = process.platform === "win32" ? ["python", "python3"] : ["python3", "python"];
+    let result;
+    for (const interpreter of interpreterCandidates) {
+        const attempt = spawnSync(interpreter, ["-c", program], {
+            input: Buffer.from(source, "utf8"),
+            encoding: "utf8",
+            maxBuffer: 4 * 1024 * 1024,
+            windowsHide: true,
+        });
+        // Interpreter missing/unspawnable → try the next candidate. A spawned
+        // interpreter that exits nonzero analyzed real input; do not retry then.
+        if (attempt.error)
+            continue;
+        result = attempt;
+        break;
+    }
+    if (!result || result.status !== 0 || !result.stdout.trim())
         return new Map();
     try {
         const parsed = JSON.parse(result.stdout);

package/dist/workflows/dag/failure-category.js

@@ -45,6 +45,13 @@ const RAW_TO_NORMALIZED = {
     quota: "executor",
     "rate-limit": "executor",
     unavailable: "executor",
+    // Deterministic capability/policy refusal: missing verified launcher JS
+    // entry, capability allowlist rejection, or missing bounded write tool
+    // profile. These are environment/config defects the operator repairs
+    // before rerunning; classify as executor so recovery recommends
+    // rerun-after-fix WITHOUT forcing a human-decision gate on
+    // standaloneTaskRerun (run-failed same-task rerun).
+    "tool-policy": "executor",
     unknown: "unknown",
 };
 function isFinishedStatus(status) {

package/package.json

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