@tea-agent/loop-agent 0.16.2 → 0.16.4

package/CHANGELOG.md

@@ -15,6 +15,18 @@
 - Pi SDK 执行长推理或大段结构化输出时不再把高频流式增量事件无界累积到内存；同一响应在多个生命周期事件中重复出现的 Token 用量只统计一次，避免 `Invalid string length` 和成本数据虚高。
 - 后端测试复合执行节点继续保持 clean environment、失败分类和 fail-closed outcome，并为 initial/final Result、repair eligibility、traceability 与 Observe 投影保留结构化运行证据。
 
+## [0.16.4] - 2026-07-19
+
+### 修复
+
+- 后端测试 `backend-test-semantic-final-gate-shell` 改为复合 pipeline `semantic-effective`，不再手写读 contracts 的 inline shell，避免 `--strict-governance` 误判为 fragile verdict gate 并阻断 BE-TEST DAG 校验。
+
+## [0.16.3] - 2026-07-19
+
+### 修复
+
+- 前端实现 DAG 在 review 前新增确定性 `frontend-worktree-diff-shell`，写出 run-owned `diff_patch` 与清单，避免 review 因找不到 actual diff 而误拦截。
+
 ## [0.16.2] - 2026-07-19
 
 ### 修复

package/dist/executors/shell-executor.js

@@ -8,6 +8,7 @@ import { buildRequirementCoverageGateShellCommand, expandShellPreset, buildVerdi
 import { materializeBackendTestAnalysisContract } from "../workflows/dag/backend-test-analysis-contract.js";
 import { materializeFrontendImplementationContract } from "../workflows/dag/frontend-implementation-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";
 import { formatTraceabilityGateStdout, materializeBackendTestCaseManifest, runBackendTestTraceabilityGate, } from "../workflows/dag/backend-test-case-manifest.js";
 import { materializeBackendTestExecutionContract } from "../workflows/dag/backend-test-execution-contract.js";
@@ -333,6 +334,20 @@ async function executeBackendTestPipeline(input, meta) {
                     throw new Error("backend pytest semantic review did not pass");
             }
         }
+        else if (pipeline === "semantic-effective") {
+            // Prefer final review contract when revision ran; otherwise accept initial pass.
+            const finalPath = path.join(meta.runDir, "contracts", "backend-test-semantic-review-final.json");
+            const initialPath = path.join(meta.runDir, "contracts", "backend-test-semantic-review.json");
+            const chosen = existsSync(finalPath) ? finalPath : initialPath;
+            if (!existsSync(chosen)) {
+                throw new Error("missing backend-test semantic review contract for effective gate");
+            }
+            const parsed = JSON.parse(await readFile(chosen, "utf8"));
+            if (parsed.verdict !== "pass") {
+                throw new Error("backend pytest semantic review did not pass");
+            }
+            outputs.push(`semantic=${chosen}`, `verdict=${parsed.verdict}`);
+        }
         else if (pipeline === "execute-parse-initial") {
             const results = await executePipelineCommands(input, meta);
             if (!results.every((result) => result.ok)) {
@@ -606,6 +621,32 @@ export async function executeDagShellNode(input, meta) {
             };
         }
     }
+    if (shell?.commands?.length === 1 &&
+        shell.commands[0] === "frontend-worktree-diff-gate") {
+        const started = Date.now();
+        try {
+            const result = await runFrontendWorktreeDiffGate({
+                runDir: meta.runDir,
+                workspaceRoot: input.cwd,
+            });
+            return {
+                ok: true,
+                stdout: formatFrontendWorktreeDiffStdout(result),
+                stderr: "",
+                failureCategory: "success",
+                durationMs: Date.now() - started,
+            };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                stdout: "",
+                stderr: error instanceof Error ? error.message : String(error),
+                failureCategory: "invalid-output",
+                durationMs: Date.now() - started,
+            };
+        }
+    }
     if (shell?.commands?.length === 1 &&
         shell.commands[0] === "frontend-failure-assess-gate") {
         const started = Date.now();

package/dist/workflows/dag/frontend-worktree-diff.js

@@ -0,0 +1,127 @@
+import { createHash } from "node:crypto";
+import { spawn } from "node:child_process";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { writeDagRunJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
+export const FRONTEND_WORKTREE_DIFF_SCHEMA_ID = "frontend-worktree-diff-v1";
+function runGit(cwd, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn("git", args, {
+            cwd,
+            env: process.env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
+    });
+}
+function splitLines(text) {
+    return text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+/**
+ * Capture the current workspace worktree as a run-owned review artifact.
+ *
+ * Frontend review is contractually required to inspect an "actual diff". The
+ * model cannot invent one, and failure-path `changes.patch` under Task Pool is
+ * not visible while the DAG is still active. This gate freezes a deterministic
+ * patch + inventory under the current run directory before review runs.
+ */
+export async function runFrontendWorktreeDiffGate(input) {
+    const root = path.resolve(input.workspaceRoot);
+    const revParse = await runGit(root, ["rev-parse", "--is-inside-work-tree"]);
+    if (revParse.code !== 0 || revParse.stdout.trim() !== "true") {
+        throw new Error(`frontend worktree diff gate requires a git worktree: ${revParse.stderr.trim() || revParse.stdout.trim() || "not a git repository"}`);
+    }
+    // Match failure capture semantics: binary-capable tracked diff vs HEAD.
+    const diff = await runGit(root, ["diff", "--binary", "HEAD"]);
+    if (diff.code !== 0) {
+        throw new Error(`frontend worktree diff gate git diff failed: ${diff.stderr.trim() || diff.stdout.trim()}`);
+    }
+    const nameOnly = await runGit(root, [
+        "diff",
+        "--name-only",
+        "--diff-filter=ACDMRTUXB",
+        "HEAD",
+    ]);
+    if (nameOnly.code !== 0) {
+        throw new Error(`frontend worktree diff gate git name-only failed: ${nameOnly.stderr.trim() || nameOnly.stdout.trim()}`);
+    }
+    const untracked = await runGit(root, [
+        "ls-files",
+        "--others",
+        "--exclude-standard",
+    ]);
+    if (untracked.code !== 0) {
+        throw new Error(`frontend worktree diff gate ls-files failed: ${untracked.stderr.trim() || untracked.stdout.trim()}`);
+    }
+    const changedFiles = splitLines(nameOnly.stdout).sort();
+    const untrackedFiles = splitLines(untracked.stdout).sort();
+    const patchBody = diff.stdout.endsWith("\n") || diff.stdout.length === 0
+        ? diff.stdout
+        : `${diff.stdout}\n`;
+    const untrackedSection = untrackedFiles.length === 0
+        ? ""
+        : [
+            "",
+            "# Untracked files (inventory only; contents not inlined)",
+            ...untrackedFiles.map((file) => `# untracked: ${file}`),
+            "",
+        ].join("\n");
+    const patchText = `${patchBody}${untrackedSection}`;
+    const patchSha256 = createHash("sha256").update(patchText).digest("hex");
+    const relativePatch = "artifacts/diff_patch.patch";
+    const absolutePatch = path.join(input.runDir, ...relativePatch.split("/"));
+    await mkdir(path.dirname(absolutePatch), { recursive: true });
+    await writeFile(absolutePatch, patchText, "utf8");
+    const payload = {
+        schemaVersion: 1,
+        schemaId: FRONTEND_WORKTREE_DIFF_SCHEMA_ID,
+        patchPath: relativePatch,
+        patchSha256,
+        changedFiles,
+        untrackedFiles,
+        empty: changedFiles.length === 0 && untrackedFiles.length === 0,
+        capturedAt: new Date().toISOString(),
+    };
+    const artifactPath = await writeDagRunJsonArtifact(input.runDir, "contracts/frontend-worktree-diff.json", payload);
+    return {
+        ok: true,
+        schemaId: FRONTEND_WORKTREE_DIFF_SCHEMA_ID,
+        patchPath: relativePatch,
+        patchAbsolutePath: absolutePatch,
+        patchSha256,
+        changedFiles,
+        untrackedFiles,
+        empty: payload.empty,
+        capturedAt: payload.capturedAt,
+        artifactPath,
+    };
+}
+export function formatFrontendWorktreeDiffStdout(result) {
+    return [
+        `schemaId=${result.schemaId}`,
+        `patchPath=${result.patchPath}`,
+        `patchSha256=${result.patchSha256}`,
+        `changedFiles=${result.changedFiles.length}`,
+        `untrackedFiles=${result.untrackedFiles.length}`,
+        `empty=${result.empty ? "true" : "false"}`,
+        result.artifactPath ? `artifactPath=${result.artifactPath}` : "",
+        ...result.changedFiles.map((file) => `changed:${file}`),
+        ...result.untrackedFiles.map((file) => `untracked:${file}`),
+    ]
+        .filter(Boolean)
+        .join("\n");
+}

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

@@ -2328,9 +2328,33 @@ function buildFrontendHybridDagFromTask(sources) {
                     timeoutMs: 120000,
                 },
             },
+            {
+                id: "frontend-worktree-diff-shell",
+                depends_on: [
+                    "frontend-verification-retrace-shell",
+                    "frontend-behavior-reverify-shell",
+                    "frontend-static-reverify-shell",
+                    "frontend-repair-pi",
+                    implementId,
+                ],
+                role: "verifier",
+                executor: "shell",
+                complexity: "LOW",
+                writePolicy: "read-only",
+                allowedPaths: readOnlyPaths,
+                forbiddenPaths,
+                outputContract: "Run-owned actual worktree diff_patch (artifacts/diff_patch.patch) plus contracts/frontend-worktree-diff.json inventory/hash for review. No product worktree writes.",
+                subtask_prompt: "Capture the authoritative actual diff after implement/repair/reverify so frontend-review-pi can audit changed files without relying on failure-path patches or model summaries.",
+                shell: {
+                    commands: ["frontend-worktree-diff-gate"],
+                    cwd: ".",
+                    timeoutMs: 120000,
+                },
+            },
             {
                 id: "frontend-review-pi",
                 depends_on: [
+                    "frontend-worktree-diff-shell",
                     "frontend-verification-retrace-shell",
                     "frontend-static-reverify-shell",
                     "frontend-behavior-reverify-shell",
@@ -2359,7 +2383,7 @@ function buildFrontendHybridDagFromTask(sources) {
                     "Review the frontend implementation and verification evidence.",
                     "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
                     "Any Critical or Important finding must force VERDICT: request-revision.",
-                    "Read the validated frontend-implementation-contract, frontend-verification-trace evidence, static/behavior shell facts, and actual diff. Trace proves command/file/symbol binding only—not semantic correctness.",
+                    "Read the validated frontend-implementation-contract, frontend-verification-trace evidence, static/behavior shell facts, and the run-owned actual diff from frontend-worktree-diff-shell (contracts/frontend-worktree-diff.json + artifacts/diff_patch.patch). Do not claim actual diff is missing when those artifacts exist; do not invent a diff from the implementation summary alone. Trace proves command/file/symbol binding only—not semantic correctness.",
                     "Flag .skip/.only, deleted or weakened tests, unauthorized config changes, Mock-only evidence claimed as real integration, and Browser/visual claims (always not-run in this workflow).",
                     "Use the direct contract, original plan, revision/no-op result, and final design review to reconstruct the approved plan and design verdict; do not infer them from the implementation summary.",
                     "Treat a commented-out real request, default-enabled Mock, production entrypoint importing test mocks, API/fixture contract drift, unauthorized Mock dependency/path, or missing behavior evidence for the selected strategy as at least Important. Mock strategies require Mock-backed evidence. not-needed requires applicable real/no-remote behavior evidence unless auto mode explicitly skipped Mock because no project Mock capability exists; in that case verify that the real request remains the default and the Real Integration Gap is preserved.",
@@ -3104,10 +3128,8 @@ function buildBackendTestSemanticFinalGateNode(sources) {
         outputContract: "Pass-only semantic authorization for traceability and initial pytest.",
         subtask_prompt: "Accept initial pass path or final semantic review pass; fail closed otherwise.",
         shell: {
-            commands: [[
-                    'test -n "${HARNESS_DAG_RUN_DIR:-}" || exit 2',
-                    'node -e \'const fs=require("fs"),path=require("path");const r=process.env.HARNESS_DAG_RUN_DIR;const final=path.join(r,"contracts","backend-test-semantic-review-final.json");const first=path.join(r,"contracts","backend-test-semantic-review.json");const p=fs.existsSync(final)?final:first;const v=JSON.parse(fs.readFileSync(p,"utf8"));if(v.verdict!=="pass")throw new Error("backend pytest semantic review did not pass");console.log("backend pytest semantic gate: pass");\'',
-                ].join("; ")],
+            commands: [],
+            backendTestPipeline: "semantic-effective",
             cwd: ".",
             timeoutMs: 60000,
         },
@@ -3542,9 +3564,26 @@ function buildBackendTestHybridDag(sources) {
     revisePytest.runIf = "$.nodes['validate-semantic-review-and-traceability-shell'].json.verdict == 'request-revision'";
     const finalSemanticReview = buildBackendTestSemanticReviewNode(sources, { id: "review-generated-backend-pytest-final-pi", dependsOn: [revisePytest.id], final: true });
     finalSemanticReview.runIf = revisePytest.runIf;
-    const semanticFinal = { id: "backend-test-semantic-final-gate-shell", depends_on: [semanticInitial.id, finalSemanticReview.id], dependsPolicy: "all-or-condition-skip", role: "verifier", executor: "shell", complexity: "LOW", writePolicy: "read-only", allowedPaths: commonReadOnlyPaths(sources), forbiddenPaths: commonForbiddenPaths(sources), outputContract: "Pass-only effective semantic review gate with final traceability after revision.", subtask_prompt: "Accept initial semantic pass or validate the single final review and traceability.", shell: { commands: [['test -n "${HARNESS_DAG_RUN_DIR:-}" || exit 2', 'node -e \'const fs=require("fs"),path=require("path");const r=process.env.HARNESS_DAG_RUN_DIR;const f=path.join(r,"contracts","backend-test-semantic-review-final.json");const i=path.join(r,"contracts","backend-test-semantic-review.json");const v=JSON.parse(fs.readFileSync(fs.existsSync(f)?f:i,"utf8"));if(v.verdict!=="pass")throw new Error("backend pytest semantic review did not pass");\''].join("; ")], cwd: ".", timeoutMs: 60000 } };
     const finalSemanticMaterialize = { id: "materialize-final-semantic-review-shell", depends_on: [finalSemanticReview.id], role: "verifier", executor: "shell", complexity: "LOW", writePolicy: "read-only", allowedPaths: commonReadOnlyPaths(sources), forbiddenPaths: commonForbiddenPaths(sources), runIf: revisePytest.runIf, outputContract: "Materialize final semantic review and re-check traceability.", subtask_prompt: "Validate final semantic review and traceability.", shell: { commands: [], backendTestPipeline: "semantic-final", cwd: ".", timeoutMs: 60000 } };
-    semanticFinal.depends_on = [semanticInitial.id, finalSemanticMaterialize.id];
+    const semanticFinal = {
+        id: "backend-test-semantic-final-gate-shell",
+        depends_on: [semanticInitial.id, finalSemanticMaterialize.id],
+        dependsPolicy: "all-or-condition-skip",
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Pass-only effective semantic review gate with final traceability after revision.",
+        subtask_prompt: "Accept initial semantic pass or validate the single final review and traceability.",
+        shell: {
+            commands: [],
+            backendTestPipeline: "semantic-effective",
+            cwd: ".",
+            timeoutMs: 60000,
+        },
+    };
     const executeInitial = buildExecuteBackendPytestNode(sources, { id: "execute-and-parse-backend-pytest-initial-shell", dependsOn: [semanticFinal.id, contracts.id], reportStem: "backend-test-initial" });
     executeInitial.shell.backendTestPipeline = "execute-parse-initial";
     const classify = buildClassifyBackendTestResultNode(sources);

package/dist/workflows/dag/types.js

@@ -145,6 +145,7 @@ export const dagBackendTestPipelineSchema = z.enum([
     "contracts",
     "semantic-initial",
     "semantic-final",
+    "semantic-effective",
     "execute-parse-initial",
     "classification-eligibility",
     "repair-safety-traceability",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.16.2",
+  "version": "0.16.4",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",

package/skills/frontend-review/SKILL.md

@@ -12,8 +12,12 @@ references:
 Use for `frontend-review-pi`; read the findings guide first. Required inputs are
 original task/reference material, contract/constraints, Mock assessment, original and
 revised/confirmed plan, final design verdict, implementation summary, actual diff,
-and static/behavior/optional Mock shell evidence. Missing actual diff or required
-evidence forces revision; never infer it from a summary.
+and static/behavior/optional Mock shell evidence. The actual diff is the run-owned
+`frontend-worktree-diff-shell` artifacts: `contracts/frontend-worktree-diff.json` and
+`artifacts/diff_patch.patch` under the current DAG run directory. When those artifacts
+exist, treat them as the authoritative actual diff—do not request revision solely for
+"missing diff". Only force revision for a missing actual diff when both artifacts are
+absent; never invent a diff from an implementation summary alone.
 
 ## Verdict Contract