@tea-agent/loop-agent 0.20.1 → 0.21.0

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## [Unreleased]
 
+## [0.21.0] - 2026-07-24
+
+### 重点更新
+
+- DAG/Pi 自适应活跃度监管：精准区分传输活动与真实执行进展，受控处置静默卡死，避免误杀。
+- 后端测试执行范围收窄：仅运行最终 Markdown 明确映射且通过安全校验的脚本，杜绝无关测试混入。
+- 后端测试 HTML 报告全面升级：采用清晰的用例卡片，直观展示脱敏的请求与响应详情。
+
+### 新增
+
+- DAG/Pi 自适应 liveness 与非误杀监管：区分 runner lease、transport 活动与 Provider/tool/output 真实进展；节点可投影 active/quiet/suspected-stall/probing/needs-attention；静默 stall 会受控终止，退出无法确认时禁止自动重试；Pi absolute max 对齐 4h；Worker 默认不再给 `run-dag` 设置外层 wall-clock，显式 `worker.timeout_ms` 仍为 hard timeout。
+
+### 改进
+
+- backend-test 第 7 节点现在只执行最终 Markdown `自动化映射` 明确声明且安全校验通过的 pytest 脚本，避免历史或无关 `test_*.py` 混入本轮 JUnit/HTML；空映射、缺失脚本或越界路径会 fail-closed。
+- backend-test HTML 报告升级为更清晰的用例卡片：保留测试结论、质量状态和失败概览，直接展示简洁测试场景、自动化用例名称、结果与耗时，并为通过/失败用例都展示同次执行中脱敏且有界的接口请求参数与响应结果；HTML 不再附带技术证据章节，审计路径与哈希继续保留在 facts/JUnit。
+- 新初始化项目的 harness 指南同步 adaptive liveness、4h absolute max、stall 状态与 `termination-unconfirmed` 处置；旧项目可由 `init check-update` 识别未修改的受管指南，并通过 `init update --apply-safe` 安全刷新。
+
 ## [0.20.1] - 2026-07-24
 
 ### 新增
@@ -17,6 +35,9 @@
 
 ### 改进
 
+- backend-test 第 4 个 Markdown 校验节点只将前置条件、操作步骤和预期结果作为必需章节；需求来源引用有效性不再阻断后续测试。普通质量问题保持 advisory，但 secret-shaped 值会先生成脱敏安全报告再 fail-closed，避免进入 pytest、HTML/facts 和最终报告。
+- backend-test 生成的真实 HTTP pytest 现在必须输出脱敏且有界的请求/响应日志，包含 method、URL/path、请求参数摘要、响应状态和响应 body 摘要；追溯节点会在 Markdown 映射脚本范围内把日志合同缺口记录为 advisory。
+- backend-test 第 7 节点的 HTML/facts 按测试概览、质量校验、失败概览、用例执行明细和技术证据分层展示；第 8 节点使用固定简洁的中文收口结构，减少重复原文并优先展示结论和风险。
 - Operator Console「恢复」面板自动拉取 DAG 运行与节点候选，优先展示失败项并以选择器填入，仍可手动输入
 - 从节点重跑预检失败时展示真实安全资格阻断原因，不再误报为「无法获取 planHash」
 - 恢复页长操作（完整重跑等）会回写终态成功/失败；不再只提示「已接受」后无下文
@@ -33,6 +54,11 @@
 - frontend-test 环境预检：在生成用例前对冻结的非生产 `baseUrl` 做 curl 可达性探测；不可达或缺少 curl 时以 `frontend-base-url-unreachable` / `curl-unavailable` 阻断 generate/map，并写入 `environmentProbe` 事实。节点 5 manifest 物化改为 ruleId 失败分类、map 配额预检与 temp+rename 原子写入；生成/清单/执行强制 playwright-cli-only，U/D 场景要求当前用户数据归属或 create/Mock/blocked。
 - 前端测试 DAG 的证据自检改为按用例降级：个别缺失、空白或格式错误的证据会如实标为 blocked 并继续生成复盘报告；只有全部用例都未产生任何证据内容或证据路径不安全时才失败。
 
+### 修复
+
+- Observe 总览 KPI 问号提示框宽度与窄卡片解耦：提示框使用稳定的 240–280px 视口安全宽度，并在五列、三列和两列布局的右侧列向内对齐，避免宽屏下被压缩成约 78px 的窄条；hover 与键盘焦点行为保持不变。
+- 节点检查器的规范证据文件预览会渲染 Markdown 标题、列表、表格与代码块，不再把正文作为带语法标记的纯文本显示。
+
 ## [0.20.0] - 2026-07-23
 
 ### 新增

package/dist/commands/init.js

@@ -2057,6 +2057,13 @@ function buildTargetLoopAgentHarness(input) {
         "",
         "Use `loop-agent new-task`, `loop-agent dag run-task`, `loop-agent dag validate`, and `loop-agent run-dag` for non-trivial implementation work.",
         "",
+        "## Adaptive Liveness",
+        "",
+        "- Healthy Pi nodes are no longer stopped by a fixed 30-minute deadline. The default 4h absolute max is a final safety bound and cannot be extended by synthetic heartbeats.",
+        "- Runner heartbeat proves only the runner lease. Provider, tool, or output activity records meaningful progress; prolonged inactivity can surface as `quiet`, `suspected-stall`, `probing`, or `needs-attention` in `dag status`, `dag doctor`, and Observe.",
+        "- A silent transport is aborted in a controlled way. `termination-unconfirmed` means the old attempt may still exist, so loop-agent fails closed and does not start an automatic retry; inspect the run before any operator recovery.",
+        "- `agent-worker` does not set an outer `run-dag` wall-clock by default. An explicit `worker.timeout_ms` remains a hard timeout.",
+        "",
         "## Operator Recovery",
         "",
         "After a run, use `loop-agent dag report --run-id <run-id> --markdown` to read canonical run facts and `loop-agent dag doctor --run-id <run-id> --markdown` to diagnose failed or paused runs. Failed DAG runs should produce a failure handoff via `loop-agent dag closeout-draft --run-id <run-id>` instead of a successful closeout.",

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

@@ -263,6 +263,17 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep) {
             beforePathFingerprints = undefined;
         }
     }
+    const reportActivity = input.reportActivity;
+    const attempt = input.attempt ?? 1;
+    const bridgeActivity = reportActivity
+        ? (kind, at) => {
+            reportActivity({
+                attempt,
+                kind,
+                at: at ?? new Date().toISOString(),
+            });
+        }
+        : undefined;
     const result = await piStepFn({
         attachedFiles: [],
         modelConfig: resolveDagPiModelConfig(input.model),
@@ -272,6 +283,19 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep) {
         toolNames: resolveDagPiToolNames(input.task),
         userMessage: buildDagPiUserMessage(input.task, persona, step),
         sessionEventsPath: path.join(meta.runDir, input.task.id, "session-events.jsonl"),
+        // Absolute max wall clock from adaptive liveness policy (defaults to 4h).
+        timeoutMs: input.timeoutMs,
+        stallTimeoutMs: input.stallTimeoutMs,
+        abortGraceMs: input.abortGraceMs,
+        onActivity: bridgeActivity
+            ? (activity) => {
+                if (activity.kind === "lease"
+                    || activity.kind === "synthetic-heartbeat") {
+                    return;
+                }
+                bridgeActivity(activity.kind, activity.at);
+            }
+            : undefined,
     });
     const context = {
         channel: "dag",

package/dist/executors/pi-executor.js

@@ -47,8 +47,13 @@ export function extractSubagentStats(stdout) {
         parts.push(`agents=[${Array.from(agents).sort().join(',')}]`);
     return parts.join(' | ');
 }
-export const DEFAULT_TIMEOUT_MS = 1_800_000;
-export const MAX_ALLOWED_TIMEOUT_MS = 1_800_000;
+/** Absolute max wall clock for a single Pi attempt (4h). Not renewed by empty heartbeats. */
+export const DEFAULT_TIMEOUT_MS = 14_400_000;
+export const MAX_ALLOWED_TIMEOUT_MS = 14_400_000;
+/** Max provider/CLI transport silence before initiating a controlled abort (15m). */
+export const DEFAULT_STALL_TIMEOUT_MS = 900_000;
+/** Grace after SIGTERM before SIGKILL on absolute max. */
+export const DEFAULT_ABORT_GRACE_MS = 30_000;
 const PI_BACKEND_ENV = 'CODE_AGENT_PI_BACKEND';
 const OUTPUT_PREVIEW_HEAD_CHARS = 64_000;
 const OUTPUT_PREVIEW_TAIL_CHARS = 64_000;
@@ -515,7 +520,9 @@ async function runCliOrchestration(options, meta) {
     }
     const primaryHardFail = !primaryResult.ok;
     const primaryInvalidOutput = primaryResult.ok && primaryIssues.length > 0;
-    const shouldFallback = primary.fallback && ((primaryHardFail && shouldRetryWithFallback(primaryResult.stderr, primaryResult.stdout))
+    const shouldFallback = primary.fallback && ((primaryHardFail
+        && primaryResult.failureCategory !== 'termination-unconfirmed'
+        && shouldRetryWithFallback(primaryResult.stderr, primaryResult.stdout))
         || primaryInvalidOutput);
     if (shouldFallback) {
         const fallbackResult = await executeSingleCliAttempt(options, primary.fallback);
@@ -590,7 +597,9 @@ async function runCliOrchestration(options, meta) {
 function shouldFallbackSdkToCli(sdkResult, validationIssues) {
     if (sdkResult.ok && validationIssues.length > 0)
         return true;
-    if (!sdkResult.ok && (sdkResult.failureCategory === 'auth' || sdkResult.failureCategory === 'timeout')) {
+    if (!sdkResult.ok && (sdkResult.failureCategory === 'auth'
+        || sdkResult.failureCategory === 'timeout'
+        || sdkResult.failureCategory === 'termination-unconfirmed')) {
         return false;
     }
     if (!sdkResult.ok && shouldRetryWithFallback(sdkResult.stderr, sdkResult.stdout))
@@ -655,9 +664,15 @@ async function executeSingleCliAttempt(options, modelConfig) {
         ? `${modelConfig.provider}/${modelConfig.model}`
         : modelConfig.model ?? 'default';
     const timeoutMs = options.timeoutMs ?? modelConfig.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const stallTimeoutMs = options.stallTimeoutMs ?? DEFAULT_STALL_TIMEOUT_MS;
+    const abortGraceMs = options.abortGraceMs ?? DEFAULT_ABORT_GRACE_MS;
     let timedOut = false;
+    let terminationUnconfirmed = false;
+    let supervisionStderr = '';
     let timeoutHandle;
+    let stallHandle;
     let sigkillHandle;
+    let exitConfirmationHandle;
     // Build pi CLI arguments (same as before).
     // We invoke pi via `node <pi-cli-path>` instead of relying on `#!/usr/bin/env node`
     // to avoid provider resolution issues when spawned from tsx-managed processes.
@@ -698,39 +713,39 @@ async function executeSingleCliAttempt(options, modelConfig) {
         const stdoutPreview = new BoundedTextPreview('stdout');
         const stderrPreview = new BoundedTextPreview('stderr', 16_000, 16_000);
         const stdoutCollector = new PiJsonlStreamCollector();
+        let settled = false;
         child.stdout.setEncoding('utf-8');
         child.stderr.setEncoding('utf-8');
-        child.stdout.on('data', (chunk) => {
-            stdoutPreview.append(chunk);
-            stdoutCollector.append(chunk);
-        });
-        child.stderr.on('data', (chunk) => {
-            stderrPreview.append(chunk);
-        });
-        child.on('error', (err) => {
-            if (timeoutHandle)
-                clearTimeout(timeoutHandle);
-            if (sigkillHandle)
-                clearTimeout(sigkillHandle);
-            reject(err);
-        });
-        child.on('close', (code) => {
+        const clearSupervisionTimers = () => {
             if (timeoutHandle)
                 clearTimeout(timeoutHandle);
+            if (stallHandle)
+                clearTimeout(stallHandle);
             if (sigkillHandle)
                 clearTimeout(sigkillHandle);
+            if (exitConfirmationHandle)
+                clearTimeout(exitConfirmationHandle);
+        };
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearSupervisionTimers();
             const durationMs = Date.now() - startedAt;
             const stdout = stdoutPreview.text();
-            const stderr = stderrPreview.text();
+            const capturedStderr = stderrPreview.text();
+            const stderr = [supervisionStderr, capturedStderr].filter(Boolean).join('\n');
             const collected = stdoutCollector.finish();
-            const failureCategory = classifyPiFailure({
-                assistantText: collected.assistantText,
-                exitCode: code,
-                stderr,
-                stdout,
-                timedOut,
-                outputTooLarge: collected.outputTooLarge,
-            });
+            const failureCategory = terminationUnconfirmed
+                ? 'termination-unconfirmed'
+                : classifyPiFailure({
+                    assistantText: collected.assistantText,
+                    exitCode: code,
+                    stderr,
+                    stdout,
+                    timedOut,
+                    outputTooLarge: collected.outputTooLarge,
+                });
             resolve({
                 assistantText: collected.assistantText,
                 command: ['pi', ...piArgs],
@@ -738,7 +753,7 @@ async function executeSingleCliAttempt(options, modelConfig) {
                 exitCode: code,
                 failureCategory,
                 modelDisplay,
-                ok: code === 0 && collected.assistantText.length > 0 && !collected.outputTooLarge,
+                ok: !timedOut && code === 0 && collected.assistantText.length > 0 && !collected.outputTooLarge,
                 parsedEvents: collected.parsedEvents,
                 stderr,
                 stdout,
@@ -749,16 +764,76 @@ async function executeSingleCliAttempt(options, modelConfig) {
                 tokensUsed: collected.tokensUsed,
                 subagentStats: collected.subagentStats,
             });
+        };
+        const hasConfirmedExitCode = () => child.exitCode !== null && child.exitCode !== undefined;
+        const beginControlledTermination = (reason) => {
+            if (timedOut || settled)
+                return;
+            timedOut = true;
+            supervisionStderr = reason;
+            child.kill('SIGTERM');
+            sigkillHandle = setTimeout(() => {
+                if (settled)
+                    return;
+                if (hasConfirmedExitCode()) {
+                    finish(child.exitCode);
+                    return;
+                }
+                child.kill('SIGKILL');
+                exitConfirmationHandle = setTimeout(() => {
+                    if (settled)
+                        return;
+                    if (hasConfirmedExitCode()) {
+                        finish(child.exitCode);
+                        return;
+                    }
+                    terminationUnconfirmed = true;
+                    supervisionStderr += `\npi CLI exit was not confirmed within ${abortGraceMs}ms after SIGKILL`;
+                    finish(null);
+                }, abortGraceMs);
+            }, abortGraceMs);
+        };
+        const armStallWatchdog = () => {
+            if (stallTimeoutMs <= 0 || timedOut || settled)
+                return;
+            if (stallHandle)
+                clearTimeout(stallHandle);
+            stallHandle = setTimeout(() => {
+                beginControlledTermination(`pi CLI step stalled after ${stallTimeoutMs}ms with no stdout/stderr activity`);
+            }, stallTimeoutMs);
+        };
+        const reportOutputActivity = () => {
+            armStallWatchdog();
+            try {
+                options.onActivity?.({ kind: 'output', at: new Date().toISOString() });
+            }
+            catch {
+                // best-effort: never fail the pi step
+            }
+        };
+        child.stdout.on('data', (chunk) => {
+            stdoutPreview.append(chunk);
+            stdoutCollector.append(chunk);
+            if (chunk.length > 0)
+                reportOutputActivity();
+        });
+        child.stderr.on('data', (chunk) => {
+            stderrPreview.append(chunk);
+            if (chunk.length > 0)
+                reportOutputActivity();
         });
+        child.on('error', (err) => {
+            clearSupervisionTimers();
+            settled = true;
+            reject(err);
+        });
+        child.on('close', (code) => {
+            finish(code);
+        });
+        armStallWatchdog();
         if (timeoutMs > 0) {
             timeoutHandle = setTimeout(() => {
-                timedOut = true;
-                child.kill('SIGTERM');
-                sigkillHandle = setTimeout(() => {
-                    if (child.exitCode === null) {
-                        child.kill('SIGKILL');
-                    }
-                }, 5_000);
+                beginControlledTermination(`pi CLI step timed out after ${timeoutMs}ms`);
             }, timeoutMs);
         }
     });

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

@@ -1,6 +1,6 @@
 import { appendFile, mkdir } from 'node:fs/promises';
 import path from 'node:path';
-import { BoundedTextPreview, classifyPiFailure, createPiJsonlStreamCollector, DEFAULT_TIMEOUT_MS, extractAssistantTextFromPiJson, } from './pi-executor.js';
+import { BoundedTextPreview, classifyPiFailure, createPiJsonlStreamCollector, DEFAULT_ABORT_GRACE_MS, DEFAULT_STALL_TIMEOUT_MS, DEFAULT_TIMEOUT_MS, extractAssistantTextFromPiJson, } from './pi-executor.js';
 import { serializeSessionEvent } from './pi-event-serializer.js';
 let sdkSessionFactoryOverride;
 let sdkImportOverrideForTests;
@@ -169,6 +169,21 @@ export function shouldPersistSessionEvent(event) {
     }
     return true;
 }
+function classifySdkActivityKind(event) {
+    if (!event || typeof event !== 'object')
+        return 'provider';
+    const type = typeof event.type === 'string'
+        ? String(event.type)
+        : '';
+    if (type === 'tool_start' || type === 'tool_end'
+        || type === 'tool_execution_start' || type === 'tool_execution_end') {
+        return 'tool';
+    }
+    if (type === 'thinking_delta' || type === 'message_update') {
+        return null;
+    }
+    return 'provider';
+}
 function createSessionEventAppender(filePath, onSessionEvent) {
     let chain = Promise.resolve();
     let dirEnsured = false;
@@ -181,6 +196,9 @@ function createSessionEventAppender(filePath, onSessionEvent) {
                         dirEnsured = true;
                     }
                     await appendFile(filePath, `${line}\n`, 'utf-8');
+                    // Only after successful persistence: surface the persisted session event.
+                    // Transport activity is reported synchronously by the subscription so
+                    // filtered deltas and slow disk writes cannot trip the stall watchdog.
                     onSessionEvent?.(line, event);
                 }
                 catch {
@@ -271,6 +289,8 @@ export async function executeSingleSdkAttempt(options) {
         ? `${modelConfig.provider}/${modelConfig.model}`
         : modelConfig.model ?? 'default';
     const timeoutMs = options.timeoutMs ?? modelConfig.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const stallTimeoutMs = options.stallTimeoutMs ?? DEFAULT_STALL_TIMEOUT_MS;
+    const abortGraceMs = options.abortGraceMs ?? DEFAULT_ABORT_GRACE_MS;
     const piSdkArgs = [
         '--provider', modelConfig.provider ?? '(default)',
         '--model', modelConfig.model ?? '(default)',
@@ -282,15 +302,46 @@ export async function executeSingleSdkAttempt(options) {
     ];
     const startedAt = Date.now();
     let timedOut = false;
+    let terminationConfirmed = true;
     let stderr = '';
     const stdoutPreview = new BoundedTextPreview('stdout');
     const stdoutCollector = createPiJsonlStreamCollector();
     const usageSamples = [];
     let session;
+    let unsubscribe;
     let timeoutHandle;
+    let stallHandle;
+    let disposeAttempted = false;
     const sessionEventAppender = options.sessionEventsPath
         ? createSessionEventAppender(options.sessionEventsPath, options.onSessionEvent)
         : undefined;
+    const appendStderr = (message) => {
+        stderr = stderr ? `${stderr}\n${message}` : message;
+    };
+    const runSessionActionWithGrace = async (label, action) => {
+        let graceHandle;
+        const outcome = await Promise.race([
+            Promise.resolve()
+                .then(action)
+                .then(() => ({ ok: true }))
+                .catch((error) => ({ ok: false, error })),
+            new Promise((resolve) => {
+                graceHandle = setTimeout(() => resolve({ ok: false, timedOut: true }), abortGraceMs);
+            }),
+        ]);
+        if (graceHandle)
+            clearTimeout(graceHandle);
+        if (outcome.ok)
+            return true;
+        if ('timedOut' in outcome) {
+            appendStderr(`pi SDK ${label} was not confirmed within ${abortGraceMs}ms`);
+        }
+        else {
+            const message = outcome.error instanceof Error ? outcome.error.message : String(outcome.error);
+            appendStderr(`pi SDK ${label} failed: ${message}`);
+        }
+        return false;
+    };
     try {
         const createSession = await resolveSdkSessionFactory(options.reuseScope);
         session = await createSession({
@@ -301,7 +352,32 @@ export async function executeSingleSdkAttempt(options) {
             model: modelConfig.model,
             thinking: modelConfig.thinking,
         });
-        const unsubscribe = session.subscribe((event) => {
+        let resolveStall;
+        const stallPromise = stallTimeoutMs > 0
+            ? new Promise((resolve) => {
+                resolveStall = resolve;
+            })
+            : null;
+        const armStallWatchdog = () => {
+            if (!stallPromise || !resolveStall)
+                return;
+            if (stallHandle)
+                clearTimeout(stallHandle);
+            stallHandle = setTimeout(() => resolveStall?.('stall'), stallTimeoutMs);
+        };
+        unsubscribe = session.subscribe((event) => {
+            // Every real SDK event proves transport activity, including noisy deltas
+            // intentionally excluded from persisted JSONL and meaningful DAG progress.
+            armStallWatchdog();
+            const activityKind = classifySdkActivityKind(event);
+            if (activityKind) {
+                try {
+                    options.onActivity?.({ kind: activityKind, at: new Date().toISOString() });
+                }
+                catch {
+                    // best-effort: activity must never change Pi result
+                }
+            }
             const usageSample = extractSdkUsageSample(event);
             if (usageSample)
                 usageSamples.push(usageSample);
@@ -317,44 +393,44 @@ export async function executeSingleSdkAttempt(options) {
             ? `${filePrefix}\n${options.userMessage}`
             : options.userMessage;
         const promptPromise = session.prompt(promptMessage);
+        armStallWatchdog();
         const timeoutPromise = timeoutMs > 0
             ? new Promise((resolve) => {
                 timeoutHandle = setTimeout(() => {
-                    timedOut = true;
-                    void session?.abort();
-                    resolve('timeout');
+                    resolve('absolute-timeout');
                 }, timeoutMs);
             })
             : null;
-        if (timeoutPromise) {
-            const raced = await Promise.race([
-                promptPromise.then(() => 'done'),
-                timeoutPromise,
-            ]);
-            if (raced === 'timeout') {
-                stderr = `pi SDK step timed out after ${timeoutMs}ms`;
-            }
+        const raced = await Promise.race([
+            promptPromise.then(() => 'done'),
+            ...(timeoutPromise ? [timeoutPromise] : []),
+            ...(stallPromise ? [stallPromise] : []),
+        ]);
+        if (raced !== 'done') {
+            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());
+            disposeAttempted = true;
+            const disposeConfirmed = await runSessionActionWithGrace('dispose', () => session.dispose());
+            terminationConfirmed = abortConfirmed && disposeConfirmed;
         }
-        else {
-            await promptPromise;
-        }
-        unsubscribe();
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        stderr = stderr ? `${stderr}\n${message}` : message;
+        appendStderr(message);
     }
     finally {
         if (timeoutHandle)
             clearTimeout(timeoutHandle);
-        if (session) {
-            try {
-                await session.dispose();
-            }
-            catch (disposeError) {
-                const message = disposeError instanceof Error ? disposeError.message : String(disposeError);
-                stderr = stderr ? `${stderr}\n${message}` : message;
-            }
+        if (stallHandle)
+            clearTimeout(stallHandle);
+        unsubscribe?.();
+        if (session && !disposeAttempted) {
+            disposeAttempted = true;
+            const disposeConfirmed = await runSessionActionWithGrace('dispose', () => session.dispose());
+            terminationConfirmed = terminationConfirmed && disposeConfirmed;
         }
         if (sessionEventAppender) {
             try {
@@ -378,14 +454,14 @@ export async function executeSingleSdkAttempt(options) {
         ? collected.parsedEvents
         : fallbackParsed?.parsedEvents ?? 0;
     const tokensUsed = aggregateSdkTokenUsage(usageSamples);
-    const failureCategory = classifyPiFailure({
+    const failureCategory = terminationConfirmed ? classifyPiFailure({
         assistantText,
         exitCode: timedOut ? 1 : stderr ? 1 : 0,
         outputTooLarge: collected.outputTooLarge,
         stderr,
         stdout,
         timedOut,
-    });
+    }) : 'termination-unconfirmed';
     return {
         assistantText,
         backend: 'sdk',
@@ -394,7 +470,7 @@ export async function executeSingleSdkAttempt(options) {
         exitCode: timedOut || stderr ? 1 : 0,
         failureCategory,
         modelDisplay,
-        ok: !timedOut && !stderr && assistantText.length > 0 && !collected.outputTooLarge,
+        ok: terminationConfirmed && !timedOut && !stderr && assistantText.length > 0 && !collected.outputTooLarge,
         parsedEvents,
         stderr,
         stdout,

package/dist/executors/shell-executor.js

@@ -17,7 +17,7 @@ import { formatFrontendReviewContextStdout, runFrontendReviewContextGate, } from
 import { formatTraceabilityGateStdout, materializeBackendTestCaseManifest, runBackendTestTraceabilityGate, } from "../workflows/dag/backend-test-case-manifest.js";
 import { materializeBackendTestExecutionContract } from "../workflows/dag/backend-test-execution-contract.js";
 import { materializeBackendTestResultFromRunDir, parseJunitXml } from "../workflows/dag/backend-test-result-contract.js";
-import { collectBackendTestHumanCaseCatalog, inspectBackendTestEnvironment, requiredBackendMarkdownCaseAcIds, renderBackendTestFacts, renderBackendTestHtml, redactBackendTestOutput, validateBackendMarkdownCases, validateBackendMarkdownTraceability, writeRunReport, } from "../workflows/dag/backend-test-markdown-workflow.js";
+import { collectBackendTestHumanCaseCatalog, collectBackendTestMappedPytestScripts, hasBlockingBackendMarkdownSafetyFindings, inspectBackendTestEnvironment, requiredBackendMarkdownCaseAcIds, renderBackendTestFacts, renderBackendTestHtml, redactBackendTestOutput, validateBackendMarkdownCases, validateBackendMarkdownTraceability, writeRunReport, } from "../workflows/dag/backend-test-markdown-workflow.js";
 import { buildBackendTestCanonicalResultFromInitialShellSnippet, materializeBackendTestClassification, } from "../workflows/dag/backend-test-classification-contract.js";
 import { backendTestSemanticReviewSchema, materializeBackendTestSemanticReview, } from "../workflows/dag/backend-test-semantic-review-contract.js";
 import { pathsChangedDuringRun, readGitStatusPorcelain, snapshotGitStatusPorcelain, validateShellWriteGuard, } from "./shell-write-guard.js";
@@ -304,6 +304,14 @@ async function runShellWriteGuard(input) {
         forbiddenPaths: input.task.forbiddenPaths,
     });
 }
+async function readRequiredRunReport(reportsDir, filename) {
+    try {
+        return await readFile(path.join(reportsDir, filename), "utf8");
+    }
+    catch {
+        throw new Error(`missing required upstream report: reports/${filename}`);
+    }
+}
 async function executeBackendTestPipeline(input, meta) {
     const pipeline = input.task.shell?.backendTestPipeline;
     const started = Date.now();
@@ -332,22 +340,54 @@ async function executeBackendTestPipeline(input, meta) {
                 meta.spec.objective ?? "",
                 ...(meta.spec.successCriteria ?? []),
             ]);
-            const report = await validateBackendMarkdownCases({
-                workspaceRoot: input.cwd,
-                environmentMarkdown,
-                requiredRequirementIds,
-                sourceBinding: meta.spec.sourceBinding,
-            });
+            let report;
+            try {
+                report = await validateBackendMarkdownCases({
+                    workspaceRoot: input.cwd,
+                    environmentMarkdown,
+                    requiredRequirementIds,
+                    sourceBinding: meta.spec.sourceBinding,
+                });
+            }
+            catch (error) {
+                report = `# Backend Markdown Case Validation\n\n## Status\n\nFAIL\n\n## Findings\n\n- Validator could not complete: ${error instanceof Error ? error.message : String(error)}\n`;
+            }
             const reportPath = await writeRunReport(meta.runDir, "backend-md-case-validation.md", report);
             outputs.push(`caseValidation=${reportPath}`, report);
+            if (hasBlockingBackendMarkdownSafetyFindings(report)) {
+                return {
+                    ok: false,
+                    stdout: outputs.join("\n"),
+                    stderr: "backend Markdown safety gate blocked: secret-shaped values detected",
+                    failureCategory: "invalid-output",
+                    durationMs: Date.now() - started,
+                };
+            }
         }
         else if (pipeline === "markdown-traceability") {
-            const report = await validateBackendMarkdownTraceability(input.cwd);
+            let report;
+            try {
+                report = await validateBackendMarkdownTraceability(input.cwd);
+            }
+            catch (error) {
+                report = `# Backend Test Traceability\n\n## Status\n\nFAIL\n\n## Findings\n\n- Traceability validation could not complete: ${error instanceof Error ? error.message : String(error)}\n`;
+            }
             const reportPath = await writeRunReport(meta.runDir, "backend-test-traceability.md", report);
             outputs.push(`traceability=${reportPath}`, report);
         }
         else if (pipeline === "markdown-execute-html") {
-            const results = await executePipelineCommands(input, meta);
+            const mappedScripts = await collectBackendTestMappedPytestScripts(input.cwd);
+            const shellQuote = (value) => `'${value.replaceAll("'", `'"'"'`)}'`;
+            const pytestTargets = mappedScripts.map(shellQuote).join(" ");
+            const pytestCommand = [
+                'mkdir -p "${HARNESS_DAG_RUN_DIR}/reports"',
+                `PYTHONUTF8=1 PYTHONIOENCODING=utf-8 PYTHONDONTWRITEBYTECODE=1 python -m pytest ${pytestTargets} -v -p no:cacheprovider -o junit_logging=all -o junit_log_passing_tests=true --junitxml="\${HARNESS_DAG_RUN_DIR}/reports/backend-test.junit.xml"`,
+                "STATUS=$?",
+                'printf "%s" "${STATUS}" > "${HARNESS_DAG_RUN_DIR}/reports/backend-test-pytest-exit.txt"',
+                'if { [ "${STATUS}" -eq 0 ] || [ "${STATUS}" -eq 1 ]; } && [ -s "${HARNESS_DAG_RUN_DIR}/reports/backend-test.junit.xml" ]; then exit 0; fi',
+                'exit "${STATUS}"',
+            ].join("; ");
+            const results = await executePipelineCommands(input, meta, [pytestCommand]);
             if (!results.every((result) => result.ok)) {
                 const failure = results.find((result) => !result.ok);
                 return { ok: false, stdout: results.map((result) => result.stdout).join("\n"), stderr: failure.stderr, failureCategory: failure.failureCategory, durationMs: Date.now() - started };
@@ -359,15 +399,18 @@ async function executeBackendTestPipeline(input, meta) {
                 throw new Error(`pytest did not complete with a reportable exit code: ${pytestExitCode}`);
             const parsed = parseJunitXml(junitContent);
             const cases = await collectBackendTestHumanCaseCatalog(input.cwd);
+            const caseValidationSummary = await readRequiredRunReport(reportsDir, "backend-md-case-validation.md");
+            const traceabilitySummary = await readRequiredRunReport(reportsDir, "backend-test-traceability.md");
             const htmlContent = renderBackendTestHtml({
                 title: meta.spec.title,
                 parsed,
                 cases,
                 environmentSummary: await readFile(path.join(reportsDir, "backend-test-environment.md"), "utf8"),
-                traceabilitySummary: await readFile(path.join(reportsDir, "backend-test-traceability.md"), "utf8"),
+                caseValidationSummary,
+                traceabilitySummary,
             });
             const htmlPath = await writeRunReport(meta.runDir, "backend-test.html", htmlContent);
-            const facts = renderBackendTestFacts({ parsed, cases, pytestExitCode, junitRelativePath: "reports/backend-test.junit.xml", htmlRelativePath: "reports/backend-test.html", junitContent, htmlContent });
+            const facts = renderBackendTestFacts({ parsed, cases, pytestExitCode, junitRelativePath: "reports/backend-test.junit.xml", htmlRelativePath: "reports/backend-test.html", junitContent, htmlContent, caseValidationSummary, traceabilitySummary });
             const factsPath = await writeRunReport(meta.runDir, "backend-test-facts.md", facts);
             const sanitizedOutputs = results.map((result) => redactBackendTestOutput(result.stdout));
             outputs.push(...sanitizedOutputs, `html=${htmlPath}`, `facts=${factsPath}`, facts);