@tea-agent/loop-agent 0.44.0-next.1 → 0.44.0-next.11

package/dist/workflows/dag/frontend-plan-progress.js

@@ -0,0 +1,92 @@
+import { assemblePlanPatchFromCommittedFacts } from "./frontend-committed-facts.js";
+import { createHash } from "node:crypto";
+const object = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+const identity = (params) => {
+    const p = object(params), entry = object(p.entry ?? p.choice);
+    return String(p.id ?? p.scopeId ?? p.requirementId ?? entry.id ?? entry.name ?? entry.purpose ?? entry.state ?? entry.interaction ?? entry.boundary ?? "singleton");
+};
+/** Counts unresolved diagnostic identities, not tool activity. A changed
+ * rationale/read/heartbeat cannot resolve the same compiler diagnostic. */
+export function createFrontendPlanProgressGuard() {
+    let stop;
+    let terminal = false;
+    let failures = [];
+    const states = [];
+    const warned = new Set();
+    const listeners = new Set();
+    return {
+        readStop: () => stop,
+        acceptTerminal: () => { if (!stop) {
+            terminal = true;
+            failures = [];
+        } },
+        subscribe(listener) { listeners.add(listener); if (stop)
+            listener(); return () => { listeners.delete(listener); }; },
+        observe(tool, params, details, committed, effectiveDigest) {
+            if (stop)
+                return stop;
+            if (terminal)
+                return undefined;
+            const key = `${tool}:${identity(params)}`;
+            if (details?.ok === true) {
+                // Only a successful durable correction of the rejected identity (or
+                // a successful compile) resolves it. Unrelated writes do not reset it.
+                if (tool.startsWith("finalize_") && committed) {
+                    terminal = true;
+                    failures = [];
+                }
+                else if (committed)
+                    failures = failures.filter(f => f.key !== key);
+                return undefined;
+            }
+            const stage = typeof details?.validationStage === "string" ? details.validationStage : undefined;
+            const completed = Array.isArray(details?.completedValidationStages) ? details.completedValidationStages : [];
+            failures = failures.filter(f => !f.stage || !completed.includes(f.stage));
+            const error = String(details?.error ?? details?.code ?? "unknown tool failure").replace(/\s+/g, " ").trim();
+            const fingerprint = createHash("sha256").update(JSON.stringify([key, details?.code ?? null, error])).digest("hex");
+            failures.push({ fingerprint, key, stage });
+            const state = `${stage ?? key}:${fingerprint}:${effectiveDigest ?? "unknown"}`;
+            states.push(state);
+            if (states.length > 8)
+                states.shift();
+            failures = failures.slice(-12);
+            const tail = failures.slice(-6);
+            const repeated = failures.filter(f => f.fingerprint === fingerprint).length;
+            if (repeated >= 6 || (tail.length === 6 && new Set(tail.map(f => f.fingerprint)).size <= 2) || (states.length === 8 && new Set(states).size <= 2)) {
+                stop = { code: "FRONTEND_PLAN_NO_PROGRESS", fingerprint, error: `Unresolved repeated Plan diagnostic: ${error}` };
+                for (const listener of listeners)
+                    listener();
+                return stop;
+            }
+            if (repeated >= 3 && !warned.has(fingerprint)) {
+                warned.add(fingerprint);
+                return { code: "FRONTEND_PLAN_REPAIR_HINT", fingerprint, error: `The same diagnostic remains unresolved. Correct the named fact before repeating this call: ${error}` };
+            }
+            return undefined;
+        },
+    };
+}
+/** Effective facts for the existing node retry ladder. Replacement history and
+ * explanation-only edits must not look like a new implementation decision. */
+export function frontendPlanSemanticDigest(records) {
+    const current = new Map();
+    const strip = (value) => Array.isArray(value) ? value.map(strip) : value && typeof value === "object"
+        ? Object.fromEntries(Object.entries(value).filter(([key]) => !["rationale", "replaces"].includes(key)).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, strip(item)])) : value;
+    const ordinary = records.some(r => ["plan-requirement", "plan-verification-target", "state-registry", "component-choice", "state-flow", "mock-api"].includes(String(object(r.fact).kind)));
+    if (ordinary) {
+        try {
+            const patch = assemblePlanPatchFromCommittedFacts(records.map(r => ({ ...r, fact: { ...object(r.fact), origin: "plan" } })));
+            if (patch)
+                return createHash("sha256").update(JSON.stringify(strip(patch))).digest("hex");
+        }
+        catch { /* An incomplete ledger still needs a stable diagnostic state. */ }
+    }
+    for (const record of records) {
+        if (record.phase !== "committed")
+            continue;
+        const fact = object(record.fact);
+        const key = `${fact.kind}:${identity(fact)}`;
+        current.set(key, strip(fact));
+    }
+    return createHash("sha256").update(JSON.stringify([...current].sort(([a], [b]) => a.localeCompare(b)))).digest("hex");
+}

package/dist/workflows/dag/frontend-recovery-plan.js

@@ -61,11 +61,14 @@ function computeFrontendRecoveryPlanForSource(input) {
     // verification commands / trace. Resetting only verify + its descendants
     // would re-run the same failing checks against the same implementation, so
     // reset from implement: the recovery re-implements and re-verifies.
-    const resetRoot = input.failureSource === "frontend-verify-shell"
-        ? "frontend-implement-pi"
-        : input.failureSource === "frontend-review-pi"
-            ? "frontend-implement-pi"
-            : input.failureSource;
+    const ownerRoots = { contract: "frontend-contract-pi", scout: "frontend-scout-pi", plan: "frontend-plan-pi", implementation: "frontend-implement-pi", "verification-config": "frontend-contract-pi" };
+    if (input.failureOwner && !ownerRoots[input.failureOwner])
+        throw new Error(`FRONTEND_RECOVERY_OWNER_UNSUPPORTED: ${input.failureOwner}; resolve the owning input before retrying`);
+    const resetRoot = input.failureOwner ? ownerRoots[input.failureOwner] :
+        input.failureSource === "frontend-verify-shell" || input.failureSource === "frontend-review-pi" ? "frontend-implement-pi" :
+            input.failureSource === "frontend-design-review-pi" ? "frontend-plan-pi" : input.failureSource;
+    if (!input.spec.tasks.some(task => task.id === resetRoot))
+        throw new Error(`FRONTEND_RECOVERY_PRODUCER_UNAVAILABLE: ${resetRoot}; this topology has no authorized producer, reproject the task contract instead of importing the same candidate`);
     const resetNodeIds = computeResetClosure(input.spec, resetRoot);
     const resetSet = new Set(resetNodeIds);
     const importedNodeIds = input.spec.tasks
@@ -77,6 +80,8 @@ function computeFrontendRecoveryPlanForSource(input) {
         parentRunId: input.parentRunId,
         requestId: input.requestId,
         failureSource: input.failureSource,
+        ...(input.failureOwner ? { failureOwner: input.failureOwner } : {}),
+        resetRootNodeId: resetRoot,
         resetNodeIds,
         importedNodeIds,
     };

package/dist/workflows/dag/frontend-recovery-run.js

@@ -298,6 +298,34 @@ async function casUpdateFrontendRecoveryState(parentRunDir, expectedRevision, de
 }
 async function materializeChildStaging(input) {
     const { cwd, parentRunDir, parentRunId, parentSpec, parentState, recovery, recoveryPlan, requestId, childRunId, stagingDir, createdAt, } = input;
+    // Phase 5: writer transient partial-write recovery resets the writer subtree
+    // (frontend-implement-pi) instead of the candidate producer; everything
+    // upstream is imported as verified parent facts.
+    let plan;
+    if (recoveryPlan) {
+        plan = recoveryPlan;
+    }
+    else if (recovery.failureSource) {
+        plan = computeFrontendRecoveryPlanForSource({
+            spec: parentSpec,
+            parentRunId,
+            requestId,
+            failureSource: recovery.failureSource,
+            failureOwner: recovery.failureOwner,
+        });
+    }
+    else {
+        const admissionRead = await readFrontendWriterAdmissionResult(parentRunDir);
+        if (!admissionRead.ok) {
+            throw new Error(admissionRead.reason);
+        }
+        plan = computeFrontendRecoveryPlan({
+            spec: parentSpec,
+            parentRunId,
+            requestId,
+            result: admissionRead.result,
+        });
+    }
     await prepareRunDir(stagingDir);
     // Design-review rejection must be visible to the reset planner. Recovery
     // children otherwise copy the old spec and only rerun design review, which
@@ -305,6 +333,8 @@ async function materializeChildStaging(input) {
     // findings into the child spec as ordinary rerun feedback.
     let childSpec = parentSpec;
     if (recovery.failureSource === "frontend-plan-pi" ||
+        recovery.failureSource === "frontend-design-review-pi" ||
+        plan.resetRootNodeId === "frontend-contract-pi" ||
         recovery.failureSource === "frontend-review-pi") {
         const designRecovery = parentState.terminalReason === "design-request-changes";
         const reviewRecovery = recovery.failureSource === "frontend-review-pi" ||
@@ -331,12 +361,13 @@ async function materializeChildStaging(input) {
             }
         }
         catch (error) {
-            if (designRecovery || reviewRecovery) {
-                throw new Error(`frontend recovery feedback unavailable: ${error instanceof Error ? error.message : String(error)}`);
-            }
+            throw new Error(`frontend recovery feedback unavailable: ${error instanceof Error ? error.message : String(error)}`);
         }
         if (feedback) {
             childSpec = { ...parentSpec, rerunFeedback: feedback };
+            if (plan.resetRootNodeId === "frontend-contract-pi") {
+                childSpec = { ...childSpec, tasks: childSpec.tasks.map(task => task.id !== plan.resetRootNodeId ? task : { ...task, subtask_prompt: `${task.subtask_prompt}\n\n<contract_recovery_diagnostic>\nParent run: ${parentRunId}\nSource node: ${feedback.sourceNodeId}\nRe-extract only from the unchanged frozen task source. These parent findings are diagnostic hypotheses, not new requirements or authorization. Do not import the parent's Plan as Contract facts. Report unresolved source ambiguity rather than inventing a decision.\n${feedback.feedbackText}\n</contract_recovery_diagnostic>` }) };
+            }
         }
         else if (designRecovery || reviewRecovery) {
             // A design/review rejection cannot be safely retried without its typed
@@ -346,33 +377,6 @@ async function materializeChildStaging(input) {
         }
     }
     await writeJsonVerified(stagingDir, "run.json", childSpec);
-    // Phase 5: writer transient partial-write recovery resets the writer subtree
-    // (frontend-implement-pi) instead of the candidate producer; everything
-    // upstream is imported as verified parent facts.
-    let plan;
-    if (recoveryPlan) {
-        plan = recoveryPlan;
-    }
-    else if (recovery.failureSource) {
-        plan = computeFrontendRecoveryPlanForSource({
-            spec: parentSpec,
-            parentRunId,
-            requestId,
-            failureSource: recovery.failureSource,
-        });
-    }
-    else {
-        const admissionRead = await readFrontendWriterAdmissionResult(parentRunDir);
-        if (!admissionRead.ok) {
-            throw new Error(admissionRead.reason);
-        }
-        plan = computeFrontendRecoveryPlan({
-            spec: parentSpec,
-            parentRunId,
-            requestId,
-            result: admissionRead.result,
-        });
-    }
     const { ranks } = topoSortToRanks(childSpec);
     const resetSet = new Set(plan.resetNodeIds);
     const importedSet = new Set(plan.importedNodeIds);
@@ -408,16 +412,16 @@ async function materializeChildStaging(input) {
     }
     // Canonical contract + writer-admission identity facts are copied alongside
     // the per-node facts so reset nodes can re-read them (AC-4).
-    const canonicalContract = await copyArtifactVerified({
+    const canonicalContract = plan.importedNodeIds.some(id => ["frontend-design-policy-shell", "frontend-contract-import-shell"].includes(id)) ? await copyArtifactVerified({
         parentRunDir,
         newRunDir: stagingDir,
         relativePath: resolveCanonicalContractRelPath(childSpec),
-    });
-    const writerAdmissionResult = await copyArtifactVerified({
+    }) : undefined;
+    const writerAdmissionResult = plan.importedNodeIds.includes("frontend-writer-admission-shell") ? await copyArtifactVerified({
         parentRunDir,
         newRunDir: stagingDir,
         relativePath: FRONTEND_WRITER_ADMISSION_RESULT_ARTIFACT,
-    });
+    }) : undefined;
     // Imported nodes keep their parent FINISHED record, so the run-owned files
     // their bodies wrote outside the node directory travel with them (smoke r31:
     // a review-triggered recovery reached review-context with no worktree
@@ -470,6 +474,7 @@ async function materializeChildStaging(input) {
         }
     }
     const childState = {
+        ...(parentSpec.sourceProviderBudget ? { sourceProviderBudget: structuredClone(parentSpec.sourceProviderBudget) } : {}),
         ...(parentState.budget ? { budget: structuredClone(parentState.budget) } : {}),
         ...(parentState.budgetLedger ? { budgetLedger: structuredClone(parentState.budgetLedger) } : {}),
         version: 1,
@@ -506,6 +511,8 @@ async function materializeChildStaging(input) {
             ...(recovery.failureSource
                 ? { failureSource: recovery.failureSource }
                 : {}),
+            ...(plan.failureOwner ? { failureOwner: plan.failureOwner } : {}),
+            ...(plan.resetRootNodeId ? { resetRootNodeId: plan.resetRootNodeId } : {}),
             revision: 0,
         },
         ...(parentState.evaluation
@@ -518,14 +525,8 @@ async function materializeChildStaging(input) {
         parentRunId,
         requestId,
         createdAt,
-        canonicalContract: {
-            relativePath: canonicalContract.destinationRelativePath,
-            sha256: canonicalContract.sha256,
-        },
-        writerAdmissionResult: {
-            relativePath: writerAdmissionResult.destinationRelativePath,
-            sha256: writerAdmissionResult.sha256,
-        },
+        ...(canonicalContract ? { canonicalContract: { relativePath: canonicalContract.destinationRelativePath, sha256: canonicalContract.sha256 } } : {}),
+        ...(writerAdmissionResult ? { writerAdmissionResult: { relativePath: writerAdmissionResult.destinationRelativePath, sha256: writerAdmissionResult.sha256 } } : {}),
         importedRunArtifacts,
         importedFacts,
     };
@@ -590,7 +591,8 @@ export async function stageRecoveryChild(options) {
                 recovery.recoveryRootRunId !== intent.recoveryRootRunId ||
                 recovery.attemptIndex !== intent.attemptIndex ||
                 recovery.continuationCount !== intent.continuationCount ||
-                recovery.failureSource !== intent.failureSource) {
+                recovery.failureSource !== intent.failureSource ||
+                recovery.failureOwner !== intent.failureOwner || recovery.resetRootNodeId !== intent.resetRootNodeId) {
                 throw new Error("frontend recovery intent replay binding mismatch");
             }
         }
@@ -620,7 +622,8 @@ export async function stageRecoveryChild(options) {
     if (options.recoveryPlan) {
         if (options.recoveryPlan.parentRunId !== parentRunId ||
             options.recoveryPlan.requestId !== requestId ||
-            options.recoveryPlan.failureSource !== recovery.failureSource) {
+            options.recoveryPlan.failureSource !== recovery.failureSource ||
+            options.recoveryPlan.failureOwner !== recovery.failureOwner || options.recoveryPlan.resetRootNodeId !== recovery.resetRootNodeId) {
             throw new Error("frontend recovery plan binding mismatch");
         }
         const expectedPlan = computeFrontendRecoveryPlanForSource({
@@ -628,9 +631,11 @@ export async function stageRecoveryChild(options) {
             parentRunId,
             requestId,
             failureSource: recovery.failureSource,
+            failureOwner: recovery.failureOwner,
         });
-        if (JSON.stringify(expectedPlan.resetNodeIds) !==
-            JSON.stringify(options.recoveryPlan.resetNodeIds) ||
+        if (expectedPlan.resetRootNodeId !== options.recoveryPlan.resetRootNodeId ||
+            JSON.stringify(expectedPlan.resetNodeIds) !==
+                JSON.stringify(options.recoveryPlan.resetNodeIds) ||
             JSON.stringify(expectedPlan.importedNodeIds) !==
                 JSON.stringify(options.recoveryPlan.importedNodeIds)) {
             throw new Error("frontend recovery plan drifted from parent DAG");

package/dist/workflows/dag/frontend-repair-assertions.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+export const repairAssertionSchema = z.discriminatedUnion("check", [
+    z.object({ check: z.literal("file-absent"), token: z.string().min(1).max(512), source: z.string().max(4096) }).strict(),
+    z.object({ check: z.literal("state-present"), token: z.string().min(1).max(512), source: z.string().max(4096) }).strict(),
+    z.object({ check: z.literal("vt-changed"), token: z.string().min(1).max(512), source: z.string().max(4096), expectedRequirementIds: z.array(z.string().min(1)).min(1).max(128) }).strict(),
+]);
+/** Invalid optional assertions never erase a blocking finding or its verdict. */
+export function sanitizeRepairAssertions(value) {
+    if (value === undefined)
+        return { assertions: [], diagnostics: [] };
+    if (!Array.isArray(value))
+        return { assertions: [], diagnostics: ["repairAssertions must be an array; semantic review remains required"] };
+    const assertions = [], diagnostics = [];
+    for (const [index, raw] of value.slice(0, 32).entries()) {
+        const parsed = repairAssertionSchema.safeParse(raw);
+        if (parsed.success)
+            assertions.push(parsed.data);
+        else
+            diagnostics.push(`repairAssertions[${index}] invalid; semantic review remains required`);
+    }
+    if (value.length > 32)
+        diagnostics.push("repairAssertions exceeds 32 items; excess items require semantic review");
+    return { assertions, diagnostics };
+}
+/** Review annotations cannot authorize deletion or invent requirements/states. */
+export function authorizeRepairAssertions(assertions, input) {
+    const files = new Set(input.parent.targets?.files ?? []);
+    const required = new Set([...(input.parent.targets?.requiredDeliverables ?? []), ...(input.requiredDeliverables ?? [])]);
+    const states = new Set(input.stateIds);
+    const targets = new Set(input.parent.verificationTargets?.map(target => String(target.id)) ?? []);
+    return assertions.flatMap(assertion => {
+        const permitted = assertion.check === "file-absent" ? files.has(assertion.token) && !required.has(assertion.token) :
+            assertion.check === "state-present" ? states.has(assertion.token) : targets.has(assertion.token) && assertion.expectedRequirementIds.every(id => input.requirementIds.includes(id));
+        return permitted ? [] : [`${assertion.check}: ${assertion.token} is outside frozen repair authority or contradicts a required delivery`];
+    });
+}

package/dist/workflows/dag/frontend-review-context.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
-import { readFile } from "node:fs/promises";
+import { readFile, lstat } from "node:fs/promises";
+import { readFileBoundarySafe } from "../../shared/path-safety.js";
 import path from "node:path";
 import { writeDagRunJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
 import { formatFrontendWorktreeDiffStdout, runFrontendWorktreeDiffGate, } from "./frontend-worktree-diff.js";
@@ -244,6 +245,31 @@ function assertReviewEvidence(input) {
         throw new FrontendReviewContextFailure("review-context-verification-unbound", "frontend review context verification trace is not bound to a passing contract");
     }
 }
+/** Snapshot only exact behavior-test paths already named by the frozen contract. */
+export async function captureFrontendReviewTestSources(input) {
+    const sources = [];
+    for (const [index, file] of [...new Set(input.files)].entries()) {
+        const targetPath = path.resolve(input.workspaceRoot, file);
+        const exists = await lstat(targetPath).catch((error) => { if (error.code === "ENOENT")
+            return undefined; throw error; });
+        if (!exists) {
+            sources.push({ file, status: "unavailable", scopes: [] });
+            continue;
+        }
+        const bytes = await readFileBoundarySafe({ boundaryRoot: input.workspaceRoot, targetPath, label: "frontend review test source" });
+        const sha256 = createHash("sha256").update(bytes).digest("hex");
+        const text = bytes.toString("utf8");
+        const scopes = [];
+        // Small text slices bound each model input; all slices are retained.
+        for (let offset = 0; offset < Math.max(1, text.length); offset += 2000) {
+            const relative = `contracts/test-source-${index}-${offset / 2000}.json`;
+            await writeDagRunJsonArtifact(input.runDir, relative, { schemaVersion: 1, file, sourceSha256: sha256, offset, totalCharacters: text.length, text: text.slice(offset, offset + 2000) });
+            scopes.push({ path: relative, sha256: createHash("sha256").update(await readFile(path.join(input.runDir, relative))).digest("hex") });
+        }
+        sources.push({ file, status: "captured", sha256, scopes });
+    }
+    return sources;
+}
 export async function runFrontendReviewContextGate(input) {
     const contractRelativePath = "contracts/frontend-implementation-contract.json";
     let contractRaw;
@@ -284,6 +310,7 @@ export async function runFrontendReviewContextGate(input) {
     const verifyFailure = await readOptionalVerifyFailure(input.runDir);
     const lintAssessment = await readOptionalLintAssessment(input.runDir);
     const verificationEvidence = await readVerificationEvidence(input.runDir);
+    const testSources = await captureFrontendReviewTestSources({ ...input, files: parsedContract.data.verificationTargets.filter(target => target.mode === "behavior").map(target => target.file) });
     const cumulativeDiff = await captureCumulativeDiffContext({
         runDir: input.runDir,
         workspaceRoot: input.workspaceRoot,
@@ -320,6 +347,7 @@ export async function runFrontendReviewContextGate(input) {
         },
         verificationTrace,
         verificationEvidence,
+        testSources,
         // Protocol-legal lint vocabulary; `lintConfigured: false` tells the
         // reviewer that this task declares no lint surface at all, so
         // `unavailable` reads as "not applicable", not "missing evidence".

package/dist/workflows/dag/frontend-review-scopes.js

@@ -1,3 +1,5 @@
+import { parseFrontendTestExecutionReport } from "./frontend-test-execution-evidence.js";
+import { readFileBoundarySafe } from "../../shared/path-safety.js";
 import { createHash, randomUUID } from "node:crypto";
 import { readFile, realpath, lstat } from "node:fs/promises";
 import path from "node:path";
@@ -11,9 +13,10 @@ const isArtifactReference = (value) => isRecord(value)
     && typeof value.sha256 === "string" && /^[a-f0-9]{64}$/.test(value.sha256);
 const hash = (text) => createHash("sha256").update(text).digest("hex");
 /** The section index is navigation; reconstruct coverage against the canonical source before using it. */
-export async function loadFrontendReviewScopes(runDir, phase, targetBytes) {
+export async function loadFrontendReviewScopes(runDir, phase, targetBytes, workspaceRoot) {
     const root = await realpath(runDir);
     const files = new Map();
+    const sourceChecks = [];
     async function read(relative, expected) {
         const absolute = path.resolve(root, relative);
         if (!absolute.startsWith(root + path.sep) || (await lstat(absolute)).isSymbolicLink() || !(await realpath(absolute)).startsWith(root + path.sep))
@@ -103,11 +106,88 @@ export async function loadFrontendReviewScopes(runDir, phase, targetBytes) {
         if (diffIndex.patchSha256 !== payload.diff.patchSha256)
             throw Error("FRONTEND_REVIEW_SCOPE_DRIFT: review diff binding");
         scopes.push(context);
+        const reportCoverage = new Map();
+        const reportedTests = [];
+        for (const ref of payload.verificationTrace?.testExecutionEvidence ?? []) {
+            if (!isArtifactReference(ref) || typeof ref.reportPath !== "string" || !/^[a-f0-9]{64}$/.test(ref.reportSha256))
+                throw invalidScope("invalid test execution reference");
+            const excerpt = await read(ref.path, ref.sha256);
+            const data = JSON.parse(excerpt.text);
+            if (data.reportSha256 !== ref.reportSha256)
+                throw invalidScope("test execution report binding mismatch");
+            const coverage = reportCoverage.get(ref.reportPath) ?? { count: 0, total: data.total };
+            if (!Number.isInteger(data.total) || data.total < 1 || data.total !== coverage.total || data.offset !== coverage.count || !Array.isArray(data.tests) || !data.tests.length || data.tests.length > 24)
+                throw invalidScope("test report excerpt coverage invalid");
+            coverage.count += data.tests.length;
+            reportCoverage.set(ref.reportPath, coverage);
+            const report = await read(ref.reportPath, ref.reportSha256);
+            if (workspaceRoot) {
+                if (typeof data.cwd !== "string" || !Number.isInteger(data.offset) || data.offset < 0)
+                    throw invalidScope("invalid test report excerpt coordinates");
+                const rootPath = await realpath(workspaceRoot);
+                const cwdPath = await realpath(path.resolve(workspaceRoot, data.cwd));
+                if (cwdPath !== rootPath && !cwdPath.startsWith(rootPath + path.sep))
+                    throw invalidScope("test report cwd escaped workspace");
+                const actual = parseFrontendTestExecutionReport(JSON.parse(report.text), cwdPath, rootPath);
+                const expected = actual.slice(data.offset, data.offset + 24).map(test => ({ file: test.file, status: test.status, title: test.title.slice(0, 500), ...(test.title.length > 500 ? { titleTruncated: true } : {}) }));
+                if (data.total !== actual.length || !expected.length || sha256OfCanonicalJson(expected) !== sha256OfCanonicalJson(data.tests))
+                    throw invalidScope("test report excerpt differs from actual runner report");
+            }
+            if (data.tests.some((test) => !isRecord(test) || typeof test.file !== "string" || typeof test.status !== "string"))
+                throw invalidScope("invalid test report records");
+            reportedTests.push(...data.tests);
+            scopes.push(excerpt);
+        }
+        if ([...reportCoverage.values()].some(coverage => coverage.count !== coverage.total))
+            throw invalidScope("test report excerpts incomplete");
+        const allowedTests = new Set((canonical.verificationTargets ?? []).filter((target) => target.mode === "behavior").map((target) => target.file));
+        // A trace may claim execution even when its entire report reference list
+        // was omitted. Require the actual, hash-checked reports for every behavior
+        // file before permitting review of the corresponding implementation.
+        for (const file of allowedTests) {
+            const normalized = path.posix.normalize(String(file).replace(/\\/g, "/"));
+            const matching = reportedTests.filter(test => path.posix.normalize(test.file) === normalized);
+            if (!workspaceRoot || !matching.length || matching.some(test => test.status !== "passed"))
+                throw invalidScope(`behavior test report coverage incomplete or not passed: ${String(file)}`);
+        }
+        if (allowedTests.size && (!Array.isArray(payload.testSources) || payload.testSources.length !== allowedTests.size || new Set(payload.testSources.map((source) => source.file)).size !== allowedTests.size))
+            throw invalidScope("contract test source coverage incomplete");
+        for (const source of payload.testSources ?? []) {
+            if (!allowedTests.has(source.file))
+                throw invalidScope("test source is outside frozen contract");
+            if (source.status === "unavailable")
+                continue;
+            if (source.status !== "captured" || !/^[a-f0-9]{64}$/.test(source.sha256) || !Array.isArray(source.scopes) || !source.scopes.length)
+                throw invalidScope("invalid test source reference");
+            let content = "";
+            for (const ref of source.scopes) {
+                if (!isArtifactReference(ref))
+                    throw invalidScope("invalid test source slice");
+                const excerpt = await read(ref.path, ref.sha256);
+                const data = JSON.parse(excerpt.text);
+                if (data.file !== source.file || data.sourceSha256 !== source.sha256 || data.offset !== content.length || typeof data.text !== "string")
+                    throw invalidScope("test source slice binding mismatch");
+                content += data.text;
+                scopes.push(excerpt);
+            }
+            if (hash(content) !== source.sha256)
+                throw invalidScope("test source snapshot incomplete");
+            if (workspaceRoot) {
+                const check = async () => {
+                    const bytes = await readFileBoundarySafe({ boundaryRoot: workspaceRoot, targetPath: path.resolve(workspaceRoot, source.file), label: "frontend review test source" });
+                    if (createHash("sha256").update(bytes).digest("hex") !== source.sha256)
+                        throw Error(`FRONTEND_REVIEW_SCOPE_DRIFT: ${source.file}`);
+                };
+                await check();
+                sourceChecks.push(check);
+            }
+        }
         for (const hunk of diffIndex.hunks)
             scopes.push(await read(hunk.patchPath, hunk.sha256));
     }
     return { scopes, digest: sha256OfCanonicalJson([...files]), validate: async () => { for (const [relative, expected] of files)
-            await read(relative, expected); } };
+            await read(relative, expected); for (const check of sourceChecks)
+            await check(); } };
 }
 /** Checkpoints attest explicit model completion of already supplied, hash-bound scopes. */
 export function createFrontendReviewScopeProtocol(input) {
@@ -118,6 +198,16 @@ export function createFrontendReviewScopeProtocol(input) {
     return {
         setActiveScope(ids) { active = new Set(ids); },
         completedScopeIds,
+        findingScopeIds(previous) {
+            if (!input.inventory)
+                return undefined;
+            const ids = previous ?? [...active];
+            if (!ids.length || ids.some(id => !active.has(id) || !input.inventory.scopes.some(scope => scope.id === id)))
+                throw Object.assign(Error("Findings require their original active review scope"), { code: "FRONTEND_INPUT_SCOPE_VIOLATION" });
+            if (ids.some(id => completedScopeIds().has(id)))
+                throw Object.assign(Error("A completed review scope cannot be changed; restart its owning review"), { code: "FRONTEND_REVIEW_SCOPE_COMPLETED" });
+            return [...ids];
+        },
         committedFacts: () => readCommittedEvents(input.getStore(), input.attemptId),
         assertComplete() { const missing = input.inventory?.scopes.filter(s => !completedScopeIds().has(s.id)) ?? []; if (missing.length)
             throw Object.assign(Error(`FRONTEND_REVIEW_SCOPE_INCOMPLETE: ${missing.map(s => s.id).join(", ")}`), { code: "FRONTEND_REVIEW_SCOPE_INCOMPLETE" }); },

package/dist/workflows/dag/frontend-risk.js

@@ -55,7 +55,12 @@ function isExplicitSharedExclusion(clause, pattern) {
     const prefix = clause.slice(0, match.index).trim();
     const suffix = clause.slice(match.index + match[0].length).trim();
     const actionInSignal = ["new-route", "new-dependency"].includes(pattern.id);
-    if (suffix && !(actionInSignal && /^no$/i.test(prefix) && /^is\s+(?:required|needed)$/i.test(suffix)))
+    // A coordinated toolchain object remains under the same explicit negation.
+    // Match the entire suffix: qualifications ("unless..." / "除非...") and
+    // consequences must still retain the signal.
+    const excludedToolchainObject = pattern.id === "new-dependency" &&
+        /^(?:或|和|及|与)\s*(?:构建|打包)(?:系统|工具|流程)$/.test(suffix);
+    if (suffix && !excludedToolchainObject && !(actionInSignal && /^no$/i.test(prefix) && /^is\s+(?:required|needed)$/i.test(suffix)))
         return false;
     if (/^(?:不涉及|不(?:修改|变更|调整|改变|新增|添加)|无需(?:修改|变更|调整|改变|新增|添加)|no\s+changes?\s+to|(?:do\s+not|don't)\s+(?:change|modify))$/i.test(prefix))
         return true;
@@ -169,13 +174,13 @@ export function classifyFrontendRisk(input) {
         profile.includes("supervised") ||
         /\bsupervised\b/i.test(blob);
     for (const pattern of HIGH_RISK_PATTERNS) {
-        if (pattern.re.test(blob))
+        if (hasAffirmativeSharedSignal(blob, pattern))
             signals.push(pattern.id);
     }
     const paths = input.allowedPaths ?? [];
     const spread = pathSpreadScore(paths);
     if (paths.some((p) => /package\.json|pnpm-lock|yarn\.lock|package-lock/.test(p))) {
-        if (DEPENDENCY_INSTALL_LANGUAGE.test(blob)) {
+        if (hasAffirmativeSharedSignal(blob, { id: "new-dependency", re: DEPENDENCY_INSTALL_LANGUAGE })) {
             signals.push("new-dependency");
         }
         else {