@tea-agent/loop-agent 0.16.19 → 0.16.20

package/dist/executors/shell-executor.js

@@ -6,6 +6,7 @@ import { writeDagNodeTextArtifact } from "../infrastructure/harness/artifact-sto
 import { truncateOutput } from "../shared/output-truncation.js";
 import { buildRequirementCoverageGateShellCommand, expandShellPreset, buildVerdictGateShellCommand, } from "./shell-presets.js";
 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 { formatFrontendVerificationTraceStdout, runFrontendVerificationTraceGate, } from "../workflows/dag/frontend-verification-trace.js";
@@ -14,8 +15,8 @@ import { formatFrontendFailureAssessStdout, formatFrontendRepairContractStdout,
 import { formatTraceabilityGateStdout, materializeBackendTestCaseManifest, runBackendTestTraceabilityGate, } from "../workflows/dag/backend-test-case-manifest.js";
 import { materializeBackendTestExecutionContract } from "../workflows/dag/backend-test-execution-contract.js";
 import { materializeBackendTestResultFromRunDir } from "../workflows/dag/backend-test-result-contract.js";
-import { buildBackendTestEffectiveResultSelectorShellSnippet, buildBackendTestRepairEligibilityShellSnippet, buildBackendTestRepairSafetyShellSnippet, materializeBackendTestClassification, } from "../workflows/dag/backend-test-repair-contract.js";
-import { materializeBackendTestSemanticReview } from "../workflows/dag/backend-test-semantic-review-contract.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";
 import { buildShellProcessEnv } from "./shell-verification.js";
 const DEFAULT_SHELL_TIMEOUT_MS = 300_000;
@@ -287,10 +288,7 @@ async function executeBackendTestPipeline(input, meta) {
             const wrapperPath = path.join(meta.runDir, "analyze-and-discover-backend-test-pi.json");
             const wrapper = JSON.parse(await readFile(wrapperPath, "utf8"));
             const raw = wrapper.assistantText?.trim() || wrapper.stdout?.trim() || "";
-            const fenced = raw.match(/^```json\s*([\s\S]*?)\s*```$/i);
-            const envelope = JSON.parse(fenced ? fenced[1] : raw);
-            if (!envelope.analysis || !envelope.execution)
-                throw new Error("backend-test contract envelope requires analysis and execution");
+            const envelope = extractBackendTestContractEnvelope(raw);
             await writeFile(path.join(meta.runDir, "backend-test-analysis-envelope.json"), JSON.stringify({ assistantText: JSON.stringify(envelope.analysis) }));
             await writeFile(path.join(meta.runDir, "backend-test-execution-envelope.json"), JSON.stringify({ assistantText: JSON.stringify(envelope.execution) }));
             const analysis = await materializeBackendTestAnalysisContract({
@@ -308,17 +306,84 @@ async function executeBackendTestPipeline(input, meta) {
             });
             outputs.push(`analysis=${analysis.path}`, `execution=${execution.path}`);
         }
-        else if (pipeline === "semantic-initial" || pipeline === "semantic-final") {
-            const fromNodeId = pipeline === "semantic-final"
-                ? "review-generated-backend-pytest-final-pi"
-                : "review-generated-backend-pytest-pi";
-            const artifactName = pipeline === "semantic-final"
-                ? "backend-test-semantic-review-final.json"
-                : "backend-test-semantic-review.json";
+        else if (pipeline === "semantic-initial") {
+            // Same pipeline id for node 09 (materialize+trace) and node 10 (pass-only authorize).
+            // Branch only on task.id so request-revision remains materializable at 09 and fail-closed at 10.
+            if (input.task.id === "backend-test-semantic-gate-shell") {
+                const artifactPath = path.join(meta.runDir, "contracts", "backend-test-semantic-review.json");
+                let raw;
+                try {
+                    raw = await readFile(artifactPath, "utf8");
+                }
+                catch {
+                    return {
+                        ok: false,
+                        stdout: "",
+                        stderr: "backend-test semantic authorize: missing canonical artifact contracts/backend-test-semantic-review.json",
+                        failureCategory: "invalid-output",
+                        durationMs: Date.now() - started,
+                    };
+                }
+                let parsed;
+                try {
+                    parsed = JSON.parse(raw);
+                }
+                catch {
+                    return {
+                        ok: false,
+                        stdout: "",
+                        stderr: "backend-test semantic authorize: malformed canonical artifact contracts/backend-test-semantic-review.json",
+                        failureCategory: "invalid-output",
+                        durationMs: Date.now() - started,
+                    };
+                }
+                if (!parsed ||
+                    typeof parsed !== "object" ||
+                    Array.isArray(parsed) ||
+                    !["verdict", "findings", "summary"].every((key) => Object.prototype.hasOwnProperty.call(parsed, key))) {
+                    return {
+                        ok: false,
+                        stdout: "",
+                        stderr: "backend-test semantic authorize: malformed canonical artifact (missing required canonical fields)",
+                        failureCategory: "invalid-output",
+                        durationMs: Date.now() - started,
+                    };
+                }
+                const validated = backendTestSemanticReviewSchema.safeParse(parsed);
+                if (!validated.success) {
+                    const detail = validated.error.issues
+                        .map((issue) => `${issue.path.join(".") || "artifact"}: ${issue.message}`)
+                        .join("; ");
+                    return {
+                        ok: false,
+                        stdout: "",
+                        stderr: `backend-test semantic authorize: malformed canonical artifact (strict schema validation failed: ${detail})`,
+                        failureCategory: "invalid-output",
+                        durationMs: Date.now() - started,
+                    };
+                }
+                const review = validated.data;
+                if (review.verdict === "pass") {
+                    return {
+                        ok: true,
+                        stdout: JSON.stringify(review),
+                        stderr: "",
+                        failureCategory: "success",
+                        durationMs: Date.now() - started,
+                    };
+                }
+                return {
+                    ok: false,
+                    stdout: JSON.stringify(review),
+                    stderr: "backend-test semantic authorize blocked: verdict=request-revision",
+                    failureCategory: "invalid-output",
+                    durationMs: Date.now() - started,
+                };
+            }
             const review = await materializeBackendTestSemanticReview({
                 runDir: meta.runDir,
-                fromNodeId,
-                artifactName,
+                fromNodeId: "review-generated-backend-pytest-pi",
+                artifactName: "backend-test-semantic-review.json",
                 outputDir: "contracts",
             });
             const trace = await runBackendTestTraceabilityGate({
@@ -327,27 +392,7 @@ async function executeBackendTestPipeline(input, meta) {
             });
             outputs.push(`semantic=${review.path}`, formatTraceabilityGateStdout(trace));
             const parsed = JSON.parse(await readFile(review.path, "utf8"));
-            if (pipeline === "semantic-initial") {
-                return { ok: true, stdout: JSON.stringify(parsed), stderr: "", failureCategory: "success", durationMs: Date.now() - started };
-            }
-            if (pipeline === "semantic-final") {
-                if (parsed.verdict !== "pass")
-                    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}`);
+            return { ok: true, stdout: JSON.stringify(parsed), stderr: "", failureCategory: "success", durationMs: Date.now() - started };
         }
         else if (pipeline === "execute-parse-initial") {
             const results = await executePipelineCommands(input, meta);
@@ -364,43 +409,24 @@ async function executeBackendTestPipeline(input, meta) {
             });
             outputs.push(...results.map((result) => result.stdout), `result=${artifact.path}`);
         }
-        else if (pipeline === "classification-eligibility") {
+        else if (pipeline === "classification-result-context") {
             const classification = await materializeBackendTestClassification({
                 runDir: meta.runDir,
                 fromNodeId: "classify-backend-test-result-pi",
                 artifactName: "backend-test-classification.json",
                 outputDir: "contracts",
             });
-            const results = await executePipelineCommands(input, meta, [buildBackendTestRepairEligibilityShellSnippet()]);
-            if (!results.every((result) => result.ok))
-                throw new Error(results.find((result) => !result.ok)?.stderr || "repair eligibility failed");
-            const eligibility = JSON.parse(await readFile(path.join(meta.runDir, "contracts", "backend-test-repair-eligibility.json"), "utf8"));
-            return { ok: true, stdout: JSON.stringify(eligibility), stderr: "", failureCategory: "success", durationMs: Date.now() - started };
-        }
-        else if (pipeline === "repair-safety-traceability") {
-            const results = await executePipelineCommands(input, meta, [buildBackendTestRepairSafetyShellSnippet()]);
-            if (!results.every((result) => result.ok))
-                throw new Error(results.find((result) => !result.ok)?.stderr || "repair safety failed");
-            const trace = await runBackendTestTraceabilityGate({ runDir: meta.runDir, workspaceRoot: input.cwd });
-            outputs.push(...results.map((result) => result.stdout), formatTraceabilityGateStdout(trace));
-        }
-        else if (pipeline === "finalize-effective-result") {
-            const eligibilityPath = path.join(meta.runDir, "contracts", "backend-test-repair-eligibility.json");
-            const eligibility = existsSync(eligibilityPath)
-                ? JSON.parse(await readFile(eligibilityPath, "utf8"))
-                : { eligible: false };
-            const finalNeeded = eligibility.eligible === true;
-            if (finalNeeded) {
-                const results = await executePipelineCommands(input, meta);
-                if (!results.every((result) => result.ok))
-                    return { ok: false, stdout: results.map((result) => result.stdout).join("\n"), stderr: results.find((result) => !result.ok)?.stderr ?? "final pytest failed", failureCategory: results.find((result) => !result.ok)?.failureCategory ?? "nonzero-exit", durationMs: Date.now() - started };
-                const artifact = await materializeBackendTestResultFromRunDir({ runDir: meta.runDir, fromNodeId: input.task.id, artifactName: "backend-test-result-final.json", outputDir: "contracts", junitRelativePath: "reports/backend-test-final-junit.xml" });
-                outputs.push(...results.map((result) => result.stdout), `final=${artifact.path}`);
-            }
-            const selected = await executePipelineCommands(input, meta, [buildBackendTestEffectiveResultSelectorShellSnippet()]);
+            const selected = await executePipelineCommands(input, meta, [buildBackendTestCanonicalResultFromInitialShellSnippet()]);
             if (!selected.every((result) => result.ok))
-                throw new Error(selected.find((result) => !result.ok)?.stderr || "effective result selection failed");
-            outputs.push(...selected.map((result) => result.stdout));
+                throw new Error(selected.find((result) => !result.ok)?.stderr || "canonical result materialization failed");
+            const contracts = path.join(meta.runDir, "contracts");
+            const context = {
+                schemaVersion: 1,
+                result: JSON.parse(await readFile(path.join(contracts, "backend-test-result.json"), "utf8")),
+                manifest: JSON.parse(await readFile(path.join(contracts, "backend-test-case-manifest.json"), "utf8")),
+                classification: JSON.parse(await readFile(path.join(contracts, "backend-test-classification.json"), "utf8")),
+            };
+            outputs.push(`classification=${classification.path}`, ...selected.map((result) => result.stdout), JSON.stringify(context, null, 2));
         }
         else {
             throw new Error(`unsupported backend-test pipeline: ${pipeline}`);

package/dist/executors/shell-write-guard.js

@@ -48,6 +48,11 @@ export function isEphemeralToolCachePath(filePath) {
     if (normalized === ".ruff_cache" || normalized.startsWith(".ruff_cache/")) {
         return true;
     }
+    // playwright-cli default session dumps (console/page/network) under repo cwd.
+    // Real browser case evidence must still be written under testcase/** explicitly.
+    if (normalized === ".playwright-cli" || normalized.startsWith(".playwright-cli/")) {
+        return true;
+    }
     if (normalized === ".coverage" || normalized.startsWith(".coverage.")) {
         return true;
     }

package/dist/shared/runtime-activity.js

@@ -0,0 +1,6 @@
+export function isInitRuntimeActive(activity) {
+    return (activity.activeDagRunIds.length > 0 ||
+        activity.activeWorkerBatches > 0 ||
+        activity.activeWorkerTasks > 0 ||
+        activity.workerProjectionError !== undefined);
+}

package/dist/worker/observability/read-model.js

@@ -1502,16 +1502,19 @@ async function loadBackendTestProjection(runDir, nodes) {
     else if (eligible)
         repairStatus = "eligible";
     const effectiveSource = final ? "final" : "initial";
+    const legacy = Boolean(eligibility || final || repairNode || safetyNode);
     return {
         ...(initial ? { initial: result(initial) } : {}),
         ...(classification ? { classification: { category: readString(classification, "category"), confidence: readNumber(classification, "confidence") } } : {}),
-        repair: {
-            eligible,
-            reason: eligibility ? readString(eligibility, "reason") : undefined,
-            attempt: final || repairAttempted ? 1 : 0,
-            status: repairStatus,
-        },
-        ...(final ? { final: result(final) } : {}),
+        ...(legacy ? {
+            repair: {
+                eligible,
+                reason: eligibility ? readString(eligibility, "reason") : undefined,
+                attempt: final || repairAttempted ? 1 : 0,
+                status: repairStatus,
+            },
+            ...(final ? { final: result(final) } : {}),
+        } : {}),
         ...(effective ? { effective: { source: effectiveSource, outcome: readString(effective, "outcome") } } : {}),
         ...(manifest && manifest.coverageSummary ? { coverage: manifest.coverageSummary } : {}),
     };

package/dist/worker/observe/static/views/session-timeline.js

@@ -209,7 +209,7 @@ export function sessionEventTimestamp(event) {
 export function formatSessionEventTime(event) {
 	const ts = sessionEventTimestamp(event);
 	if (!ts) return "未记录时间";
-	return formatTs(ts).replace(/\s.*/, "") || formatTs(ts);
+	return formatTs(ts);
 }
 
 export function sessionEventKind(event) {

package/dist/workflows/dag/backend-test-case-manifest.js

@@ -335,7 +335,18 @@ export async function materializeBackendTestCaseManifest(input) {
     if (secrets.length) {
         throw new Error(`invalid-output: ${secrets.join("; ")}`);
     }
-    const result = backendTestCaseManifestSchema.safeParse(parsed);
+    // Model-provided top-level coverageSummary is non-authoritative. Secret scan
+    // above still inspects it; strip before strict schema parse so partial/
+    // custom shapes cannot fail materialization, then always recompute.
+    let candidate = parsed;
+    if (candidate &&
+        typeof candidate === "object" &&
+        !Array.isArray(candidate) &&
+        Object.prototype.hasOwnProperty.call(candidate, "coverageSummary")) {
+        const { coverageSummary: _ignored, ...rest } = candidate;
+        candidate = rest;
+    }
+    const result = backendTestCaseManifestSchema.safeParse(candidate);
     if (!result.success) {
         throw new Error(`invalid-output: ${result.error.issues
             .map((issue) => `${issue.path.join(".")}: ${issue.message}`)
@@ -343,8 +354,7 @@ export async function materializeBackendTestCaseManifest(input) {
     }
     const withSummary = {
         ...result.data,
-        coverageSummary: result.data.coverageSummary ??
-            computeCaseManifestCoverageSummary(result.data),
+        coverageSummary: computeCaseManifestCoverageSummary(result.data),
     };
     assertBackendTestCaseManifestInvariants(withSummary, input.sourceBinding);
     const relativePath = path.posix.join(input.outputDir, input.artifactName);

package/dist/workflows/dag/backend-test-classification-contract.js

@@ -0,0 +1,38 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import { writeDagRunJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
+import { BACKEND_TEST_CLASSIFICATION_CATEGORIES, } from "./backend-test-result-contract.js";
+import { extractUniqueJsonObject } from "./backend-test-contract-envelope.js";
+export const BACKEND_TEST_CLASSIFICATION_SCHEMA_ID = "backend-test-classification-v1";
+export const backendTestClassificationContractSchema = z
+    .object({
+    category: z.enum(BACKEND_TEST_CLASSIFICATION_CATEGORIES),
+    evidence: z.array(z.string().min(1)).min(1),
+    confidence: z.number().min(0).max(1),
+    notes: z.string().min(1),
+})
+    .strict();
+export async function materializeBackendTestClassification(input) {
+    const wrapperPath = path.join(input.runDir, `${input.fromNodeId}.json`);
+    const wrapper = JSON.parse(await readFile(wrapperPath, "utf8"));
+    const raw = wrapper.assistantText?.trim() || wrapper.stdout?.trim() || "";
+    if (!raw)
+        throw new Error("backend-test classification output is empty");
+    const classification = backendTestClassificationContractSchema.parse(extractUniqueJsonObject(raw));
+    const relativePath = path.posix.join(input.outputDir, input.artifactName);
+    const artifactPath = await writeDagRunJsonArtifact(input.runDir, relativePath, classification);
+    const serialized = `${JSON.stringify(classification, null, 2)}\n`;
+    return {
+        path: artifactPath,
+        sha256: createHash("sha256").update(serialized).digest("hex"),
+        schemaId: BACKEND_TEST_CLASSIFICATION_SCHEMA_ID,
+    };
+}
+export function buildBackendTestCanonicalResultFromInitialShellSnippet() {
+    return [
+        'test -n "${HARNESS_DAG_RUN_DIR:-}" || { echo "missing HARNESS_DAG_RUN_DIR for backend-test canonical result" >&2; exit 2; }',
+        `node -e 'const fs=require("fs"),path=require("path"),crypto=require("crypto");const root=process.env.HARNESS_DAG_RUN_DIR;const contracts=path.join(root,"contracts");const source=path.join(contracts,"backend-test-result-initial.json");if(!fs.existsSync(source))throw new Error("missing initial backend-test result");const result=JSON.parse(fs.readFileSync(source,"utf8"));const target=path.join(contracts,"backend-test-result.json");const body=JSON.stringify(result,null,2)+"\\n";fs.writeFileSync(target,body);process.stdout.write(JSON.stringify({canonicalResult:"backend-test-result-initial.json",outcome:result.outcome,sha256:crypto.createHash("sha256").update(body).digest("hex")}));'`,
+    ].join("; ");
+}

package/dist/workflows/dag/backend-test-contract-envelope.js

@@ -0,0 +1,167 @@
+/**
+ * Deterministic, fail-closed unique JSON object extraction for backend-test pipelines.
+ *
+ * Accepts pure JSON object, unique fenced json, prose+unique fence, or prose+unique
+ * bracket-balanced bare object. Contracts envelope adds analysis/execution validation.
+ * Semantic review / classification materializers reuse the same scanner.
+ */
+const JSON_FENCE_RE = /```json\s*\r?\n([\s\S]*?)\r?\n```/gi;
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/**
+ * Collect balanced top-level `{...}` object spans with string/escape awareness.
+ * Does not use greedy regex to guess JSON.
+ */
+export function findBalancedObjectSpans(text) {
+    return scanBalancedObjectSpans(text).spans;
+}
+function scanBalancedObjectSpans(text) {
+    const spans = [];
+    let depth = 0;
+    let start = -1;
+    let inString = false;
+    let escape = false;
+    for (let i = 0; i < text.length; i += 1) {
+        const ch = text[i];
+        if (inString) {
+            if (escape) {
+                escape = false;
+                continue;
+            }
+            if (ch === "\\") {
+                escape = true;
+                continue;
+            }
+            if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            continue;
+        }
+        if (ch === "{") {
+            if (depth === 0)
+                start = i;
+            depth += 1;
+            continue;
+        }
+        if (ch === "}") {
+            if (depth === 0)
+                continue;
+            depth -= 1;
+            if (depth === 0 && start >= 0) {
+                spans.push({ start, end: i + 1 });
+                start = -1;
+            }
+        }
+    }
+    return { spans, unclosedObject: depth !== 0 };
+}
+function collectFencedJsonBlocks(text) {
+    const blocks = [];
+    JSON_FENCE_RE.lastIndex = 0;
+    for (const match of text.matchAll(JSON_FENCE_RE)) {
+        const start = match.index;
+        if (start === undefined)
+            continue;
+        blocks.push({
+            body: match[1] ?? "",
+            start,
+            end: start + match[0].length,
+        });
+    }
+    return blocks;
+}
+function parseObjectJson(candidate, label) {
+    let parsed;
+    try {
+        parsed = JSON.parse(candidate);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`backend-test unique JSON object ${label}: invalid JSON (${detail})`);
+    }
+    if (!isPlainObject(parsed)) {
+        throw new Error(`backend-test unique JSON object ${label}: JSON root must be an object`);
+    }
+    return parsed;
+}
+function countJsonFenceOpenings(text) {
+    return [...text.matchAll(/```json\b/gi)].length;
+}
+function findUniqueJsonObjectText(text) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+        throw new Error("backend-test unique JSON object: empty input; expected one unique JSON object");
+    }
+    // Pure object fast path must run before Markdown recognition so fence-like
+    // tokens inside JSON strings remain ordinary string content.
+    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (isPlainObject(parsed)) {
+                return trimmed;
+            }
+        }
+        catch {
+            // Fall through to fenced / balanced candidate discovery.
+        }
+    }
+    const fenceOpenings = countJsonFenceOpenings(trimmed);
+    const fences = collectFencedJsonBlocks(trimmed);
+    if (fenceOpenings > fences.length) {
+        throw new Error("backend-test unique JSON object: unclosed fenced json block; expected one unique fenced json block");
+    }
+    if (fences.length > 1) {
+        throw new Error(`backend-test unique JSON object: expected exactly one fenced json block, found ${fences.length}`);
+    }
+    if (fences.length === 1) {
+        const fence = fences[0];
+        const outsideScans = [trimmed.slice(0, fence.start), trimmed.slice(fence.end)]
+            .map((fragment) => scanBalancedObjectSpans(fragment));
+        if (outsideScans.some((scan) => scan.unclosedObject)) {
+            throw new Error("backend-test unique JSON object: unclosed JSON object outside fenced json block");
+        }
+        const outsideSpans = outsideScans.flatMap((scan) => scan.spans);
+        if (outsideSpans.length > 0) {
+            throw new Error(`backend-test unique JSON object: expected one unique JSON object, found fenced json plus ${outsideSpans.length} bare object candidate(s)`);
+        }
+        return fence.body;
+    }
+    const scan = scanBalancedObjectSpans(trimmed);
+    if (scan.unclosedObject) {
+        throw new Error("backend-test unique JSON object: unclosed JSON object; expected one unique balanced object");
+    }
+    if (scan.spans.length === 0) {
+        throw new Error("backend-test unique JSON object: no unique JSON object found (no fenced json and no balanced bare object)");
+    }
+    if (scan.spans.length > 1) {
+        throw new Error(`backend-test unique JSON object: expected exactly one top-level JSON object, found ${scan.spans.length}`);
+    }
+    const span = scan.spans[0];
+    return trimmed.slice(span.start, span.end);
+}
+/**
+ * Extract exactly one plain JSON object from model text.
+ * Does not require analysis/execution fields.
+ */
+export function extractUniqueJsonObject(text) {
+    const jsonText = findUniqueJsonObjectText(text);
+    return parseObjectJson(jsonText, "extract");
+}
+/**
+ * Extract the unique backend-test contract envelope `{ analysis, execution }` from model text.
+ */
+export function extractBackendTestContractEnvelope(text) {
+    const envelope = extractUniqueJsonObject(text);
+    if (!envelope.analysis || !envelope.execution) {
+        throw new Error("backend-test contract envelope requires analysis and execution");
+    }
+    return {
+        analysis: envelope.analysis,
+        execution: envelope.execution,
+    };
+}

package/dist/workflows/dag/backend-test-semantic-review-contract.js

@@ -3,6 +3,7 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
 import { writeDagRunJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
+import { extractUniqueJsonObject } from "./backend-test-contract-envelope.js";
 export const BACKEND_TEST_SEMANTIC_REVIEW_SCHEMA_ID = "backend-test-semantic-review-v1";
 export const backendTestSemanticReviewSchema = z.object({
     verdict: z.enum(["pass", "request-revision"]),
@@ -27,8 +28,7 @@ export const backendTestSemanticReviewSchema = z.object({
 export async function materializeBackendTestSemanticReview(input) {
     const wrapper = JSON.parse(await readFile(path.join(input.runDir, `${input.fromNodeId}.json`), "utf8"));
     const raw = wrapper.assistantText?.trim() || wrapper.stdout?.trim() || "";
-    const fenced = raw.match(/^```json\s*([\s\S]*?)\s*```$/i);
-    const parsed = backendTestSemanticReviewSchema.parse(JSON.parse(fenced ? fenced[1] : raw));
+    const parsed = backendTestSemanticReviewSchema.parse(extractUniqueJsonObject(raw));
     const relativePath = path.posix.join(input.outputDir, input.artifactName);
     const artifactPath = await writeDagRunJsonArtifact(input.runDir, relativePath, parsed);
     const normalized = `${JSON.stringify(parsed, null, 2)}\n`;