@tea-agent/loop-agent 0.44.0-next.8 → 0.44.0-next.9

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 {

package/dist/workflows/dag/frontend-root-observation.js

@@ -0,0 +1,261 @@
+import { sourceBudgetContractIdentity } from "../../application/evaluation/budget.js";
+import { verifyFrozenSourceUsage } from "../../task/source-prepare/source-provider-budget.js";
+import { sha256OfCanonicalJson } from "../../task/contract/hash.js";
+import { locateDagRun, readDagRunSpec, readDagRunState } from "./lifecycle.js";
+import { validateCumulativeBudgetSuccessor } from "./budget-enforcement.js";
+import { readFrontendSessionBudgetReceipts, summarizeFrontendPlanCanary, summarizeFrontendSessions } from "./frontend-session-budget.js";
+/** One explicit recovery chain. Missing links never look like cheaper runs. */
+export async function readFrontendRootObservation(workspaceRoot, runId) {
+    const diagnostics = [];
+    const chain = [];
+    const seen = new Set();
+    let sourceUsage = null;
+    let sourceBudgetHash;
+    const load = async (id) => {
+        if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(id))
+            throw Error("invalid run identity");
+        const found = await locateDagRun(workspaceRoot, id);
+        if (!found)
+            throw Error(`missing recovery run: ${id}`);
+        const state = await readDagRunState(found.runDir);
+        if (state.runId !== id || state.executionMode !== "execute")
+            throw Error(`invalid execution identity: ${id}`);
+        return { runDir: found.runDir, state };
+    };
+    const parentOf = (state) => {
+        const continuation = state.continuation?.parentRunId;
+        const recovery = state.frontendRecoveryState?.parentRunId;
+        if (continuation === state.runId)
+            throw Error("continuation ancestor cycle");
+        const recoveryParent = recovery === state.runId ? undefined : recovery;
+        if (continuation && recoveryParent && continuation !== recoveryParent)
+            throw Error("conflicting recovery parents");
+        return continuation ?? recoveryParent;
+    };
+    try {
+        let current = await load(runId);
+        const ancestorChildren = new Map();
+        // In a root's pending recovery intent parentRunId can refer to itself.
+        while (true) {
+            if (seen.has(current.state.runId))
+                throw Error("recovery ancestor cycle");
+            seen.add(current.state.runId);
+            const parent = parentOf(current.state);
+            if (!parent)
+                break;
+            ancestorChildren.set(parent, current.state.runId);
+            current = await load(parent);
+        }
+        const rootId = current.state.runId;
+        seen.clear();
+        let sourceHash;
+        while (true) {
+            if (seen.has(current.state.runId))
+                throw Error("recovery descendant cycle");
+            seen.add(current.state.runId);
+            chain.push(current);
+            const spec = await readDagRunSpec(current.runDir);
+            if (!spec.sourceBinding)
+                throw Error("missing frozen source binding");
+            const hash = sha256OfCanonicalJson(spec.sourceBinding);
+            if (sourceHash && hash !== sourceHash)
+                throw Error("recovery source binding drift");
+            sourceHash = hash;
+            const boundBudgetHash = sha256OfCanonicalJson(spec.sourceProviderBudget ?? null);
+            if (sourceBudgetHash !== undefined && sourceBudgetHash !== boundBudgetHash)
+                throw Error("recovery source budget evidence drift");
+            sourceBudgetHash = boundBudgetHash;
+            if (spec.sourceProviderBudget) {
+                if (sha256OfCanonicalJson(spec.sourceProviderBudget.contract ?? null) !== sha256OfCanonicalJson(sourceBudgetContractIdentity(spec.taskContractBinding) ?? null) || spec.sourceProviderBudget.sourceBindingSha256 !== hash || sha256OfCanonicalJson(current.state.sourceProviderBudget ?? null) !== boundBudgetHash)
+                    throw Error("source budget state/spec binding mismatch");
+                sourceUsage = await verifyFrozenSourceUsage(workspaceRoot, spec.sourceProviderBudget);
+                diagnostics.push(...sourceUsage.diagnostics);
+                if (sourceUsage.complete && ((current.state.budgetLedger?.consumed.tokens ?? -1) < sourceUsage.totalTokens || (current.state.budgetLedger?.consumed.providerRequests ?? -1) < spec.sourceProviderBudget.ledger.reservedRequests))
+                    throw Error("source cost missing from cumulative budget");
+            }
+            const recovery = current.state.frontendRecoveryState;
+            if (recovery && recovery.recoveryRootRunId !== rootId)
+                throw Error("recovery root identity drift");
+            if (!["finished", "failed", "partial_failed"].includes(current.state.status) || !current.state.finishedAt)
+                throw Error(`incomplete run: ${current.state.runId}`);
+            const declaredChild = recovery?.childRunId === current.state.runId ? undefined : recovery?.childRunId;
+            const selectedChild = ancestorChildren.get(current.state.runId);
+            if (declaredChild && selectedChild && declaredChild !== selectedChild)
+                throw Error("conflicting recovery children");
+            const child = selectedChild ?? declaredChild;
+            if (!child)
+                break;
+            const next = await load(child);
+            if (parentOf(next.state) !== current.state.runId)
+                throw Error("recovery parent/child mismatch");
+            validateCumulativeBudgetSuccessor(current.state, next.state);
+            current = next;
+        }
+        if (!seen.has(runId))
+            throw Error("requested run is outside the root chain");
+    }
+    catch (error) {
+        diagnostics.push(error instanceof Error ? error.message : String(error));
+    }
+    const receipts = [];
+    const identities = new Map();
+    for (const item of chain) {
+        const own = await readFrontendSessionBudgetReceipts(item.runDir);
+        const executedPlan = item.state.nodes?.["frontend-plan-pi"];
+        if (!own.length && executedPlan && executedPlan.origin?.kind !== "imported")
+            diagnostics.push(`missing Plan receipts: ${item.state.runId}`);
+        for (const receipt of own) {
+            if (!chain.some(entry => entry.state.runId === receipt.identity.runId))
+                diagnostics.push("receipt outside recovery lineage");
+            const key = `${receipt.identity.runId}:${receipt.identity.sessionId}`;
+            const digest = sha256OfCanonicalJson(receipt);
+            if (identities.has(key) && identities.get(key) !== digest)
+                diagnostics.push(`conflicting receipt: ${key}`);
+            identities.set(key, digest);
+            receipts.push(receipt);
+        }
+    }
+    if (receipts.some(receipt => receipt.completion !== "complete"))
+        diagnostics.push("incomplete session receipts");
+    let complete = diagnostics.length === 0 && chain.length > 0;
+    const plan = summarizeFrontendPlanCanary(complete ? receipts : []);
+    const first = chain[0]?.state, last = chain.at(-1)?.state;
+    const wall = first && last ? Date.parse(last.finishedAt) - Date.parse(first.startedAt) : NaN;
+    if (complete && (!Number.isFinite(wall) || wall < 0))
+        diagnostics.push("invalid root timing");
+    complete = diagnostics.length === 0 && complete;
+    return { complete, diagnostics, sourceUsage, runIds: chain.map(entry => entry.state.runId), plan,
+        sessions: summarizeFrontendSessions(receipts),
+        recoveryCount: complete ? chain.length - 1 : null,
+        dagWallClockMs: complete && Number.isFinite(wall) && wall >= 0 ? wall : null,
+        // The final ledger already includes inherited consumption. Never sum it.
+        cumulativeBudget: complete ? last?.budgetLedger ?? null : null,
+        outcome: complete ? last?.status ?? null : null };
+}
+/** Explicit identities are required; absent on both sides does not mean equal. */
+export function compareFrontendPairIdentity(before, after) {
+    return ["protocol", "source", "model", "budget", "initialTree", "controller", "promptTools", "acceptance"].flatMap(key => typeof before[key] !== "string" || !before[key]?.trim() || typeof after[key] !== "string" || !after[key]?.trim() ? [`missing-pair-identity:${key}`] : before[key] !== after[key] ? [`pair-identity-mismatch:${key}`] : []);
+}
+export const FRONTEND_PLAN_CANARY_SCENARIOS = [
+    "missing-idle-loading-empty",
+    "loading-not-mounted",
+    "test-layer-does-not-prove-wiring",
+    "mock-claimed-as-real-integration",
+];
+export async function readFrontendCanaryEvidence(input) {
+    const { createHash } = await import("node:crypto");
+    const path = await import("node:path");
+    const { z } = await import("zod");
+    const { readFileBoundarySafe } = await import("../../shared/path-safety.js");
+    const { typedEventRecordSchema } = await import("./frontend-typed-event-store.js");
+    const ref = z.object({ path: z.string().min(1), sha256: z.string().regex(/^[a-f0-9]{64}$/) }).strict();
+    const identitySchema = z.object({ protocol: ref, source: ref, model: ref, budget: ref, initialTree: ref, controller: ref, promptTools: ref, acceptance: ref }).strict();
+    const manifestSchema = z.object({ schemaVersion: z.literal(1), runId: z.string().min(1), run: ref, state: ref, identity: identitySchema, acceptance: ref }).strict();
+    const read = async (value, boundaryRoot = input.manifest.directory) => {
+        const checked = ref.parse({ path: value.path, sha256: value.sha256 });
+        if (path.isAbsolute(checked.path) || checked.path.split(/[\\/]/).includes(".."))
+            throw Error("canary-evidence-path");
+        const bytes = await readFileBoundarySafe({ boundaryRoot, targetPath: path.join(boundaryRoot, checked.path), label: "canary evidence" });
+        if (createHash("sha256").update(bytes).digest("hex") !== checked.sha256)
+            throw Error(`canary-evidence-hash:${checked.path}`);
+        return bytes;
+    };
+    const json = async (value) => JSON.parse((await read(value)).toString("utf8"));
+    const manifest = manifestSchema.parse(await json(input.manifest));
+    const tailId = input.runIds.at(-1);
+    const tail = tailId && await locateDagRun(input.workspaceRoot, tailId);
+    if (!tail || manifest.runId !== tailId || path.resolve(tail.runDir) !== path.resolve(input.runDir))
+        throw Error("canary-evidence-run-mismatch");
+    if (manifest.run.path !== "run.json" || manifest.state.path !== "state.json")
+        throw Error("canary-evidence-run-path");
+    await read(manifest.run, input.runDir);
+    await read(manifest.state, input.runDir);
+    const spec = await readDagRunSpec(input.runDir);
+    const state = await readDagRunState(input.runDir);
+    if (state.runId !== tailId || state.status !== "finished" || !state.finishedAt)
+        throw Error("canary-evidence-run-not-finished");
+    const identity = {};
+    for (const key of Object.keys(manifest.identity)) {
+        await read(manifest.identity[key]);
+        identity[key] = manifest.identity[key].sha256;
+    }
+    if (sha256OfCanonicalJson(await json(manifest.identity.source)) !== sha256OfCanonicalJson(spec.sourceBinding))
+        throw Error("canary-evidence-source-mismatch");
+    if (sha256OfCanonicalJson(await json(manifest.identity.budget)) !== sha256OfCanonicalJson(spec.budget ?? null))
+        throw Error("canary-evidence-budget-mismatch");
+    const modelConfig = z.object({ models: z.array(z.string().min(1)).min(1), parameters: z.record(z.unknown()).optional() }).strict().parse(await json(manifest.identity.model));
+    const outcome = z.enum(["pass", "fail"]);
+    const expected = z.object({ cases: z.array(z.object({ id: z.string().min(1), expected: outcome, scenario: z.enum(FRONTEND_PLAN_CANARY_SCENARIOS).optional() }).strict()).min(1) }).strict().parse(await json(manifest.identity.acceptance));
+    const actual = z.object({ schemaVersion: z.literal(1), runId: z.string(), run: ref, state: ref, results: z.array(z.object({ id: z.string().min(1), actual: outcome, evidence: ref, scenarioResult: z.enum(["blocked", "reported", "not-observed"]).optional() }).strict()).min(1) }).strict().parse(await json(manifest.acceptance));
+    if (actual.runId !== tailId || sha256OfCanonicalJson(actual.run) !== sha256OfCanonicalJson(manifest.run) || sha256OfCanonicalJson(actual.state) !== sha256OfCanonicalJson(manifest.state))
+        throw Error("canary-acceptance-run-mismatch");
+    const expectedIds = new Set(expected.cases.map(row => row.id));
+    const actualIds = new Set(actual.results.map(row => row.id));
+    if (expectedIds.size !== expected.cases.length || actualIds.size !== actual.results.length || expectedIds.size !== actualIds.size || [...actualIds].some(id => !expectedIds.has(id)))
+        throw Error("canary-acceptance-case-mismatch");
+    for (const result of actual.results)
+        await read(result.evidence);
+    const defects = expected.cases.filter(row => actual.results.find(result => result.id === row.id).actual !== row.expected).length;
+    const regressions = {};
+    for (const scenario of FRONTEND_PLAN_CANARY_SCENARIOS) {
+        const cases = expected.cases.filter(row => row.scenario === scenario);
+        const verified = cases.length > 0 && cases.every(row => {
+            const result = actual.results.find(value => value.id === row.id);
+            return result.actual === row.expected && (result.scenarioResult === "blocked" || result.scenarioResult === "reported");
+        });
+        regressions[scenario] = verified ? "reported" : "not-observed";
+    }
+    let reviews = 0, rejects = 0;
+    const actualModels = new Set();
+    for (const id of input.runIds) {
+        const found = await locateDagRun(input.workspaceRoot, id);
+        if (!found)
+            throw Error("canary-design-run-missing");
+        for (const receipt of await readFrontendSessionBudgetReceipts(found.runDir)) {
+            if (receipt.identity.executionKind !== "model")
+                continue;
+            const plannedModel = receipt.planned?.capabilities?.model;
+            const models = [plannedModel, ...receipt.attempts.map(attempt => attempt.model)];
+            if (!receipt.attempts.length || models.some(model => !model || !modelConfig.models.includes(model)))
+                throw Error("canary-evidence-model-mismatch");
+            for (const attempt of receipt.attempts)
+                actualModels.add(attempt.model);
+        }
+        const runState = await readDagRunState(found.runDir);
+        const runSpec = await readDagRunSpec(found.runDir);
+        const node = runState.nodes["frontend-design-review-pi"];
+        if (!node && runSpec.tasks.some(task => task.id === "frontend-design-review-pi"))
+            throw Error("canary-design-node-missing");
+        // Small/micro paths have no independent design review; skipped/imported
+        // nodes contribute no new verdict. Missing facts on executed nodes are errors.
+        if (!node || node.status === "SKIPPED" || node.origin?.kind === "imported")
+            continue;
+        const bytes = await readFileBoundarySafe({ boundaryRoot: found.runDir, targetPath: path.join(found.runDir, "frontend-design-review-pi/design-typed-facts.jsonl"), label: "canary design facts" });
+        const records = bytes.toString("utf8").split("\n").filter(line => line.trim()).map(line => typedEventRecordSchema.parse(JSON.parse(line)));
+        const terminals = records.filter(record => record.phase === "committed" && ["approve_design", "request_design_changes"].includes(String(record.fact.kind)));
+        const attempts = new Set();
+        if (!terminals.length)
+            throw Error("canary-design-terminal-missing");
+        for (const record of terminals) {
+            if (record.payloadSha256 !== sha256OfCanonicalJson(record.fact) || attempts.has(record.attemptId))
+                throw Error("canary-design-terminal-invalid");
+            attempts.add(record.attemptId);
+            reviews++;
+            if (record.fact.kind === "request_design_changes")
+                rejects++;
+        }
+    }
+    if (actualModels.size !== 1)
+        throw Error("canary-evidence-mixed-models");
+    identity.model = sha256OfCanonicalJson({ configurationSha256: identity.model, actualModel: [...actualModels][0] });
+    // Recheck all observed files after collection, including run state/spec.
+    await read(input.manifest);
+    await read(manifest.run, input.runDir);
+    await read(manifest.state, input.runDir);
+    for (const value of Object.values(manifest.identity))
+        await read(value);
+    await read(manifest.acceptance);
+    for (const result of actual.results)
+        await read(result.evidence);
+    return { identity, regressions, designReviewRejectRate: reviews ? rejects / reviews : 0, finalReviewDefectRate: defects / expected.cases.length, acceptancePassed: defects === 0 };
+}

package/dist/workflows/dag/frontend-session-budget.js

@@ -1,3 +1,5 @@
+import { currentSourceExecution } from "../../task/source-prepare/source-execution.js";
+import { withFrontendSessionIdentity } from "./frontend-session-context.js";
 import { createHash, randomUUID } from "node:crypto";
 import { mkdir, readdir, rename, rm, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
@@ -157,13 +159,13 @@ export async function observeFrontendSession(input, execute) {
     const before = safeObservation(() => input.committedCount?.(), undefined);
     const toolsBefore = readFrontendToolProgress(input.customTools);
     const receipt = {
-        schemaVersion: 1, policyVersion: "frontend-session-observation-v1",
-        identity: { sessionId: randomUUID(), phase: input.phase, scopeIds: input.scopeIds ?? [], taskId: input.taskId ?? null, runId: input.runId ?? null, nodeId: input.nodeId ?? null, attempt: input.attempt ?? null, sourceDigest: input.sourceDigest ?? null, contractDigest: input.contractDigest ?? null },
+        schemaVersion: 2, policyVersion: "frontend-session-observation-v2",
+        identity: { ...(currentSourceExecution(input.taskId) ? { sourceExecutionId: currentSourceExecution(input.taskId) } : {}), sessionId: randomUUID(), phase: input.phase, executionKind: input.executionKind ?? "model", dispatchReason: input.dispatchReason ?? "initial", scopeIds: input.scopeIds ?? [], taskId: input.taskId ?? null, runId: input.runId ?? null, nodeId: input.nodeId ?? null, attempt: input.attempt ?? null, sourceDigest: input.sourceDigest ?? null, contractDigest: input.contractDigest ?? null },
         startedAt: new Date().toISOString(), finishedAt: null, completion: "incomplete",
         planned: { prompt: measure(input.prompt), userMessage: measure(input.userMessage ?? ""), toolSchemas: input.customTools ? safeObservation(() => measure(JSON.stringify(input.customTools.map(t => { const tool = record(t); return { name: tool.name, description: tool.description, parameters: tool.parameters }; }))), null) : null,
             estimatorVersion: "utf8-bytes-div3-v1-estimate", capabilities: { ...frontendModelCapabilities(undefined), model: input.model ?? null }, unmeasuredComponents: ["sdk-system-overhead", "built-in-tools", "history", "tool-results", "attachments"] },
         actual: collectFrontendUsage([]), attempts: [],
-        progress: { memoryCommittedDelta: null, durableCommittedDelta: null, failedRecords: null, duplicateRecords: null, durableSubmissions: null, durableReplacements: null, successfulReadBytes: null, duplicateReadBytes: null }, terminal: null,
+        progress: { finalizeRejections: null, memoryCommittedDelta: null, durableCommittedDelta: null, failedRecords: null, duplicateRecords: null, durableSubmissions: null, durableReplacements: null, successfulReadBytes: null, duplicateReadBytes: null }, terminal: null,
     };
     let writes = Promise.resolve();
     let abandoned = false;
@@ -203,14 +205,14 @@ export async function observeFrontendSession(input, execute) {
         }
     };
     await waitForWrite(save());
-    const result = await execute(event => {
+    const result = await withFrontendSessionIdentity({ ...receipt.identity, scopeIds: [...receipt.identity.scopeIds] }, () => execute(event => {
         const index = receipt.attempts.findIndex(a => a.id === event.id);
         if (index < 0)
             receipt.attempts.push(event);
         else
             receipt.attempts[index] = event;
         void save();
-    });
+    }));
     receipt.finishedAt = new Date().toISOString();
     receipt.completion = "complete";
     receipt.actual = receipt.attempts.length ? aggregateAttempts(receipt.attempts) : result.usageObservation ?? collectFrontendUsage([]);
@@ -220,8 +222,10 @@ export async function observeFrontendSession(input, execute) {
     receipt.progress.durableCommittedDelta = durableBefore !== undefined && durableAfter !== undefined ? Math.max(0, durableAfter - durableBefore) : null;
     const toolsAfter = readFrontendToolProgress(input.customTools);
     if (toolsBefore && toolsAfter)
-        for (const key of ["failedRecords", "duplicateRecords", "durableSubmissions", "durableReplacements"])
+        for (const key of ["finalizeRejections", "failedRecords", "duplicateRecords", "durableSubmissions", "durableReplacements"])
             receipt.progress[key] = Math.max(0, toolsAfter[key] - toolsBefore[key]);
+    if (input.executionKind === "runtime")
+        receipt.progress.finalizeRejections = result.ok ? 0 : 1;
     const reads = receipt.attempts.length ? receipt.attempts.map(a => a.reads) : [result.readObservation];
     for (const key of ["successfulReadBytes", "duplicateReadBytes"])
         receipt.progress[key] = sumKnown(reads.map(r => r?.[key] ?? null));
@@ -229,16 +233,30 @@ export async function observeFrontendSession(input, execute) {
     await waitForWrite(save());
     return result;
 }
+/** Observe deterministic compilation without inflating model/session counts. */
+export async function observeFrontendFinalization(input, execute) {
+    let value;
+    await observeFrontendSession({ ...input, executionKind: "runtime", phase: "plan/runtime-finalize", prompt: "" }, async () => {
+        value = await execute();
+        const details = record(record(value).details ?? value);
+        return { ok: details.ok === true, assistantText: "", command: [], durationMs: 0, exitCode: null,
+            failureCategory: details.ok === true ? "success" : "invalid-output", modelDisplay: "runtime", parsedEvents: 0,
+            stderr: details.ok === true ? "" : String(details.error ?? details.code ?? "finalize rejected"), stdout: "", timedOut: false,
+            attemptedModels: [], fallbackUsed: false, tokensUsed: 0 };
+    });
+    return value;
+}
 function uniqueFrontendSessions(receipts) {
     const byId = new Map();
     for (const receipt of receipts) {
-        const previous = byId.get(receipt.identity.sessionId);
+        const key = `${receipt.identity.runId ?? "unknown"}:${receipt.identity.sessionId}`;
+        const previous = byId.get(key);
         const rank = (r) => [r.completion === "complete" ? 1 : 0, Date.parse(r.finishedAt ?? r.startedAt), r.attempts.filter(a => a.completion === "complete").length, r.attempts.length];
         const candidateRank = rank(receipt);
         const previousRank = previous ? rank(previous) : [];
         const difference = candidateRank.map((v, i) => v - (previousRank[i] ?? 0)).find(v => v !== 0) ?? 0;
         if (!previous || difference > 0)
-            byId.set(receipt.identity.sessionId, receipt);
+            byId.set(key, receipt);
     }
     return [...byId.values()];
 }
@@ -288,13 +306,13 @@ export async function readFrontendSessionBudgetReceipts(runDir, nodeId = "fronte
             // Keep a visible incomplete receipt so canary aggregation cannot turn a
             // truncated artifact into an apparent zero-cost improvement.
             receipts.push({
-                schemaVersion: 1,
-                policyVersion: "frontend-session-observation-v1",
-                identity: { sessionId: `invalid:${file}`, phase: "unknown", scopeIds: [], taskId: null, runId: null, nodeId, attempt: null, sourceDigest: null, contractDigest: null },
+                schemaVersion: 2,
+                policyVersion: "frontend-session-observation-v2",
+                identity: { sessionId: `invalid:${file}`, phase: "unknown", executionKind: "model", dispatchReason: "initial", scopeIds: [], taskId: null, runId: null, nodeId, attempt: null, sourceDigest: null, contractDigest: null },
                 startedAt: new Date(0).toISOString(), finishedAt: null, completion: "incomplete",
                 planned: { prompt: { sha256: "", chars: 0, bytes: 0, estimatedTokens: 0 }, userMessage: { sha256: "", chars: 0, bytes: 0, estimatedTokens: 0 }, toolSchemas: null, estimatorVersion: "unknown", capabilities: { ...frontendModelCapabilities(undefined), model: null }, unmeasuredComponents: [] },
                 actual: { ...collectFrontendUsage([]) }, attempts: [],
-                progress: { memoryCommittedDelta: null, durableCommittedDelta: null, failedRecords: null, duplicateRecords: null, durableSubmissions: null, durableReplacements: null, successfulReadBytes: null, duplicateReadBytes: null }, terminal: null,
+                progress: { finalizeRejections: null, memoryCommittedDelta: null, durableCommittedDelta: null, failedRecords: null, duplicateRecords: null, durableSubmissions: null, durableReplacements: null, successfulReadBytes: null, duplicateReadBytes: null }, terminal: null,
             });
         }
     }
@@ -302,7 +320,8 @@ export async function readFrontendSessionBudgetReceipts(runDir, nodeId = "fronte
 }
 export function summarizeFrontendPlanCanary(receipts) {
     const unique = uniqueFrontendSessions(receipts);
-    const complete = unique.length > 0 && unique.every(receipt => isCanaryReceipt(receipt) && receipt.completion === "complete");
+    const model = unique.filter(r => r.identity.executionKind === "model");
+    const complete = model.length > 0 && unique.every(receipt => isCanaryReceipt(receipt) && receipt.completion === "complete");
     const known = (values, sum) => {
         if (!complete || values.length === 0)
             return null;
@@ -310,14 +329,17 @@ export function summarizeFrontendPlanCanary(receipts) {
         return present.length === values.length ? sum(present) : null;
     };
     return {
-        planModelRequests: known(unique.map((receipt) => receipt.actual.requestCount), (items) => items.reduce((total, value) => total + value, 0)),
-        planSessions: complete ? unique.length : null,
+        planModelRequests: known(model.map((receipt) => receipt.actual.requestCount), (items) => items.reduce((total, value) => total + value, 0)),
+        planSessions: complete ? model.length : null,
         // Receipt envelope includes gaps and overlapping sessions only once. The
         // run reader below replaces this with the authoritative node interval.
         planWallClockMs: complete ? Math.max(...unique.map(r => Date.parse(r.finishedAt))) - Math.min(...unique.map(r => Date.parse(r.startedAt))) : null,
-        planTokens: known(unique.map((receipt) => receipt.actual.totalTokens), (items) => items.reduce((total, value) => total + value, 0)),
-        toolRejections: known(unique.map((receipt) => receipt.progress.failedRecords), (items) => items.reduce((total, value) => total + value, 0)),
-        retries: complete ? unique.reduce((total, receipt) => total + Math.max(0, receipt.attempts.length - 1), 0) : null,
+        planTokens: known(model.map((receipt) => receipt.actual.totalTokens), (items) => items.reduce((total, value) => total + value, 0)),
+        toolRejections: known(model.map((receipt) => receipt.progress.failedRecords), (items) => items.reduce((total, value) => total + value, 0)),
+        factReplacements: known(model.map(r => r.progress.durableReplacements), items => items.reduce((a, b) => a + b, 0)),
+        finalizeRejections: known(unique.map(r => r.progress.finalizeRejections), items => items.reduce((a, b) => a + b, 0)),
+        correctionSessions: complete ? model.filter(r => r.identity.dispatchReason === "correction").length : null,
+        transportRetries: complete ? model.reduce((total, receipt) => total + Math.max(0, receipt.attempts.length - 1), 0) : null,
     };
 }
 /** Validate the fields consumed by aggregation before accessing nested values.
@@ -325,11 +347,15 @@ export function summarizeFrontendPlanCanary(receipts) {
 function isCanaryReceipt(value) {
     const r = record(value), identity = record(r.identity), actual = record(r.actual), progress = record(r.progress);
     const nullableCount = (v) => v === null || (typeof v === "number" && Number.isFinite(v) && Number.isInteger(v) && v >= 0);
-    return r.schemaVersion === 1 && r.policyVersion === "frontend-session-observation-v1"
+    return r.schemaVersion === 2 && r.policyVersion === "frontend-session-observation-v2"
+        && ["model", "runtime"].includes(String(identity.executionKind))
+        && ["initial", "correction"].includes(String(identity.dispatchReason))
+        && typeof identity.phase === "string" && Array.isArray(identity.scopeIds)
         && typeof identity.sessionId === "string" && identity.sessionId.length > 0
         && typeof r.startedAt === "string" && Number.isFinite(Date.parse(r.startedAt))
         && (r.completion === "incomplete" || (r.completion === "complete" && typeof r.finishedAt === "string" && Date.parse(r.finishedAt) >= Date.parse(r.startedAt)))
         && Array.isArray(r.attempts) && r.attempts.every(a => a !== null && typeof a === "object")
+        && nullableCount(progress.durableReplacements) && nullableCount(progress.finalizeRejections)
         && nullableCount(actual.requestCount) && nullableCount(actual.totalTokens) && nullableCount(progress.failedRecords);
 }
 /** Read one frozen canary run. The optional artifact may add only run-level
@@ -337,27 +363,14 @@ function isCanaryReceipt(value) {
  * request usage and tool rejections always come from session receipts. */
 export async function readFrontendPlanCanaryRunMetrics(runDir, nodeId = "frontend-plan-pi") {
     const sessionMetrics = summarizeFrontendPlanCanary(await readFrontendSessionBudgetReceipts(runDir, nodeId));
-    let supplemental = {};
-    try {
-        const parsed = JSON.parse(await readFile(path.join(runDir, "frontend-plan-canary-metrics.json"), "utf8"));
-        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-            supplemental = parsed;
-        }
-    }
-    catch {
-        // Missing or malformed supplemental evidence remains unavailable.
-    }
-    const optionalNumber = (key) => {
-        const value = supplemental[key];
-        return typeof value === "number" && Number.isFinite(value) && value >= 0
-            ? value
-            : null;
-    };
+    // A freely editable metrics JSON is not execution or adjudication evidence.
+    // Root evaluation must supply validated lineage and independent acceptance;
+    // until then the Plan projection can pass only its own local gate.
     return {
         ...sessionMetrics,
-        dagWallClockMs: optionalNumber("dagWallClockMs"),
-        designReviewRejectRate: optionalNumber("designReviewRejectRate"),
-        finalReviewDefectRate: optionalNumber("finalReviewDefectRate"),
-        recoveryCount: optionalNumber("recoveryCount"),
+        dagWallClockMs: null,
+        designReviewRejectRate: null,
+        finalReviewDefectRate: null,
+        recoveryCount: null,
     };
 }

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

@@ -0,0 +1,10 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const context = new AsyncLocalStorage();
+/** Async-local identity only; no mutable budget or usage is stored here. */
+export function withFrontendSessionIdentity(identity, execute) {
+    return context.run(structuredClone(identity), execute);
+}
+export function currentFrontendSessionIdentity() {
+    const identity = context.getStore();
+    return identity && structuredClone(identity);
+}