@tea-agent/loop-agent 0.24.5 → 0.24.7

package/CHANGELOG.md

@@ -2,6 +2,38 @@
 
 ## [Unreleased]
 
+### 新增
+
+- Observe / Inspect 节点检查器在「节点输出」左侧新增「节点输入」页签：只读投影冻结 `run.json` 顶层节点定义（任务正文、依赖、执行器摘要、边界）与可选 assembled prompt 指纹；完整 assembled prompt 与动态展开子节点仍不在本轮范围
+
+### 修复
+
+- 修复前端证据校验在 Windows 下通过长 `node -e` 命令执行时的终端转义崩溃：改为由 runtime 内部直接校验，兼容 CMD、Git Bash、PowerShell 与 Unix shell
+
+## [0.24.7] - 2026-07-29
+
+### 重点更新
+
+- 修复 Feature Verification Bundle 在 Delivery 重验时因绝对路径 artifact、`qa-testcode` 类型与 `run_record` 后写 hash 漂移而失败的问题
+
+### 修复
+
+- Outcome 投影强制写出 repo-relative artifact 路径
+- Delivery `verifyArtifactRefs` 接受位于仓库内的绝对路径（兼容旧 envelope）
+- `verifyBundleTaskSpecBindings` 接受 `qa-testcode`（backend-test）与 `qa-execute`（frontend-test）
+- Bundle 重验仅 rehash typed evidence（backend/frontend-test-result），忽略可能后写的 run_record
+
+## [0.24.6] - 2026-07-29
+
+### 重点更新
+
+- 修复后端测试 Markdown-first 成功路径未投影 `backend-test-result` 的问题，Ready Planner 可再次放行 FE-TEST
+
+### 修复
+
+- Markdown-first `markdown-execute-html` 在解析原生 pytest-html 后立即物化 `contracts/backend-test-result.json`（Result v1），避免 styled HTML 覆盖后丢失 JSON island
+- `node-execution` 对 `markdown-execute-html` 绑定 `structuredArtifact*`，Outcome 适配器可投影 `kind: backend-test-result`
+
 ## [0.24.5] - 2026-07-28
 
 ### 重点更新

package/dist/executors/shell-executor.js

@@ -8,7 +8,7 @@ import { buildRequirementCoverageGateShellCommand, expandShellPreset, buildVerdi
 import { materializeBackendTestAnalysisContract } from "../workflows/dag/backend-test-analysis-contract.js";
 import { extractBackendTestContractEnvelope } from "../workflows/dag/backend-test-contract-envelope.js";
 import { materializeFrontendImplementationContract } from "../workflows/dag/frontend-implementation-contract.js";
-import { materializeFrontendTestResult, } from "../workflows/dag/frontend-test-result-contract.js";
+import { materializeFrontendTestResult, validateFrontendCaseEvidence, } from "../workflows/dag/frontend-test-result-contract.js";
 import { formatFrontendVerificationTraceStdout, runFrontendVerificationTraceGate, } from "../workflows/dag/frontend-verification-trace.js";
 import { formatFrontendWorktreeDiffStdout, runFrontendWorktreeDiffGate, } from "../workflows/dag/frontend-worktree-diff.js";
 import { formatFrontendFailureAssessStdout, formatFrontendRepairContractStdout, runFrontendFailureAssessGate, runFrontendRepairContractGate, } from "../workflows/dag/frontend-repair.js";
@@ -17,7 +17,7 @@ import { formatFrontendReviewContextStdout, runFrontendReviewContextGate, } from
 import { materializeFrontendLintAssessment, materializeFrontendLintBaseline, } from "../workflows/dag/frontend-lint-baseline.js";
 import { formatTraceabilityGateStdout, materializeBackendTestCaseManifest, runBackendTestTraceabilityGate, } from "../workflows/dag/backend-test-case-manifest.js";
 import { materializeBackendTestExecutionContract } from "../workflows/dag/backend-test-execution-contract.js";
-import { materializeBackendTestResultFromRunDir, parsePytestHtmlReport } from "../workflows/dag/backend-test-result-contract.js";
+import { materializeBackendTestResultFromPytestHtml, materializeBackendTestResultFromRunDir, parsePytestHtmlReport } from "../workflows/dag/backend-test-result-contract.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";
@@ -414,6 +414,14 @@ async function executeBackendTestPipeline(input, meta) {
             if (![0, 1].includes(pytestExitCode))
                 throw new Error(`pytest did not complete with a reportable exit code: ${pytestExitCode}`);
             const parsed = parsePytestHtmlReport(pytestHtmlContent);
+            // Bind Result v1 from the native pytest-html report BEFORE overwriting with the
+            // styled renderer (which drops the data-jsonblob island).
+            const resultArtifact = await materializeBackendTestResultFromPytestHtml({
+                runDir: meta.runDir,
+                htmlRelativePath: "reports/backend-test.html",
+                htmlContent: pytestHtmlContent,
+                pytestExitCode,
+            });
             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");
@@ -430,7 +438,7 @@ async function executeBackendTestPipeline(input, meta) {
             const markdownPath = await writeRunReport(meta.runDir, "backend-test.md", facts);
             const factsPath = await writeRunReport(meta.runDir, "backend-test-facts.md", facts);
             const sanitizedOutputs = results.map((result) => redactBackendTestOutput(result.stdout));
-            outputs.push(...sanitizedOutputs, `html=${htmlPath}`, `markdown=${markdownPath}`, `facts=${factsPath}`, facts);
+            outputs.push(...sanitizedOutputs, `html=${htmlPath}`, `markdown=${markdownPath}`, `facts=${factsPath}`, `result=${resultArtifact.path}`, facts);
         }
         else if (pipeline === "contracts") {
             const wrapperPath = path.join(meta.runDir, "analyze-and-discover-backend-test-pi.json");
@@ -889,6 +897,38 @@ async function executeFrontendVerificationBundle(input, meta) {
         };
     }
 }
+async function executeFrontendTestEvidenceValidation(input) {
+    const started = Date.now();
+    try {
+        const result = await validateFrontendCaseEvidence({ workspaceRoot: input.cwd });
+        const output = `frontend case evidence validation cases=${result.cases} findings=${result.issues.length}${result.issues.length ? ` issues=${JSON.stringify(result.issues)}` : ""}`;
+        if (result.hardFail) {
+            return {
+                ok: false,
+                stdout: "",
+                stderr: `frontend-test evidence hard-fail: ${JSON.stringify(result.issues)}`,
+                failureCategory: "nonzero-exit",
+                durationMs: Date.now() - started,
+            };
+        }
+        return {
+            ok: true,
+            stdout: output,
+            stderr: "",
+            failureCategory: "success",
+            durationMs: Date.now() - started,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            stdout: "",
+            stderr: error instanceof Error ? error.message : String(error),
+            failureCategory: "invalid-output",
+            durationMs: Date.now() - started,
+        };
+    }
+}
 async function executeFrontendLintBaseline(input, meta) {
     const started = Date.now();
     const shell = input.task.shell;
@@ -989,6 +1029,9 @@ export async function executeDagShellNode(input, meta) {
             return { ok: false, stdout: "", stderr: error instanceof Error ? error.message : String(error), failureCategory: "invalid-output", durationMs: Date.now() - started };
         }
     }
+    if (shell?.frontendTestEvidenceValidation) {
+        return executeFrontendTestEvidenceValidation(input);
+    }
     if (shell?.backendTestPipeline) {
         return executeBackendTestPipelineWithWriteGuard(input, meta);
     }

package/dist/worker/delivery/verification-bundle.js

@@ -404,7 +404,23 @@ export async function verifyBundleOutcomes(repoRoot, bundle) {
             return false;
         if (JSON.stringify(verified.artifacts) !== JSON.stringify(outcome.artifacts))
             return false;
-        if (!await verifyArtifactRefs(repoRoot, outcome.artifacts))
+        // Rehash only durable typed evidence. run_record/dag_json may be rewritten
+        // after outcome projection (worker-run-record appends report commands).
+        const evidenceArtifacts = outcome.artifacts.filter((artifact) => {
+            const kind = artifact.kind ?? "";
+            if (kind === "run_record" || kind === "dag_json")
+                return false;
+            if (kind === "backend-test-result" ||
+                kind === "frontend-test-result" ||
+                kind.includes("backend-test-result") ||
+                kind.includes("frontend-test-result")) {
+                return true;
+            }
+            // Unknown kinds: still rehash unless clearly infrastructure paths.
+            return (!artifact.path.includes("worker-run-record") &&
+                !artifact.path.includes("-dag.json"));
+        });
+        if (!await verifyArtifactRefs(repoRoot, evidenceArtifacts))
             return false;
     }
     return true;
@@ -417,9 +433,12 @@ export function verifyBundleTaskSpecBindings(bundle, specs) {
             return false;
         taskIds.add(outcome.taskId);
         const spec = specs.get(outcome.taskId);
+        // Typed verification tasks may be qa-execute (frontend-test) or qa-testcode
+        // (backend-test Markdown-first). Delivery binds on feature_id + workflow.
+        const typedVerificationTypes = new Set(["qa-execute", "qa-testcode"]);
         if (!spec ||
             spec.feature_id !== bundle.featureId ||
-            spec.type !== "qa-execute" ||
+            !typedVerificationTypes.has(spec.type) ||
             spec.execution?.workflow !== outcome.workflow)
             return false;
     }
@@ -460,9 +479,11 @@ async function verifyArtifactRefs(repoRoot, artifacts) {
         return false;
     }
     for (const artifact of artifacts) {
-        if (path.isAbsolute(artifact.path))
-            return false;
-        const lexical = path.resolve(canonicalRepoRoot, artifact.path);
+        // Accept absolute paths only when they resolve inside the repo (legacy
+        // envelopes may store abs paths). Prefer relative for new projections.
+        const lexical = path.isAbsolute(artifact.path)
+            ? path.resolve(artifact.path)
+            : path.resolve(canonicalRepoRoot, artifact.path);
         let resolved;
         let content;
         try {

package/dist/worker/observe/dag-run-artifacts.js

@@ -0,0 +1,90 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { isSafeObservabilityIdentifier } from "../observability/event-store.js";
+export const DAG_RUN_LIFECYCLES = ["active", "completed", "paused"];
+function isPathInside(root, target) {
+    const normalizedRoot = root.endsWith(path.sep) ? root : `${root}${path.sep}`;
+    const normalizedTarget = path.normalize(target);
+    return (normalizedTarget === root || normalizedTarget.startsWith(normalizedRoot));
+}
+function normalizeRelativeSegments(relativeSegments) {
+    if (!Array.isArray(relativeSegments) || relativeSegments.length === 0) {
+        return null;
+    }
+    const segments = [];
+    for (const segment of relativeSegments) {
+        if (typeof segment !== "string" || !segment)
+            return null;
+        if (segment === "." || segment === "..")
+            return null;
+        if (segment.includes("/") || segment.includes("\\") || segment.includes("\0")) {
+            return null;
+        }
+        segments.push(segment);
+    }
+    return segments;
+}
+/**
+ * Resolve a path under `.harness/dag-runs/{lifecycle}/{dagRunId}/...`.
+ * Fail closed on invalid ids, path escape, or the same runId appearing in
+ * multiple lifecycle directories.
+ */
+export function resolveDagRunArtifact(repoRoot, dagRunId, relativeSegments) {
+    if (!isSafeObservabilityIdentifier(dagRunId)) {
+        return { ok: false, reason: "invalid-id" };
+    }
+    const segments = normalizeRelativeSegments(relativeSegments);
+    if (!segments) {
+        return { ok: false, reason: "unsafe-path" };
+    }
+    for (const segment of segments) {
+        if (segment !== "run.json" &&
+            segment !== "state.json" &&
+            !isSafeObservabilityIdentifier(segment) &&
+            !/^[a-zA-Z0-9._-]+$/.test(segment)) {
+            // Allow known artifact filenames under a validated node id prefix.
+            if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(segment)) {
+                return { ok: false, reason: "unsafe-path" };
+            }
+        }
+    }
+    const dagRunsRoot = path.resolve(repoRoot, ".harness", "dag-runs");
+    const matches = [];
+    for (const lifecycle of DAG_RUN_LIFECYCLES) {
+        const runDir = path.join(dagRunsRoot, lifecycle, dagRunId);
+        const absolutePath = path.resolve(runDir, ...segments);
+        if (!isPathInside(dagRunsRoot, absolutePath))
+            continue;
+        const relative = path.relative(dagRunsRoot, absolutePath);
+        const parts = relative.split(path.sep).filter(Boolean);
+        if (parts[0] !== lifecycle || parts[1] !== dagRunId)
+            continue;
+        if (!existsSync(absolutePath))
+            continue;
+        matches.push({
+            lifecycle,
+            runDir,
+            absolutePath,
+            relativePath: path.join(lifecycle, dagRunId, ...segments),
+        });
+    }
+    if (matches.length === 0) {
+        return { ok: false, reason: "not-found" };
+    }
+    if (matches.length > 1) {
+        return { ok: false, reason: "ambiguous" };
+    }
+    return { ok: true, result: matches[0] };
+}
+export function resolveDagRunJson(repoRoot, dagRunId) {
+    return resolveDagRunArtifact(repoRoot, dagRunId, ["run.json"]);
+}
+export function resolveDagNodePromptRedacted(repoRoot, dagRunId, nodeId) {
+    if (!isSafeObservabilityIdentifier(nodeId)) {
+        return { ok: false, reason: "invalid-id" };
+    }
+    return resolveDagRunArtifact(repoRoot, dagRunId, [
+        nodeId,
+        "prompt.redacted.md",
+    ]);
+}