@tea-agent/loop-agent 0.31.0 → 0.32.0

package/AGENTS.md

@@ -38,7 +38,7 @@
 4. 涉及测试纪律/验证声明/调试时继续读：`docs/governance/harness-methodology-*.md`。
 5. 查看最近提交、相关 plan/progress/report；`git status --short --branch`；跑最小基线验证。
 6. 后端/接口/pytest → `taskKind: "backend-test"`（不是 `--profile`）；知识回写 `knowledge-sync`；图谱开荒 `knowledge-graph-bootstrap`。`--profile` 仅 `auto|minimal|standard|reviewed|supervised`。
-7. 看板/observe → `agent-worker console`（默认 repo=当前目录、port=8790；兼容入口 `agent-worker console serve --repo . --port 8790`）（`/inspect/` 只读）；`observe serve` 仅为兼容入口。
+7. 看板/observe → `agent-worker console`（默认 repo=当前目录、port=8790；兼容入口 `agent-worker console serve --repo . --port 8790`）（`/inspect/` 只读）；`observe serve` 已下线（`OBSERVE_SERVE_REMOVED` + exit 2）；`observe snapshot` 仍可用。
 8. 分支合并 → 先读 `docs/operations/branch-merge-guideline.md`。
 
 ## 会话协议

package/CHANGELOG.md

@@ -2,6 +2,66 @@
 
 ## [Unreleased]
 
+## [0.32.0] - 2026-08-09
+
+### 重点更新
+
+- 启动 Agent Worker Production Readiness v1 分阶段落地：Running Attempt 归属不再依赖 terminal ledger；safe `run-error` 可直接 `task retry`，不再要求 emergency `mark-failed`
+- Harness Task 新 identity 改为 lineage/revision digest，同日 retry 不再依赖修改 title
+- 新增 Task-scoped attempt lease、controller protocol compatibility 评估，以及 agent-worker production readiness 操作合同/checklist
+- Attempt 终态释放 lease；写入前评估 controllerProtocol；scaffold 强制 ADR 0007 acceptance_policy；reconcile dry-run inventory 给出唯一恢复命令
+- 硬下线 `agent-worker observe serve`，只读检视统一走 Console `/inspect/`
+
+### 新增
+
+- `WorkerAttemptIdentity` / immutable run-owner store / `beginWorkerAttempt`（含 lease 路径）
+- `WorkerAttemptFailureV2`、`resolveWorkerRecoveryDecision`、Attempt transition reducer
+- Harness Task lineage/revision digests 与 `MaterializeOutcome` 元数据
+- `docs/operations/agent-worker-production-readiness.md` 与 checklist 模板
+- operator capabilities `controllerProtocol` envelope；`buildRuntimeReconcileInventoryDryRun`；command lifecycle official 命令清单
+- Feature scaffold `acceptance_policy` 与 AC `verification.authority` / `required_evidence_kinds`
+
+### 改进
+
+- Feature Review / Observe 对 Running 与 terminal 分层投影，ownership 告警按 `workerRunId` 聚合
+- Task-scoped WorkerEvent 携带 `featureId`
+- `batch run-ready` / `runSingleTaskAttempt` 在 terminal 后 CAS 释放 lease；有 controller identity 时先做 protocol preflight
+- Feature next-action 优先消费 acceptanceGaps.nextCommand
+
+### 修复
+
+- 硬下线 `agent-worker observe serve`：调用后不再监听端口，stderr 输出稳定标记 `OBSERVE_SERVE_REMOVED` 与替代入口，进程以退出码 2 结束
+- 只读检视统一走 `agent-worker console`（默认 `127.0.0.1:8790`）的 `/inspect/`；`observe snapshot` 仍输出 GlobalSnapshot JSON
+- Console doctor / health-match 不再以外部 8787 Observe 进程为健康前提
+
+## [0.31.1] - 2026-08-09
+
+### 重点更新
+
+- 后端测试生成新增确定性冲突预检与执行就绪性校验，在执行前精准拦截潜在错误并安全自动修复局部缺陷
+- 更精细地区分多种写入失败状态（如思考耗尽、部分写入等），避免无效重试并优先恢复可用进度
+- 收紧测试参数校验与结果真实性，准确区分失败与错误，并前置语法门禁防止生成错误代码
+- 优化 16 个节点的执行成本，将多个审查与计划环节改为确定性交接，在保持质量的同时显著降低资源消耗
+
+### 新增
+
+- 为 `dag rerun-task` 新增确定性 generated-output-conflict 预检，执行前扫描并拦截与磁盘已有文件的冲突，提供精确修复建议
+- writer 执行新增 `writer-thinking-exhausted` 终态分类，精准识别模型思考耗尽且无实际写入的情况，避免无限重试
+- 后端 pytest 模块新增 self-contained 静态导入门禁，在收集前拦截对生成共享命名空间的非法导入
+- 新增 `backend-test-execution-readiness-v1` 执行就绪预检，在收集通过后验证传递 fixture/plugin 注册，支持对局部缺陷的安全自动修复
+
+### 改进
+
+- 在已确认存在实质变更且完整性校验通过时，允许确定性推断缺失的实现结果，避免因模型漏报而中断已完成的流程
+- 收紧 scenario-param 结论判定，全量不可判定显示 `UNAVAILABLE`，混合情况显示 `PARTIAL`，并支持精确到具体传输目标的校验与修复
+- 大幅降低 16 节点运行成本：将部分审查与计划环节改为确定性静态交接，统一质量度量并优化模块聚合策略
+- 在修复写入前新增 `ast.parse` 语法门禁并修正尾逗号算法，严格禁止生成 `,,` 等错误语法污染收集流程
+
+### 修复
+
+- 修复 pytest 结果真实性问题：setup/teardown 错误不再被误报为 collection error，准确区分并独立展示 Failed 与 Error
+- 修复结果合同丢失标识的问题，现完整保留原 pytest node ID、Case ID 与 TP ID，并明确记录业务测试体的实际执行数
+
 ## [0.31.0] - 2026-08-08
 
 ### 重点更新

package/README.md

@@ -100,7 +100,7 @@ loop-agent dag report --run-id <run-id>
 | --- | --- | --- |
 | 受治理 CLI | `loop-agent …` / `agent-worker …` | 权威写入与诊断 |
 | Loop Operator Console | `agent-worker console` | Official 本地控制面（默认 repo=当前目录、`127.0.0.1:8790`，含 Operate 与 Inspect） |
-| Observe | `agent-worker observe serve --repo . --port 8787` | 兼容期独立只读入口；不再作为推荐路径 |
+| Inspect（只读） | `agent-worker console` → `/inspect/`；`observe snapshot` | 统一 Console 内只读检视；`observe serve` 已下线（REMOVED / exit 2） |
 
 ```bash
 # 终端 A：Console（任务/运行操作面；canonical mutation 只经 sibling loop-agent）

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

@@ -11,6 +11,55 @@ import { GitStatusUnavailableError, pathsChangedDuringRun, readGitStatusPorcelai
 import { isWriterEmptyDiffRetryCandidate, INCOMPLETE_WRITE_SET_RETRY_CATEGORY, WRITER_EMPTY_DIFF_RETRY_CATEGORY, } from "../workflows/dag/retry-policy.js";
 import { assessBackendTestMdPlanCompleteness, assessBackendTestMdWriterCompleteness, assessBackendTestPytestPlanCompleteness, assessBackendTestPytestWriterCompleteness, assessBackendTestShardChildCompleteness, backendTestWriterProgressRoleForTask, classifyBackendTestWriterCompletenessFailure, isBackendTestCompletenessRetryCandidate, isBackendTestMdPlanTask, isBackendTestPytestPlanTask, isBackendTestShardChildTask, writeBackendTestWriterProgressArtifacts, } from "../workflows/dag/backend-test-writer-completeness.js";
 import { redactSecrets, truncateUtf8Preview } from "../shared/preview.js";
+/**
+ * Writer classification for a length-stopped thinking-only attempt: the model
+ * exhausted its output budget thinking but never issued a write/edit tool call
+ * and produced zero attributed diff. This is a terminal, non-retryable
+ * diagnosis (the same prompt + model will hit the same budget wall); the
+ * recommendation is a model switch plus a fresh run. It must NOT mask a
+ * recoverable partial-write-set (incomplete-write-set) upgrade.
+ */
+export const WRITER_THINKING_EXHAUSTED_CATEGORY = "writer-thinking-exhausted";
+function readWriterThinkingExhaustionEvidence(result) {
+    const wider = result;
+    return {
+        ...(typeof wider.stopReason === "string"
+            ? { stopReason: wider.stopReason }
+            : {}),
+        ...(typeof wider.thinkingObserved === "boolean"
+            ? { thinkingObserved: wider.thinkingObserved }
+            : {}),
+        ...(typeof wider.writeToolCallCount === "number"
+            ? { writeToolCallCount: wider.writeToolCallCount }
+            : {}),
+    };
+}
+/**
+ * Pure classification predicate for writer-thinking-exhausted (AC-002).
+ * Requires ALL of: empty-output base category, stopReason exactly "length",
+ * thinking observed, zero write/edit tool calls, and a confirmed empty
+ * run-attributed diff. Recoverable partial writes stay incomplete-write-set
+ * because the caller only consults this predicate when the completeness gate
+ * did not upgrade the category.
+ */
+export function isWriterThinkingExhausted(result, mapped, changeManifestChangedFiles) {
+    if (mapped.ok)
+        return false;
+    if (mapped.failureCategory !== "empty-output")
+        return false;
+    const evidence = readWriterThinkingExhaustionEvidence(result);
+    if (evidence.stopReason !== "length")
+        return false;
+    if (evidence.thinkingObserved !== true)
+        return false;
+    if ((evidence.writeToolCallCount ?? 0) !== 0)
+        return false;
+    if (changeManifestChangedFiles === undefined)
+        return false;
+    if (changeManifestChangedFiles.length !== 0)
+        return false;
+    return true;
+}
 export const DAG_PI_READONLY_TOOLS = ["read", "grep", "find", "ls"];
 /** Bounded writer tools include bash; edit/write remain policy-wrapped via SDK customTools. */
 export const DAG_PI_WRITE_TOOLS = [
@@ -664,6 +713,7 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
         else {
             const outcomeValidation = validateWriterImplementationOutcome(mapped.assistantText || mapped.stdout, changeManifestChangedFiles, {
                 requireChangedFiles: input.task.writerOutcomePolicy.requireChangedFiles === true,
+                allowMissingChangedOutcomeWhenDiffPresent: isBackendTestCompletenessRetryCandidate(input.task),
             });
             if (!outcomeValidation.ok) {
                 writerOutcomeViolation = outcomeValidation.reason;
@@ -739,9 +789,10 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
             };
         }
     }
-    if (writeGuardOk && !writerOutcomeViolation && !completenessFailure) {
+    if (mapped.ok && writeGuardOk && !writerOutcomeViolation && !completenessFailure) {
         return mapped;
     }
+    const writerThinkingExhausted = isWriterThinkingExhausted(result, mapped, changeManifestChangedFiles);
     const stderrParts = [mapped.stderr];
     if (!writeGuardOk) {
         stderrParts.push(`write guard failed: ${writeGuardViolations.join(", ")}`);
@@ -752,6 +803,9 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
     if (completenessFailure) {
         stderrParts.push(completenessFailure.detail);
     }
+    if (writerThinkingExhausted) {
+        stderrParts.push(`${WRITER_THINKING_EXHAUSTED_CATEGORY}: stopReason=length, thinking observed, 0 write tool calls, 0 attributed diff; recommend a model switch and a new run`);
+    }
     if (meta.writeGuardAttribution === "best-effort") {
         stderrParts.push("write guard note: concurrent rank writers use best-effort per-node attribution; keep same-rank writeSet entries disjoint");
     }
@@ -783,13 +837,26 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
                         mapped.failureCategory === "invalid-output" ||
                         mapped.failureCategory === WRITER_EMPTY_DIFF_RETRY_CATEGORY)
                     ? INCOMPLETE_WRITE_SET_RETRY_CATEGORY
-                    : mapped.failureCategory,
+                    : // writer-thinking-exhausted: a length-stopped thinking-only attempt with
+                        // zero write tool calls and zero attributed diff is terminal and
+                        // non-retryable; recommend a model switch + fresh run. Only applies on
+                        // the empty-output base category so provider/transport failures keep
+                        // their original category, and only when the completeness gate did not
+                        // upgrade to incomplete-write-set above.
+                        writerThinkingExhausted
+                            ? WRITER_THINKING_EXHAUSTED_CATEGORY
+                            : mapped.failureCategory,
         durationMs: mapped.durationMs || Date.now() - started,
     };
 }
 export function validateWriterImplementationOutcome(text, changedFiles, options) {
     const parsed = parseWriterImplementationOutcome(text);
     const diagnostics = writerOutcomeDiagnostics(text, parsed, changedFiles.length);
+    if (parsed.kind === "missing" &&
+        options?.allowMissingChangedOutcomeWhenDiffPresent === true &&
+        changedFiles.length > 0) {
+        return { ok: true, outcome: "changed" };
+    }
     if (parsed.kind !== "valid") {
         return {
             ok: false,

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

@@ -275,6 +275,11 @@ function classifySdkActivityKind(event) {
     }
     return "provider";
 }
+/** Write/edit-style tool names emitted by DAG writer customTools.
+ * Used to attribute write-tool activity for writer-thinking-exhausted diagnosis.
+ * Kept as a module-local constant so tests stay deterministic regardless of the
+ * SDK's tool registration quirks. */
+const SDK_WRITE_TOOL_NAMES = new Set(["edit", "write", "str_replace_editor"]);
 function createSessionEventAppender(filePath, onSessionEvent) {
     let chain = Promise.resolve();
     let dirEnsured = false;
@@ -365,6 +370,25 @@ 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;
@@ -415,6 +439,32 @@ export async function executeSingleSdkAttempt(options) {
     const stdoutPreview = new BoundedTextPreview("stdout");
     const stdoutCollector = createPiJsonlStreamCollector();
     const usageSamples = [];
+    // Writer-thinking-exhausted diagnosis evidence (AC-002). Collected in the
+    // subscribe callback regardless of shouldPersistSessionEvent filtering, so a
+    // length-stopped thinking-only attempt with no persisted write tool calls is
+    // still distinguishable from generic empty output.
+    let stopReason;
+    let thinkingObserved = false;
+    let writeToolCallCount = 0;
+    const observeWriterThinkingExhaustionEvidence = (event) => {
+        const type = typeof event.type === "string" ? event.type : "";
+        if (type === "thinking_delta") {
+            thinkingObserved = true;
+        }
+        if (type === "tool_execution_start" &&
+            typeof event.toolName === "string" &&
+            SDK_WRITE_TOOL_NAMES.has(event.toolName)) {
+            writeToolCallCount += 1;
+        }
+        if (type === "turn_end" ||
+            type === "message_end" ||
+            type === "agent_end" ||
+            type === "agent_settled") {
+            const candidate = readStopReason(event);
+            if (candidate)
+                stopReason = candidate;
+        }
+    };
     let session;
     let unsubscribe;
     let timeoutHandle;
@@ -513,6 +563,11 @@ export async function executeSingleSdkAttempt(options) {
             const usageSample = extractSdkUsageSample(event);
             if (usageSample)
                 usageSamples.push(usageSample);
+            // Capture writer-thinking-exhausted evidence BEFORE the
+            // shouldPersistSessionEvent filter: thinking_delta is intentionally
+            // excluded from persisted JSONL, but must still count toward the
+            // in-memory thinkingObserved/writeToolCallCount/stopReason evidence.
+            observeWriterThinkingExhaustionEvidence(event);
             if (!shouldPersistSessionEvent(event))
                 return;
             const line = serializeSessionEvent(event);
@@ -623,5 +678,11 @@ export async function executeSingleSdkAttempt(options) {
         timedOut,
         tokensUsed,
         subagentStats: collected.subagentStats,
+        // Writer-thinking-exhausted diagnosis evidence (AC-002). Carried through
+        // the object spread in executePiStep so executeDagPiNode can read them
+        // via a widened type without modifying PiStepExecutionResult's shape.
+        stopReason,
+        thinkingObserved,
+        writeToolCallCount,
     };
 }

package/dist/executors/shell-executor.js

@@ -32,7 +32,7 @@ import { analyzeBackendTestCaseCoverage, analyzeBackendTestMarkdownPytestCorresp
 import { materializeBackendTestResultFromPytestHtml, materializeBackendTestResultFromRunDir, parsePytestHtmlReport, } from "../workflows/dag/backend-test-result-contract.js";
 import { collectBackendTestHumanCaseCatalog, collectBackendTestMappedPytestScripts, resolveBackendTestMappedPytestScripts, collectJacocoCoverage, hasBlockingBackendMarkdownSafetyFindings, inspectBackendTestEnvironment, requiredBackendMarkdownCaseAcIds, renderBackendTestFacts, renderBackendTestHtml, renderBackendTestL5Dashboard, redactBackendTestOutput, validateBackendMarkdownCases, validateBackendMarkdownTraceability, writeRunReport, } from "../workflows/dag/backend-test-markdown-workflow.js";
 import { applyDeterministicScenarioParamRepairs, assessBackendScenarioParamConsistency, classifyBackendTestFailureWithScenarioParam, readBackendScenarioParamFacts, renderBackendTestFailureAnalysis, writeBackendScenarioParamArtifacts, writeScenarioParamRepairAudit, } from "../workflows/dag/backend-test-scenario-param.js";
-import { assessBackendPytestCollection, assessMissingBackendPytestScripts, assertBackendPytestCollectionFresh, buildBackendPytestAssetInventory, materializeEffectiveBackendPytestCollection, readBackendPytestCollectionFacts, writeBackendPytestCollectionArtifacts, } from "../workflows/dag/backend-test-pytest-collection.js";
+import { assessBackendPytestCollection, assessMissingBackendPytestScripts, assertBackendTestExecutionReadinessFresh, buildBackendPytestAssetInventory, materializeBackendTestExecutionReadiness, materializeEffectiveBackendPytestCollection, readBackendPytestCollectionFacts, readBackendTestExecutionReadiness, writeBackendPytestCollectionArtifacts, } from "../workflows/dag/backend-test-pytest-collection.js";
 import { computeL5ReportMetrics } from "../workflows/dag/l5-report-metrics.js";
 import { buildBackendTestCanonicalResultFromInitialShellSnippet, materializeBackendTestClassification, } from "../workflows/dag/backend-test-classification-contract.js";
 import { backendTestSemanticReviewSchema, materializeBackendTestSemanticReview, } from "../workflows/dag/backend-test-semantic-review-contract.js";
@@ -43,6 +43,57 @@ import { readRunState } from "../workflows/dag/run-store.js";
 import { resolveDagTaskSourcePath } from "../task/dag-source-paths.js";
 import { readProjectGovernanceContext } from "../workflows/dag/project-governance-context.js";
 import { assertMavenPlanFresh, MavenPlanStaleError, } from "../verification/maven/index.js";
+async function runBackendScenarioParamPreflight(input) {
+    const outputs = [];
+    const initial = await assessBackendScenarioParamConsistency({
+        workspaceRoot: input.workspaceRoot,
+        phase: "initial",
+        repairAttempt: 0,
+        strictScenarioParamGate: input.strictScenarioParamGate,
+    });
+    const initialArtifacts = await writeBackendScenarioParamArtifacts({
+        runDir: input.runDir,
+        facts: initial.facts,
+        markdown: initial.markdown,
+    });
+    outputs.push(`scenarioParamInitial=${initialArtifacts.reportPath}`);
+    let finalFacts;
+    let finalMarkdown;
+    if (initial.facts.repairEligible) {
+        const repair = await applyDeterministicScenarioParamRepairs({
+            workspaceRoot: input.workspaceRoot,
+            facts: initial.facts,
+        });
+        const auditPath = await writeScenarioParamRepairAudit({
+            runDir: input.runDir,
+            audit: repair.audit,
+            changedFiles: repair.changedFiles,
+        });
+        outputs.push(`scenarioParamRepairAudit=${auditPath}`, `scenarioParamRepaired=${repair.repaired.join(",") || "(none)"}`);
+        const reassessed = await assessBackendScenarioParamConsistency({
+            workspaceRoot: input.workspaceRoot,
+            phase: "final",
+            repairAttempt: 1,
+            strictScenarioParamGate: input.strictScenarioParamGate,
+        });
+        finalFacts = reassessed.facts;
+        finalMarkdown = reassessed.markdown;
+    }
+    else {
+        finalFacts = { ...initial.facts, phase: "final", repairAttempt: 0, repairEligible: false };
+        finalMarkdown = initial.markdown.replace("Phase: initial", "Phase: final");
+    }
+    const finalArtifacts = await writeBackendScenarioParamArtifacts({
+        runDir: input.runDir,
+        facts: finalFacts,
+        markdown: finalMarkdown,
+    });
+    outputs.push(`scenarioParamFinal=${finalArtifacts.reportPath}`, `scenarioParamStatus=${finalFacts.overallStatus}`);
+    if (input.strictScenarioParamGate && ["FAIL", "UNAVAILABLE"].includes(finalFacts.overallStatus)) {
+        throw new Error(`backend-test strict scenario-param gate blocked ${finalFacts.overallStatus} before collection`);
+    }
+    return { facts: finalFacts, outputs };
+}
 /** In-memory same-run success cache. Never shared across runIds. */
 const sameRunShellCommandCaches = new Map();
 function shellCommandCacheKey(runId, workspaceFingerprint, contractKey) {
@@ -612,6 +663,12 @@ async function executeBackendTestPipeline(input, meta) {
             }
             else {
                 const mappedScripts = resolution.existingScripts;
+                const scenario = await runBackendScenarioParamPreflight({
+                    workspaceRoot: input.cwd,
+                    runDir: meta.runDir,
+                    strictScenarioParamGate: Boolean((meta.spec.globalConstraints ?? []).some((item) => /strictScenarioParamGate\s*=\s*true/i.test(item))),
+                });
+                outputs.push(...scenario.outputs);
                 const inventory = await buildBackendPytestAssetInventory(input.cwd, mappedScripts);
                 const shellQuote = (value) => `'${value.replaceAll("'", `'"'"'`)}'`;
                 const targets = mappedScripts.map(shellQuote).join(" ");
@@ -628,6 +685,23 @@ async function executeBackendTestPipeline(input, meta) {
                         durationMs: Date.now() - started,
                     };
                 }
+                let fixtureResolution;
+                if ((result.exitCode ?? 2) === 0) {
+                    const fixtureCommand = `PYTHONDONTWRITEBYTECODE=1 python -m pytest --setup-plan -q -p no:cacheprovider ${targets}`;
+                    const [fixtureResult] = await executePipelineCommands(input, meta, [fixtureCommand]);
+                    if (!fixtureResult)
+                        throw new Error("backend pytest fixture-resolution command did not produce a result");
+                    if (["spawn-error", "timeout", "termination-unconfirmed"].includes(fixtureResult.failureCategory ?? "")) {
+                        return {
+                            ok: false,
+                            stdout: fixtureResult.stdout,
+                            stderr: fixtureResult.stderr || "backend pytest fixture resolution could not start",
+                            failureCategory: fixtureResult.failureCategory,
+                            durationMs: Date.now() - started,
+                        };
+                    }
+                    fixtureResolution = { exitCode: fixtureResult.exitCode ?? 2, stdout: fixtureResult.stdout, stderr: fixtureResult.stderr };
+                }
                 facts = assessBackendPytestCollection({
                     phase: "initial",
                     mappedScripts,
@@ -635,6 +709,7 @@ async function executeBackendTestPipeline(input, meta) {
                     exitCode: result.exitCode ?? 2,
                     stdout: result.stdout,
                     stderr: result.stderr,
+                    fixtureResolution,
                 });
             }
             const artifacts = await writeBackendPytestCollectionArtifacts({
@@ -650,8 +725,10 @@ async function executeBackendTestPipeline(input, meta) {
                     repairEligible: facts.repairEligible,
                     collectionAttempted: facts.collectionAttempted,
                     pytestExitCode: facts.pytestExitCode,
+                    fixtureResolutionStatus: facts.fixtureResolutionStatus,
                     collectedItemCount: facts.collectedItemCount,
                     missingMappedScripts: facts.missingMappedScripts,
+                    repairPaths: facts.repairPaths,
                     factsPath: "contracts/backend-test-pytest-collection-initial.json",
                 }),
                 stderr: "",
@@ -669,6 +746,12 @@ async function executeBackendTestPipeline(input, meta) {
             }
             else if (initial.status === "REPAIRABLE") {
                 const mappedScripts = await collectBackendTestMappedPytestScripts(input.cwd);
+                const scenario = await runBackendScenarioParamPreflight({
+                    workspaceRoot: input.cwd,
+                    runDir: meta.runDir,
+                    strictScenarioParamGate: Boolean((meta.spec.globalConstraints ?? []).some((item) => /strictScenarioParamGate\s*=\s*true/i.test(item))),
+                });
+                outputs.push(...scenario.outputs);
                 const inventory = await buildBackendPytestAssetInventory(input.cwd, mappedScripts);
                 const shellQuote = (value) => `'${value.replaceAll("'", `'"'"'`)}'`;
                 const targets = mappedScripts.map(shellQuote).join(" ");
@@ -686,6 +769,23 @@ async function executeBackendTestPipeline(input, meta) {
                         durationMs: Date.now() - started,
                     };
                 }
+                let fixtureResolution;
+                if ((result.exitCode ?? 2) === 0) {
+                    const fixtureCommand = `PYTHONDONTWRITEBYTECODE=1 python -m pytest --setup-plan -q -p no:cacheprovider ${targets}`;
+                    const [fixtureResult] = await executePipelineCommands(input, meta, [fixtureCommand]);
+                    if (!fixtureResult)
+                        throw new Error("backend pytest final fixture-resolution command did not produce a result");
+                    if (["spawn-error", "timeout", "termination-unconfirmed"].includes(fixtureResult.failureCategory ?? "")) {
+                        return {
+                            ok: false,
+                            stdout: fixtureResult.stdout,
+                            stderr: fixtureResult.stderr || "backend pytest final fixture resolution could not start",
+                            failureCategory: fixtureResult.failureCategory,
+                            durationMs: Date.now() - started,
+                        };
+                    }
+                    fixtureResolution = { exitCode: fixtureResult.exitCode ?? 2, stdout: fixtureResult.stdout, stderr: fixtureResult.stderr };
+                }
                 const finalFacts = assessBackendPytestCollection({
                     phase: "final",
                     mappedScripts,
@@ -693,6 +793,7 @@ async function executeBackendTestPipeline(input, meta) {
                     exitCode: result.exitCode ?? 2,
                     stdout: result.stdout,
                     stderr: result.stderr,
+                    fixtureResolution,
                 });
                 effective = await materializeEffectiveBackendPytestCollection({
                     workspaceRoot: input.cwd,
@@ -708,6 +809,14 @@ async function executeBackendTestPipeline(input, meta) {
                 stem: "effective",
                 facts: effective,
             });
+            const scenarioFacts = await readBackendScenarioParamFacts(path.join(meta.runDir, "contracts", "backend-test-scenario-param-consistency-facts.json"));
+            const readiness = await materializeBackendTestExecutionReadiness({
+                runDir: meta.runDir,
+                workspaceRoot: input.cwd,
+                effective,
+                scenarioParamStatus: scenarioFacts.overallStatus,
+                scenarioParamRepairAttempt: scenarioFacts.repairAttempt,
+            });
             return {
                 ok: true,
                 stdout: JSON.stringify({
@@ -715,7 +824,10 @@ async function executeBackendTestPipeline(input, meta) {
                     collectionSource: effective.collectionSource,
                     repairAttempt: effective.repairAttempt,
                     collectedItemCount: effective.collectedItemCount,
+                    fixtureResolutionStatus: effective.fixtureResolutionStatus,
+                    executionReadinessStatus: readiness.status,
                     factsPath: "contracts/backend-test-pytest-collection-effective.json",
+                    readinessPath: "contracts/backend-test-execution-readiness.json",
                     reportPath: artifacts.reportPath,
                 }),
                 stderr: "",
@@ -770,76 +882,18 @@ async function executeBackendTestPipeline(input, meta) {
                     durationMs: Date.now() - started,
                 };
             }
-            // Scenario-param consistency (P1): assess -> deterministic repair <=1 -> reassess final.
+            // Scenario-param assessment and deterministic repair run before collection,
+            // so effective collection/fixture facts bind the final executable assets.
             try {
-                const initialAssessment = await assessBackendScenarioParamConsistency({
-                    workspaceRoot: input.cwd,
-                    phase: "initial",
-                    repairAttempt: 0,
-                    strictScenarioParamGate: Boolean((meta.spec.globalConstraints ?? []).some((item) => /strictScenarioParamGate\s*=\s*true/i.test(item))),
-                });
-                const initialArtifacts = await writeBackendScenarioParamArtifacts({
-                    runDir: meta.runDir,
-                    facts: initialAssessment.facts,
-                    markdown: initialAssessment.markdown,
-                });
-                outputs.push(`scenarioParamInitial=${initialArtifacts.reportPath}`, `scenarioParamInitialFacts=${initialArtifacts.factsPath}`);
-                let finalFacts = initialAssessment.facts;
-                let finalMarkdown = initialAssessment.markdown;
-                if (initialAssessment.facts.repairEligible) {
-                    const repair = await applyDeterministicScenarioParamRepairs({
-                        workspaceRoot: input.cwd,
-                        facts: initialAssessment.facts,
-                    });
-                    const auditPath = await writeScenarioParamRepairAudit({
-                        runDir: meta.runDir,
-                        audit: repair.audit,
-                        changedFiles: repair.changedFiles,
-                    });
-                    outputs.push(`scenarioParamRepairAudit=${auditPath}`, `scenarioParamRepaired=${repair.repaired.join(",") || "(none)"}`);
-                    const reassessment = await assessBackendScenarioParamConsistency({
-                        workspaceRoot: input.cwd,
-                        phase: "final",
-                        repairAttempt: 1,
-                        strictScenarioParamGate: initialAssessment.facts.strictScenarioParamGate,
-                    });
-                    finalFacts = reassessment.facts;
-                    finalMarkdown = reassessment.markdown;
-                }
-                else {
-                    finalFacts = {
-                        ...initialAssessment.facts,
-                        phase: "final",
-                        repairAttempt: 0,
-                        repairEligible: false,
-                    };
-                    finalMarkdown = initialAssessment.markdown.replace("Phase: initial", "Phase: final");
-                }
-                const finalArtifacts = await writeBackendScenarioParamArtifacts({
-                    runDir: meta.runDir,
-                    facts: finalFacts,
-                    markdown: finalMarkdown,
-                });
-                outputs.push(`scenarioParamFinal=${finalArtifacts.reportPath}`, `scenarioParamFinalFacts=${finalArtifacts.factsPath}`, `scenarioParamMismatch=${finalFacts.summary.mismatchCount}`, finalMarkdown);
-                if (finalFacts.strictScenarioParamGate &&
-                    finalFacts.summary.mismatchCount > 0) {
-                    return {
-                        ok: false,
-                        stdout: outputs.join("\n\n"),
-                        stderr: "backend-test strict scenario-param gate blocked residual MISMATCH before execute",
-                        failureCategory: "invalid-output",
-                        durationMs: Date.now() - started,
-                    };
-                }
+                const scenarioFactsPath = path.join(meta.runDir, "contracts", "backend-test-scenario-param-consistency-facts.json");
+                const scenarioReportPath = path.join(meta.runDir, "reports", "backend-test-scenario-param-consistency.md");
+                const scenarioFacts = await readBackendScenarioParamFacts(scenarioFactsPath);
+                const scenarioReport = await readFile(scenarioReportPath, "utf8");
+                outputs.push(`scenarioParamFinal=${scenarioReportPath}`, `scenarioParamFinalFacts=${scenarioFactsPath}`, `scenarioParamStatus=${scenarioFacts.overallStatus}`, scenarioReport);
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
-                const report = "# Backend Test Scenario-Param Consistency\n\n## Status\n\nUNAVAILABLE\n\n## Findings\n\n- Scenario-param analysis crashed: " +
-                    message +
-                    "\n";
-                const reportPath = await writeRunReport(meta.runDir, "backend-test-scenario-param-consistency.md", report);
-                outputs.push(`scenarioParam=${reportPath}`, report);
-                // Advisory by default: do not fail the node on scenario-param infrastructure errors.
+                outputs.push("# Backend Test Scenario-Param Consistency\n\n## Status\n\nUNAVAILABLE\n\n## Findings\n\n- Pre-collection scenario-param evidence missing: " + message + "\n");
             }
         }
         else if (pipeline === "markdown-manifest") {
@@ -866,8 +920,8 @@ async function executeBackendTestPipeline(input, meta) {
             outputs.push(`manifest=${manifestPath}`, `materializationStatus=${manifest.materializationStatus ?? "available"}`, `coverageSummary.explicitAcCount=${summary?.explicitAcCount ?? "unavailable"}`, `coverageSummary.coveredAcCount=${summary?.coveredAcCount ?? "unavailable"}`, `coverageSummary.caseCount=${summary?.caseCount ?? "unavailable"}`, `coverageSummary.generatedCount=${summary?.generatedCount ?? "unavailable"}`, `ruleCoverageSummary.ruleCount=${manifest.ruleCoverageSummary?.ruleCount ?? "unavailable"}`, `correspondenceSummary.exactCorrespondenceCount=${manifest.correspondenceSummary?.exactCorrespondenceCount ?? "unavailable"}`, `correspondenceSummary.primarySymbolCount=${manifest.correspondenceSummary?.primarySymbolCount ?? "unavailable"}`, `correspondenceSummary.testPoints=${manifest.correspondenceSummary?.mappedTestPointCount ?? "unavailable"}/${manifest.correspondenceSummary?.testPointCount ?? "unavailable"}`, `correspondenceSummary.variantTestPointCount=${manifest.correspondenceSummary?.variantTestPointCount ?? "unavailable"}`, `correspondenceSummary.assertionTestPointCount=${manifest.correspondenceSummary?.assertionTestPointCount ?? "unavailable"}`, `correspondenceSummary.crossCuttingTestPointCount=${manifest.correspondenceSummary?.crossCuttingTestPointCount ?? "unavailable"}`, `correspondenceSummary.unclassifiedTestPointCount=${manifest.correspondenceSummary?.unclassifiedTestPointCount ?? "unavailable"}`, `correspondenceSummary.duplicateBindingTestPointCount=${manifest.correspondenceSummary?.duplicateBindingTestPointCount ?? "unavailable"}`);
         }
         else if (pipeline === "markdown-execute-html") {
-            const effectiveCollection = await readBackendPytestCollectionFacts(path.join(meta.runDir, "contracts", "backend-test-pytest-collection-effective.json"));
-            await assertBackendPytestCollectionFresh(input.cwd, effectiveCollection);
+            const executionReadiness = await readBackendTestExecutionReadiness(path.join(meta.runDir, "contracts", "backend-test-execution-readiness.json"));
+            await assertBackendTestExecutionReadinessFresh(input.cwd, executionReadiness);
             const mappedScripts = await collectBackendTestMappedPytestScripts(input.cwd);
             const shellQuote = (value) => `'${value.replaceAll("'", `'"'"'`)}'`;
             const pytestTargets = mappedScripts.map(shellQuote).join(" ");
@@ -1068,8 +1122,7 @@ async function executeBackendTestPipeline(input, meta) {
             const scenarioParamStatusByToken = new Map();
             try {
                 const scenarioFacts = await readBackendScenarioParamFacts(path.join(meta.runDir, "contracts", "backend-test-scenario-param-consistency-facts.json"));
-                scenarioParamFinalStatus =
-                    scenarioFacts.summary.mismatchCount > 0 ? "FAIL" : "PASS";
+                scenarioParamFinalStatus = scenarioFacts.overallStatus;
                 scenarioParamRepairAttempt = scenarioFacts.repairAttempt;
                 for (const entry of scenarioFacts.entries) {
                     scenarioParamStatusByToken.set(entry.caseId, entry.status);
@@ -1085,16 +1138,20 @@ async function executeBackendTestPipeline(input, meta) {
                 htmlReportPath: "reports/backend-test.html",
                 total: parsed.tests,
                 passed: parsed.passed,
-                failed: parsed.failed + parsed.errors,
-                durationLabel: `${parsed.durationMs ?? 0}ms`,
+                failed: parsed.failed,
+                errors: parsed.errors,
+                durationLabel: `${parsed.durationMs ?? failureCases.reduce((sum, item) => sum + (item.durationMs ?? 0), 0)}ms`,
                 environmentSummary: await readFile(path.join(reportsDir, "backend-test-environment.md"), "utf8").catch(() => "unavailable"),
                 scenarioParamFinalStatus,
                 repairAttempt: scenarioParamRepairAttempt,
                 failures: failureCases.map((result) => {
-                    const caseMatch = result.name.match(/\bBE-[A-Z0-9_-]+-\d{2,3}\b/);
-                    const tpMatch = result.name.match(/\bTP-[A-Z0-9-]+\b/);
-                    const caseId = caseMatch?.[0] ?? result.name;
-                    const scenarioParamStatus = (tpMatch && scenarioParamStatusByToken.get(tpMatch[0])) ||
+                    const identityText = `${result.nodeId ?? ""} ${result.name}`;
+                    const caseToken = identityText.match(/BE[-_][A-Z0-9_-]+[-_]\d{2,3}/i)?.[0];
+                    const caseId = caseToken
+                        ? caseToken.replace(/^BE_/i, "BE-").replaceAll("_", "-").toUpperCase()
+                        : result.name;
+                    const tpToken = identityText.match(/TP-[A-Z0-9-]+/i)?.[0]?.toUpperCase();
+                    const scenarioParamStatus = (tpToken && scenarioParamStatusByToken.get(tpToken)) ||
                         scenarioParamStatusByToken.get(caseId);
                     const evidence = [result.message, result.details]
                         .filter(Boolean)
@@ -1102,7 +1159,7 @@ async function executeBackendTestPipeline(input, meta) {
                     const statusMatch = /assert\s+(\d{3})\s*==\s*(\d{3})/i.exec(evidence) ||
                         /expected[^\d]*(\d{3})[\s\S]{0,40}actual[^\d]*(\d{3})/i.exec(evidence);
                     return {
-                        name: result.name,
+                        name: tpToken ?? result.name,
                         caseId,
                         scenario: cases.find((item) => item.id === caseId)?.scenario ??
                             cases.find((item) => item.id === caseId)?.title ??
@@ -1110,7 +1167,7 @@ async function executeBackendTestPipeline(input, meta) {
                         expectedCode: statusMatch?.[2] ?? statusMatch?.[1],
                         actualCode: statusMatch?.[1] ?? statusMatch?.[2],
                         message: result.message || result.status,
-                        scriptPath: result.classname,
+                        scriptPath: result.nodeId ?? result.filePath ?? result.classname,
                         durationLabel: result.durationMs !== undefined
                             ? `${result.durationMs}ms`
                             : undefined,