@tea-agent/loop-agent 0.42.0-next.15 → 0.42.0-next.16

package/dist/executors/shell-executor.js

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
+import { withFrontendTestReporter, parseFrontendTestExecutionReport } from "../workflows/dag/frontend-test-execution-evidence.js";
 import { appendFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
@@ -1950,6 +1951,23 @@ async function executeFrontendVerificationBundle(input, meta) {
     const bundle = shell.frontendVerificationBundle;
     const cwd = resolveShellCwd(input.cwd, shell.cwd);
     const results = [];
+    const commandResultsByKey = new Map();
+    const commandKey = (command) => `${cwd}\u0000${command.trim()}`;
+    const reuseCommandResult = (result, command) => {
+        const reusedAt = new Date().toISOString();
+        return {
+            ...result,
+            command,
+            durationMs: 0,
+            wallDurationMs: 0,
+            executionDurationMs: result.executionDurationMs ?? result.durationMs,
+            startedAt: reusedAt,
+            finishedAt: reusedAt,
+            stdoutArtifactPath: undefined,
+            stderrArtifactPath: undefined,
+            reused: true,
+        };
+    };
     let beforeStatus;
     try {
         beforeStatus = await readGitStatusPorcelain(input.cwd);
@@ -1958,22 +1976,32 @@ async function executeFrontendVerificationBundle(input, meta) {
         beforeStatus = undefined;
     }
     const lintResults = [];
+    const successfulLabels = new Map();
+    const successfulCommandTexts = new Map();
+    const executedTests = new Map();
+    const commandExecutionEvidence = new Map();
     for (const command of bundle.lintCommands ?? []) {
-        const commandNumber = results.length + 1;
-        const result = await executeShellCommand({
-            command,
-            cwd,
-            timeoutMs: shell.timeoutMs ?? DEFAULT_SHELL_TIMEOUT_MS,
-            envAllowlist: shell.envAllowlist,
-            dagRunMeta: { runDir: meta.runDir, runId: meta.runId },
-            reportActivity: input.reportActivity,
-            outputArtifacts: {
-                stdoutPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stdout.txt`),
-                stderrPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stderr.txt`),
-            },
-        });
-        lintResults.push(result);
+        const key = commandKey(command);
+        const cached = commandResultsByKey.get(key);
+        let result = cached ? reuseCommandResult(cached, command) : undefined;
+        if (!result) {
+            const commandNumber = results.length + 1;
+            result = await executeShellCommand({
+                command,
+                cwd,
+                timeoutMs: shell.timeoutMs ?? DEFAULT_SHELL_TIMEOUT_MS,
+                envAllowlist: shell.envAllowlist,
+                dagRunMeta: { runDir: meta.runDir, runId: meta.runId },
+                reportActivity: input.reportActivity,
+                outputArtifacts: {
+                    stdoutPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stdout.txt`),
+                    stderrPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stderr.txt`),
+                },
+            });
+            commandResultsByKey.set(key, result);
+        }
         results.push(result);
+        lintResults.push(result);
     }
     let lintAssessment;
     if ((bundle.lintCommands?.length ?? 0) > 0 &&
@@ -2007,30 +2035,64 @@ async function executeFrontendVerificationBundle(input, meta) {
             labels: bundle.behaviorEvidence.commandLabels,
         },
     ];
-    const successfulLabels = new Map();
+    const failedGroups = new Set();
+    const groupFailures = [];
     for (const group of lintBlocked ? [] : groups) {
         for (const [index, command] of group.commands.entries()) {
-            const commandNumber = results.length + 1;
-            const result = await executeShellCommand({
-                command,
-                cwd,
-                timeoutMs: shell.timeoutMs ?? DEFAULT_SHELL_TIMEOUT_MS,
-                envAllowlist: shell.envAllowlist,
-                dagRunMeta: { runDir: meta.runDir, runId: meta.runId },
-                reportActivity: input.reportActivity,
-                outputArtifacts: {
-                    stdoutPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stdout.txt`),
-                    stderrPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stderr.txt`),
-                },
-            });
+            if (failedGroups.has(group.name))
+                break;
+            const key = commandKey(command);
+            const cached = commandResultsByKey.get(key);
+            let result = cached ? reuseCommandResult(cached, command) : undefined;
+            if (!result) {
+                const commandNumber = results.length + 1;
+                const reportPath = path.join(meta.runDir, input.task.id, "commands", `${commandNumber}-${randomUUID()}.vitest.json`);
+                const observedCommand = await withFrontendTestReporter({ command, cwd, reportPath });
+                if (observedCommand)
+                    await mkdir(path.dirname(reportPath), { recursive: true });
+                result = await executeShellCommand({
+                    command: observedCommand ?? command,
+                    cwd,
+                    timeoutMs: shell.timeoutMs ?? DEFAULT_SHELL_TIMEOUT_MS,
+                    envAllowlist: shell.envAllowlist,
+                    dagRunMeta: { runDir: meta.runDir, runId: meta.runId },
+                    reportActivity: input.reportActivity,
+                    outputArtifacts: {
+                        stdoutPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stdout.txt`),
+                        stderrPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stderr.txt`),
+                    },
+                });
+                let reportError;
+                if (observedCommand && result.ok) {
+                    try {
+                        commandExecutionEvidence.set(key, parseFrontendTestExecutionReport(JSON.parse(await readFile(reportPath, "utf8")), cwd));
+                    }
+                    catch (error) {
+                        reportError = `frontend test execution report unavailable: ${error instanceof Error ? error.message : String(error)}`;
+                    }
+                }
+                if (reportError) {
+                    result = { ...result, ok: false, failureCategory: "invalid-output", stderr: reportError };
+                }
+                commandResultsByKey.set(key, result);
+            }
             results.push(result);
             if (result.ok && group.labels[index]) {
+                const observations = commandExecutionEvidence.get(key);
+                if (observations !== undefined)
+                    executedTests.set(group.labels[index], observations);
                 const labels = successfulLabels.get(group.name) ?? [];
                 labels.push(group.labels[index]);
                 successfulLabels.set(group.name, labels);
+                const texts = successfulCommandTexts.get(group.name) ?? [];
+                texts.push(command);
+                successfulCommandTexts.set(group.name, texts);
             }
-            if (!result.ok)
+            if (!result.ok) {
+                groupFailures.push(result);
+                failedGroups.add(group.name);
                 break;
+            }
         }
     }
     if (beforeStatus !== undefined) {
@@ -2060,12 +2122,15 @@ async function executeFrontendVerificationBundle(input, meta) {
         exitCode: result.exitCode,
         failureCategory: result.failureCategory,
         command: result.command,
+        reused: result.reused === true,
     }));
+    // Lint baseline-debt is tolerated, so a lint-only failure must not become the
+    // verification failure. A shared lint/static or lint/behavior command is
+    // different: once reused by a non-lint lane, its failure belongs to that lane
+    // and must remain the primary failure evidence.
     const firstFailure = lintBlocked
         ? lintResults.find((result) => !result.ok)
-        : results
-            .filter((result) => !lintResults.includes(result))
-            .find((result) => !result.ok);
+        : groupFailures[0];
     const lintSyntheticFailure = lintBlocked && !firstFailure
         ? {
             failureCategory: "invalid-output",
@@ -2082,7 +2147,7 @@ async function executeFrontendVerificationBundle(input, meta) {
                 mock: {
                     nodeId: input.task.id,
                     commandLabels: successfulLabels.get("mock") ?? [],
-                    commandTexts: bundle.mockCommands.slice(0, successfulLabels.get("mock")?.length ?? 0),
+                    commandTexts: successfulCommandTexts.get("mock") ?? [],
                 },
                 static: {
                     nodeId: input.task.id,
@@ -2091,6 +2156,7 @@ async function executeFrontendVerificationBundle(input, meta) {
                 behavior: {
                     nodeId: input.task.id,
                     commandLabels: successfulLabels.get("behavior") ?? [],
+                    executedTests,
                 },
             },
         });
@@ -2123,7 +2189,9 @@ async function executeFrontendVerificationBundle(input, meta) {
             nodeId: failedNodeId,
             rawFailureCategory: failureCategory,
         });
-        const failureOwner = classifiedOwner === "unknown" ? "implement-pi" : classifiedOwner;
+        const failureOwner = classifiedOwner === "unknown" &&
+            ["typecheck", "build", "lint", "component-test", "unit-test", "trace"].includes(failureClass)
+            ? "implementation" : classifiedOwner;
         const restartPhase = classifyRestartPhase(failureOwner);
         // A+B (AC-008): verification-config routing. Produce structured
         // unresolved entrypoint refs from committed plan facts and the frozen

package/dist/shared/dag-failure-category.js

@@ -63,6 +63,12 @@ const RAW_TO_NORMALIZED = {
     // compaction / fresh context before retrying — an executor-side
     // environment condition, not a plan-quality defect.
     "context-overflow": "executor",
+    // stopReason=length output-capacity truncation: same executor-side
+    // capacity class as context-overflow. Legacy thinking-exhausted labels
+    // (pre-output-limit artifacts) map to the same class.
+    "output-limit": "executor",
+    "writer-thinking-exhausted": "executor",
+    "planner-thinking-exhausted": "executor",
     // Deterministic capability/policy refusal: missing verified launcher JS
     // entry, capability allowlist rejection, or missing bounded write tool
     // profile. These are environment/config defects the operator repairs

package/dist/task/contract/apply.js

@@ -147,7 +147,7 @@ export async function applyTaskContract(input) {
             ref,
             changedFiles: [],
             idempotentReplay: true,
-            txId: existing.txId,
+            ...(existing.txId ? { txId: existing.txId } : { noOp: true }),
         };
     }
     const lock = await acquireTaskContractLock({
@@ -175,7 +175,9 @@ export async function applyTaskContract(input) {
                 ref,
                 changedFiles: [],
                 idempotentReplay: true,
-                txId: existingUnderLock.txId,
+                ...(existingUnderLock.txId
+                    ? { txId: existingUnderLock.txId }
+                    : { noOp: true }),
             };
         }
         const state = await observeTaskContractState(input.repoRoot, input.taskId);
@@ -251,6 +253,38 @@ export async function applyTaskContract(input) {
             sourceHashes,
             taskConfigSha256,
         });
+        // Content-level no-op: when the freshly projected draft hashes
+        // identically to both the recorded contract and the on-disk observation,
+        // the journaled commit would only churn revision/updatedAt metadata and
+        // force downstream consumers (writeSet gate digest binds
+        // contractRevision+contractCanonicalHash) to re-issue approvals for
+        // zero content change. Return the current ref untouched instead. A
+        // drifted disk (observed !== ref) never reaches this short-circuit: the
+        // apply is then a repair projection and must run.
+        if (state.ref &&
+            canonicalHash === state.ref.canonicalHash &&
+            state.observedCanonicalHash === state.ref.canonicalHash) {
+            await assertLockHeld(lock);
+            await appendRequestLedgerEntry({
+                repoRoot: input.repoRoot,
+                taskId: input.taskId,
+                entry: {
+                    schemaVersion: 1,
+                    requestId: input.requestId,
+                    requestPayloadSha256: input.requestPayloadSha256,
+                    revision: state.ref.revision,
+                    canonicalHash: state.ref.canonicalHash,
+                    recordedAt: new Date().toISOString(),
+                    resultSummary: { ok: true, operation: "apply" },
+                },
+            });
+            return {
+                ref: state.ref,
+                changedFiles: [],
+                idempotentReplay: false,
+                noOp: true,
+            };
+        }
         const nextRevision = currentRevision + 1;
         const nextRef = {
             schemaVersion: TASK_CONTRACT_REF_SCHEMA_VERSION,

package/dist/task/source-prepare/parse-intent.js

@@ -13,6 +13,13 @@ const HEADING_ALIASES = {
         "需求范围",
         "已确认范围",
         "已确认需求",
+        // Common zh-CN frontend-PRD variants seen in real PRDs; without these a
+        // raw-PRD fallback parse (semantic intake unavailable) yields an empty
+        // scope and flips the import to incomplete (EMPTY scope deadlock).
+        "目标表面",
+        "交付范围",
+        "实现范围",
+        "交付内容",
     ]),
     nonGoals: new Set(["非目标", "out of scope", "non-goals", "non goals"]),
     acceptance: new Set([

package/dist/workflows/dag/dag-retry-schema.js

@@ -32,7 +32,10 @@ export const DEFAULT_DAG_RETRY_CATEGORIES = [
     "rate-limit",
     "unavailable",
     "empty-output",
+    "output-limit",
 ];
+/** Provider stopReason=length: output/context capacity ended the turn early. */
+export const OUTPUT_LIMIT_RETRY_CATEGORY = "output-limit";
 export const STRUCTURED_OUTPUT_RETRY_CATEGORY = "output-too-large";
 export const PROTOCOL_INVALID_RETRY_CATEGORY = "protocol-invalid";
 /** Recoverable model artifact/schema formatting failure on read-only structured nodes. */

package/dist/workflows/dag/frontend-design-policy.js

@@ -259,7 +259,7 @@ export function checkTargetPaths(contract, writeSetPatterns) {
     if (contract.targets.files.length > MAX_WRITE_SET_FILES) {
         findings.push({
             code: "write-set-too-large",
-            message: `implementation writeSet has ${contract.targets.files.length} files (limit ${MAX_WRITE_SET_FILES}); split the task (record_split_proposal) so no single implement node exceeds the bound`,
+            message: `implementation writeSet has ${contract.targets.files.length} files (limit ${MAX_WRITE_SET_FILES}); split the task at the Contract boundary so no single implement node exceeds the bound; preserve all required files`,
         });
     }
     for (const file of contract.targets.files) {

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

@@ -70,8 +70,10 @@ function blobOf(input) {
     ].join("\n");
 }
 function pathSpreadScore(paths) {
+    const auxiliaryRoot = /^(?:test|tests|__tests__|e2e|cypress|spec|specs|docs|documentation)$/i;
     const tops = new Set(paths
         .map((p) => p.replace(/\\/g, "/").split("/").filter(Boolean)[0] ?? "")
+        .filter((root) => !auxiliaryRoot.test(root))
         .filter(Boolean));
     return tops.size;
 }

package/dist/workflows/dag/frontend-shadow-dual-write.js

@@ -485,7 +485,22 @@ export function assemblePlanPatchFromCommittedFacts(records, contractRequirement
     }
     const verificationTargets = verificationTargetOrder
         .map((id) => verificationTargetById.get(id))
-        .filter((entry) => Boolean(entry));
+        .filter((entry) => Boolean(entry))
+        .map((entry) => {
+        // Coverage precedes UX. A later state-flow fact explicitly naming
+        // this VT establishes the reverse binding without another model call.
+        // No path/name heuristics: unbound or ambiguous decisions stay subject
+        // to canonical validation. Recompute from live states after removals.
+        const boundStates = [...stateByName.values()]
+            .filter((state) => state.applicable === true &&
+            asStringArray(state.verificationTargetIds).includes(asString(entry.id)))
+            .map((state) => asString(state.name));
+        if (boundStates.length === 0)
+            return entry;
+        return { ...entry, uiStates: [...new Set([
+                    ...asStringArray(entry.uiStates), ...boundStates,
+                ])].sort() };
+    });
     if (verificationTargets.length > 0) {
         patch.verificationTargets = verificationTargets;
     }

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

@@ -46,8 +46,15 @@ const EXECUTABLE_SHAPE_RANK = {
     high: 3,
 };
 function pathSpreadScore(paths) {
+    // Verification-only roots are routinely authorized together with the
+    // implementation root (for example `src/**` + `test/**`). They do not make
+    // a UI change cross-domain, so exclude them from the topology spread signal.
+    // Keep product packages and source roots intact: `apps/**` + `packages/**`
+    // must still count as a real spread and prevent an unsafe small topology.
+    const auxiliaryRoot = /^(?:test|tests|__tests__|e2e|cypress|spec|specs|docs|documentation)$/i;
     const tops = new Set(paths
         .map((p) => p.replace(/\\/g, "/").split("/").filter(Boolean)[0] ?? "")
+        .filter((root) => !auxiliaryRoot.test(root))
         .filter(Boolean));
     return tops.size;
 }
@@ -65,6 +72,13 @@ function collectEscalationSignals(blob, supervised) {
     }
     return [...new Set(signals)];
 }
+/** Negation applies to the API mention itself, never to unrelated Mock policy. */
+function hasFrontendRemoteSignal(blob) {
+    const remaining = blob
+        .replace(/\bno\s+api\b/gi, "")
+        .replace(/无\s*(?:api\b|接口)/gi, "");
+    return /\b(api|fetch|axios|graphql|endpoint)\b|远程|接口/i.test(remaining);
+}
 function resolveBaselineFrontendTaskShape(input) {
     const blob = [
         input.requirementMarkdown ?? "",
@@ -84,9 +98,7 @@ function resolveBaselineFrontendTaskShape(input) {
     const paths = input.allowedPaths ?? [];
     const spread = pathSpreadScore(paths);
     const concentrated = spread <= 1 && paths.length <= 4;
-    const hasApiSignal = /\b(api|fetch|axios|graphql|endpoint|远程|接口)\b/i.test(blob) &&
-        !(/(?:^|[^\w])(?:no\s+api|not-needed)(?:$|[^\w])/i.test(blob) ||
-            /无\s*api|无\s*接口/i.test(blob));
+    const hasApiSignal = hasFrontendRemoteSignal(blob);
     const complexity = (input.complexity ?? "").toLowerCase();
     // split-required wins over everything: it is a termination/escalation
     // signal, not an executable topology.
@@ -266,9 +278,7 @@ export function deriveFrontendRuntimeShapeFacts(input) {
     const supervised = /\bsupervised\b/i.test(blob);
     const escalationSignals = collectEscalationSignals(blob, supervised);
     const paths = input.allowedPaths ?? [];
-    const hasApiSignal = /\b(api|fetch|axios|graphql|endpoint|远程|接口)\b/i.test(blob) &&
-        !(/(?:^|[^\w])(?:no\s+api|not-needed)(?:$|[^\w])/i.test(blob) ||
-            /无\s*api|无\s*接口/i.test(blob));
+    const hasApiSignal = hasFrontendRemoteSignal(blob);
     const requiresFull = escalationSignals.length > 0 || pathSpreadScore(paths) > 1 || hasApiSignal;
     return {
         splitRequired: input.splitRequired,

package/dist/workflows/dag/frontend-test-execution-evidence.js

@@ -0,0 +1,48 @@
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+import { z } from "zod";
+/** Observe supported frozen Vitest commands without changing their selection. */
+export async function withFrontendTestReporter(input) {
+    // Compound commands/wrappers need their own adapter: never append flags to
+    // a different shell command, change selection, or override a user reporter.
+    if (/[;&|<>`\n\r$]/.test(input.command) || /--(?:reporter|outputFile)/.test(input.command))
+        return undefined;
+    const direct = /^(?:(?:npx|pnpm exec|yarn exec)\s+)?vitest\s+run(?:\s|$)/.test(input.command.trim());
+    const npm = /^npm\s+(?:run\s+([\w:-]+)|(test))(?=\s|$)(.*)$/.exec(input.command.trim());
+    let separator = "";
+    if (!direct) {
+        if (!npm)
+            return undefined;
+        let manifest;
+        try {
+            manifest = JSON.parse(await readFile(path.join(input.cwd, "package.json"), "utf8"));
+        }
+        catch {
+            return undefined;
+        }
+        const script = manifest.scripts?.[npm[1] ?? "test"] ?? "";
+        if (!/^vitest\s+run(?:\s|$)/.test(script) || /[;&|<>`\n\r$]|--(?:reporter|outputFile)/.test(script))
+            return undefined;
+        if (npm[3]?.trim() && !/^--(?:\s|$)/.test(npm[3].trim()))
+            return undefined;
+        separator = npm[3]?.trim() ? "" : " --";
+    }
+    const quote = (value) => `'${value.replace(/'/g, `'"'"'`)}'`;
+    return `${input.command}${separator} --reporter=json --outputFile=${quote(input.reportPath)}`;
+}
+const resultSchema = z.object({
+    testResults: z.array(z.object({
+        name: z.string().min(1),
+        assertionResults: z.array(z.object({
+            title: z.string(), fullName: z.string().optional(),
+            ancestorTitles: z.array(z.string()).optional(), status: z.string(),
+        })),
+    })),
+});
+export function parseFrontendTestExecutionReport(raw, cwd) {
+    return resultSchema.parse(raw).testResults.flatMap((suite) => suite.assertionResults.map((test) => ({
+        file: path.relative(cwd, path.resolve(cwd, suite.name)).replace(/\\/g, "/"),
+        title: test.fullName ?? [...(test.ancestorTitles ?? []), test.title].join(" "),
+        status: test.status,
+    })));
+}

package/dist/workflows/dag/frontend-verification-trace.js

@@ -152,6 +152,7 @@ export function extractFrontendTestTitles(content) {
     const tokens = lexFrontendTestSource(content);
     const titles = [];
     const configurationModifiers = new Set(["each", "runIf", "skipIf"]);
+    const nonExecutingModifiers = new Set(["skip", "todo", "fails"]);
     function closingParenIndex(openIndex) {
         let depth = 0;
         for (let cursor = openIndex; cursor < tokens.length; cursor += 1) {
@@ -177,12 +178,21 @@ export function extractFrontendTestTitles(content) {
         }
         let cursor = index + 1;
         let hasConfigurationModifier = false;
+        let hasNonExecutingModifier = false;
+        let conditionalModifier;
         while (tokens[cursor]?.type === "punctuation" &&
             tokens[cursor]?.value === "." &&
             tokens[cursor + 1]?.type === "identifier") {
             if (tokens[cursor + 1]?.type === "identifier" &&
                 configurationModifiers.has(tokens[cursor + 1].value)) {
                 hasConfigurationModifier = true;
+                if (["runIf", "skipIf"].includes(tokens[cursor + 1].value)) {
+                    conditionalModifier = tokens[cursor + 1].value;
+                }
+            }
+            if (tokens[cursor + 1]?.type === "identifier" &&
+                nonExecutingModifiers.has(tokens[cursor + 1].value)) {
+                hasNonExecutingModifier = true;
             }
             cursor += 2;
         }
@@ -191,6 +201,13 @@ export function extractFrontendTestTitles(content) {
             continue;
         }
         if (hasConfigurationModifier) {
+            if (conditionalModifier && tokens[cursor + 1]?.type === "identifier" &&
+                tokens[cursor + 2]?.value === ")") {
+                const condition = tokens[cursor + 1].value;
+                if ((conditionalModifier === "runIf" && condition === "false") ||
+                    (conditionalModifier === "skipIf" && condition === "true"))
+                    hasNonExecutingModifier = true;
+            }
             const close = closingParenIndex(cursor);
             if (close === null ||
                 tokens[close + 1]?.type !== "punctuation" ||
@@ -199,6 +216,11 @@ export function extractFrontendTestTitles(content) {
             }
             cursor = close + 1;
         }
+        if (hasNonExecutingModifier) {
+            // A skipped suite also skips every nested test title in its body.
+            index = closingParenIndex(cursor) ?? tokens.length;
+            continue;
+        }
         if (tokens[cursor + 1]?.type !== "string")
             continue;
         titles.push(tokens[cursor + 1].value);
@@ -302,6 +324,15 @@ export async function evaluateVerificationTargets(input) {
             target,
         });
         issues.push(...fileTrace.issues);
+        const executed = input.executedTests?.get(target.commandLabel);
+        if (target.mode !== "static" && executed !== undefined) {
+            // safePath permits "./" prefixes; reporter files are cwd-relative.
+            const targetFile = path.posix.normalize(target.file.replace(/\\/g, "/"));
+            const matching = executed.filter((test) => test.file === targetFile && traceKeyMatchesTitle(target.id, test.title));
+            if (matching.length === 0 || matching.some((test) => test.status !== "passed")) {
+                issues.push(`behavior target was not fully executed and passed: ${target.id} in ${target.file}`);
+            }
+        }
         const status = issues.length ? "failed" : "ok";
         if (issues.length)
             hardIssues.push(...issues.map((i) => `${target.id}: ${i}`));
@@ -473,6 +504,7 @@ export async function runFrontendVerificationTraceGate(input) {
         contract,
         labelOwners,
         workspaceRoot: input.workspaceRoot,
+        executedTests: input.evidence?.behavior.executedTests,
     });
     if (hardIssues.length) {
         throw new Error(`trace: ${hardIssues.join("; ")}`);

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

@@ -2559,8 +2559,8 @@ function resolveFrontendMockContextBlock(sources) {
     if (mode === "not-required") {
         parts.push("Generation-time evidence does not require Mock. The assessment must still use contract/scout evidence: select not-needed when Mock is intentionally skipped, or select a safe Mock strategy if project evidence supports one.");
         if (frontendMockStrategyMustBeNotNeeded(sources)) {
-            parts.push('Auto mode has no confirmed project Mock capability or no deterministic Mock verification command. The structured contract must set mockApi.strategy to "not-needed". Do not add Mock files or dependencies; keep the real request path as default and record any unproved backend behavior as Real Integration Gap.');
-            parts.push('HARD CONSTRAINT (frozen at generation time): this DAG allows only mockApi.strategy "not-needed"; the prewrite gate rejects any other strategy. If project governance (openspec / ai_workspace / decision records, e.g. a DEC rule requiring native) demands Mock-backed verification, that is a generation-time contract gap, not a plan-revision defect: declare frontendMock.verifyCommands (or policy: "required") in task.json and regenerate the DAG. Do not emit any mockApi.strategy outside the allowlist and do not add Mock files or dependencies within this run.');
+            parts.push('Auto mode has no confirmed project Mock capability or no deterministic Mock verification command. The structured contract must set mockApi.strategy to "not-needed". Keep the real request path as the default, record any unproved backend behavior as Real Integration Gap, and do not add Mock files or dependencies within this run.');
+            parts.push('HARD CONSTRAINT (frozen at generation time): this DAG allows only mockApi.strategy "not-needed"; the prewrite gate rejects any other strategy. If project governance (openspec / ai_workspace / decision records, e.g. a DEC rule requiring native) demands Mock-backed verification, that is a generation-time contract gap, not a plan-revision defect: declare frontendMock.verifyCommands (or policy: "required") in task.json and regenerate the DAG.');
         }
     }
     if (mode === "blocked") {
@@ -3226,9 +3226,7 @@ async function buildFrontendHybridDagFromTask(sources) {
         "Reference frozen commands ONLY by commandId (record_plan_verification_target entry.commandId). The runtime resolves mode and label; never invent a mode or type.",
         ...frontendVerifyDirectory.map((entry) => `  - ${entry.commandId} [${entry.mode}]: ${JSON.stringify(entry.label)}`),
         `- Static command source: ${staticVerifyEvidence.commandSource}`,
-        ...staticVerifyEvidence.commandLabels.map((command) => `  - ${JSON.stringify(command)}`),
         `- Behavior command source: ${behaviorVerifyEvidence.commandSource}`,
-        ...behaviorVerifyEvidence.commandLabels.map((command) => `  - ${JSON.stringify(command)}`),
     ].join("\n");
     const advisories = [];
     if (!hasDeclaredFrontendVerification &&
@@ -3394,7 +3392,10 @@ async function buildFrontendHybridDagFromTask(sources) {
                 depends_on: ["frontend-contract-pi", "frontend-scout-pi"],
                 role: "planner",
                 executor: "pi",
-                complexity: "MED",
+                // Small topology has already proven a concentrated, no-remote scope;
+                // keep its bounded plan on the LOW model tier. Standard/High retain
+                // MED for broader contract-to-surface decisions.
+                complexity: frontendTaskShape.shape === "small" ? "LOW" : "MED",
                 writePolicy: "read-only",
                 retryPolicy: FRONTEND_PLAN_LADDER_RETRY_POLICY,
                 allowedPaths: readOnlyPaths,
@@ -3503,18 +3504,16 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "Your authoritative terminal verdict is exactly one committed typed tool call: approve_design or request_design_changes. Call exactly one of them; after calling one, do not call the other.",
                     "request_design_changes must carry a typed issueCategory, at least one evidenceRef, and non-empty findings.",
                     "Your verdict is consumed as deterministic data input by frontend-writer-admission-shell. approve_design permits admission; request_design_changes blocks writer admission until a recovery plan incorporates every Critical/Important finding.",
-                    "Request design changes when the Mock strategy is MOCK_STRATEGY: blocked, missing, unsupported by repository evidence, inconsistent with the API contract, outside authorized paths/dependencies, unable to prove production-default-off behavior with the fixed production/default-real-path static check, or missing deterministic behavior verification for a declared behavior target or selected Mock strategy. Mock strategies require Mock-backed evidence. A static-only contract is allowed only when every verification target is static and maps to a declared static entrypoint. not-needed otherwise requires applicable real/no-remote behavior evidence unless auto mode explicitly skipped Mock because no project Mock capability exists; in that case the plan must preserve the real request path and record the Real Integration Gap.",
+                    "Request design changes when the Mock strategy is blocked, missing, unsupported by repository evidence, inconsistent with the API contract, outside authorized paths/dependencies, unable to prove production-default-off behavior with the fixed production/default-real-path static check, or missing deterministic behavior verification for a declared behavior target or selected Mock strategy. Mock strategies require Mock-backed evidence; a static-only contract is allowed only when every verification target is static and maps to a declared static entrypoint; not-needed requires applicable real/no-remote behavior evidence unless auto mode explicitly skipped Mock because no project Mock capability exists, in which case the plan must preserve the real request path and record the Real Integration Gap.",
                     "Also request design changes for missing applicable UI states, unsupported dependency additions, design-system drift without reason, weak interaction coverage, broad scope, inline fake data, schema drift, or missing deterministic verification commands.",
-                    "Component selection conformance is a hard blocking condition: request_design_changes when the frontend spec (component/theme/rule.components bucket) already defines a component for a purpose but the plan selects another or self-invents one without a declared deviation; when uiComponentChoices is missing/empty for UI-visible work while the frozen component/theme bucket is non-empty; when a decision=specified specReference.path is missing a ledger OpenSpec reference or successful read event; or when a decision=new component lacks a traceable task-source/PRD specReference. A PRD reference for decision=new is not an OpenSpec citation and must not be rejected merely for lacking an OpenSpec read event.",
-                    "For uiComponentChoices, purpose is the stable coverage key and must match interaction.name or uiState.name. Responsibility is expressed by the matched expectedBehavior plus rationale; you must not reject it merely for matching an interaction or component identifier.",
-                    "You must NOT make authoritative assertions about the execution result of frozen verification commands (typecheck/test/build/lint/etc.). Predicting that a command will necessarily pass or fail, or declaring an acceptance criterion unreachable on that basis, is out of your authority: command results are deterministically established by frontend-verify-shell. Any concern about verification feasibility must be recorded only as a non-blocking verification concern in findings (severity must not be Critical, and it must never be the sole fatal basis for request_design_changes). Only semantic design defects (component selection, state flow, interaction contract, or conflicts with the specification) may be Critical. A pure command-will-fail prediction must not be classified as contract-requirement-gap.",
+                    "Component selection conformance is a hard blocking condition: request_design_changes when the frontend spec (component/theme/rule.components bucket) already defines a component for a purpose but the plan selects another or self-invents one without a declared deviation; when uiComponentChoices is missing/empty for UI-visible work while the frozen component/theme bucket is non-empty; when a decision=specified specReference.path is missing a ledger OpenSpec reference or successful read event; or when a decision=new component lacks a traceable task-source/PRD specReference. A PRD reference for decision=new is not an OpenSpec citation and must not be rejected merely for lacking an OpenSpec read event. For uiComponentChoices, purpose is the stable coverage key and must match interaction.name or uiState.name; responsibility is expressed by the matched expectedBehavior plus rationale, and you must not reject it merely for matching an interaction or component identifier.",
+                    "You must NOT make authoritative assertions about the execution result of frozen verification commands: command results are deterministically established by frontend-verify-shell. Record a verification-feasibility concern only as a non-blocking finding (severity must not be Critical, and it must never be the sole fatal basis for request_design_changes). Only semantic design defects (component selection, state flow, interaction contract, or conflicts with the specification) may be Critical; a pure command-will-fail prediction must not be classified as contract-requirement-gap.",
                     "Read-only: do not modify repository files.",
                     "LARGE-FILE AUDIT (avoid full reads): style/theme audit files can be large (e.g. styles.css is often hundreds of KB). Prefer grep to locate the exact rules/variables you must verify (e.g. grep the oc- class, is-* modifier, or --oc- theme variables with their line numbers), then read only the narrow line range when surrounding context is needed. Do not read a large style/test file in full — a single full read can exhaust the read budget and fail the attempt.",
                     "Canonical contract reading: frontend-design-policy-shell prints absolute paths for Contract, Contract index, and the non-blocking Capacity diagnostic. Read the capacity diagnostic first. When it recommends full-contract, read the exact Contract path. When it recommends indexed-sections, read the Contract index and its hash-bound section files instead of opening the full contract. Never resolve a bare contracts/... path against the repository root or hunt for substitutes. Implementation target files inside the writeSet are created later by the implement node: do not read them and do not treat their absence as a design defect.",
                     fixedVerificationContext,
                     sourceContexts.designReview,
                     scopedOpenspecContext,
-                    frontendContractFieldSummary,
                     mockContextBlock,
                 ].join("\n\n"),
             },