@tea-agent/loop-agent 0.42.0-next.8 → 0.42.0

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

@@ -1,3 +1,4 @@
+import { setTimeout as delay } from "node:timers/promises";
 import { isTerminalOperationState, } from "../../infrastructure/console/operation-store.js";
 import { runOperation, } from "../../worker/console/operation-runner.js";
 import { buildFailureCapsule, classifyFailureOwner, projectProtocolFailureReason, } from "./frontend-recovery-capsule.js";
@@ -78,7 +79,13 @@ export async function runRecoveryOperationController(input) {
     const readChangedFiles = deps.readChangedFiles ?? (async () => []);
     const fingerprints = [...(deps.previousFingerprints ?? [])];
     let budgetAggregate;
-    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    const pollIntervalMs = Math.max(10, deps.operationPollIntervalMs ?? 1_000);
+    const waitTimeoutMs = Math.max(pollIntervalMs, deps.operationWaitTimeoutMs ??
+        deps.operationRunnerDeps.defaultTimeoutMs ??
+        30 * 60_000);
+    const waitStartedAt = Date.now();
+    let attempt = 1;
+    while (attempt <= maxAttempts) {
         const operation = await deps.store.get(operationId);
         if (!operation) {
             return {
@@ -190,7 +197,24 @@ export async function runRecoveryOperationController(input) {
                 detail: `interrupt projection: ${projected}`,
             };
         }
+        const operationAlreadyInFlight = operation.state === "starting" || operation.state === "running";
+        const operationOwnedElsewhere = input.observeOnly &&
+            (operation.state === "queued" || operation.state === "needs-reconcile");
+        if (operationAlreadyInFlight || operationOwnedElsewhere) {
+            if (Date.now() - waitStartedAt >= waitTimeoutMs) {
+                return {
+                    terminalReason: "needs-attention",
+                    attempts: attempt,
+                    budgetAggregate,
+                    fingerprints,
+                    detail: `recovery operation did not settle within ${waitTimeoutMs}ms`,
+                };
+            }
+            await delay(pollIntervalMs);
+            continue;
+        }
         await runOperation(operationId, deps.operationRunnerDeps);
+        attempt += 1;
     }
     return {
         terminalReason: "max-attempts",

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

@@ -26,7 +26,9 @@ export function deriveFrontendRecoveryFailureSource(result) {
  * Compute the frontend candidate-continuation reset partition:
  * - `frontend-plan-pi` failure → reset plan + design-review + policy/admission (+ descendants);
  * - `frontend-design-policy-shell` failure → reset policy/admission (+ descendants);
- * - admission/design-review failure → reset writer admission (+ descendants);
+ * - design-review rejection → reset plan + design review + admission (+ descendants);
+ * - final-review rejection → reset implementation + verification/review (+ descendants);
+ * - other admission failures → reset writer admission (+ descendants);
  *
  * Everything upstream of the failure source is imported as verified parent facts.
  */
@@ -61,7 +63,9 @@ function computeFrontendRecoveryPlanForSource(input) {
     // reset from implement: the recovery re-implements and re-verifies.
     const resetRoot = input.failureSource === "frontend-verify-shell"
         ? "frontend-implement-pi"
-        : input.failureSource;
+        : input.failureSource === "frontend-review-pi"
+            ? "frontend-implement-pi"
+            : input.failureSource;
     const resetNodeIds = computeResetClosure(input.spec, resetRoot);
     const resetSet = new Set(resetNodeIds);
     const importedNodeIds = input.spec.tasks

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

@@ -3,8 +3,10 @@ import path from "node:path";
 import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
 import { sha256Hex } from "./frontend-implementation-contract.js";
 import { FRONTEND_RECOVERY_IMPORT_MANIFEST_REL_PATH, FRONTEND_RECOVERY_INTENT_REL_DIR, FRONTEND_RECOVERY_STAGING_PREFIX, computeFrontendRecoveryPlan, computeFrontendRecoveryPlanForSource, } from "./frontend-recovery-plan.js";
-import { dagRunDirExists, getDagRunDir, readDagRunSpec, readDagRunState, transferDagRunDir, writeDagRunState, } from "./lifecycle.js";
+import { dagRunDirExists, getDagRunDir, locateDagRun, readDagRunSpec, readDagRunState, transferDagRunDir, writeDagRunState, } from "./lifecycle.js";
 import { buildDagRunId } from "./runner.js";
+import { buildFrontendTopologyBinding } from "./frontend-shape.js";
+import { FRONTEND_SHAPE_BOUNDARIES, isCanonicalFrontendShapeDag, } from "./frontend-shape-facts.js";
 import { prepareRunDir, writeNodeRecord } from "./run-store.js";
 import { FRONTEND_WRITER_ADMISSION_RESULT_ARTIFACT, readFrontendWriterAdmissionResult, } from "./scheduler.js";
 import { topoSortToRanks } from "./topo.js";
@@ -273,14 +275,63 @@ async function casUpdateFrontendRecoveryState(parentRunDir, expectedRevision, de
     await deps.writeParentState(parentRunDir, state);
 }
 async function materializeChildStaging(input) {
-    const { cwd, parentRunDir, parentRunId, parentSpec, parentState, recovery, requestId, childRunId, stagingDir, createdAt, } = input;
+    const { cwd, parentRunDir, parentRunId, parentSpec, parentState, recovery, recoveryPlan, requestId, childRunId, stagingDir, createdAt, } = input;
     await prepareRunDir(stagingDir);
-    await writeJsonVerified(stagingDir, "run.json", parentSpec);
+    // Design-review rejection must be visible to the reset planner. Recovery
+    // children otherwise copy the old spec and only rerun design review, which
+    // deterministically re-rejects the unchanged plan. Bind the parent's typed
+    // findings into the child spec as ordinary rerun feedback.
+    let childSpec = parentSpec;
+    if (recovery.failureSource === "frontend-plan-pi" ||
+        recovery.failureSource === "frontend-review-pi") {
+        const designRecovery = parentState.terminalReason === "design-request-changes";
+        const reviewRecovery = recovery.failureSource === "frontend-review-pi" ||
+            parentState.terminalReason === "review-request-changes";
+        let feedback;
+        try {
+            const { deriveDagRerunFeedback } = await import("./rerun-feedback.js");
+            const taskId = parentSpec.taskContractBinding?.taskId ??
+                parentSpec.sourceBinding?.taskId ??
+                parentRunId;
+            feedback = await deriveDagRerunFeedback({
+                parentRunId,
+                taskId,
+                runDir: parentRunDir,
+                spec: parentSpec,
+                state: parentState,
+            });
+            if (reviewRecovery &&
+                feedback &&
+                feedback.sourceNodeId !== "frontend-review-pi") {
+                // Do not accidentally carry an older design/verify finding when a
+                // review-triggered continuation has lost its typed review fact.
+                feedback = undefined;
+            }
+        }
+        catch (error) {
+            if (designRecovery || reviewRecovery) {
+                throw new Error(`frontend recovery feedback unavailable: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (feedback) {
+            childSpec = { ...parentSpec, rerunFeedback: feedback };
+        }
+        else if (designRecovery || reviewRecovery) {
+            // A design/review rejection cannot be safely retried without its typed
+            // findings. Fail closed instead of deterministically re-running the
+            // unchanged plan and producing another rejection.
+            throw new Error(`frontend recovery feedback unavailable: no typed ${reviewRecovery ? "review" : "design"} findings were found for recovery`);
+        }
+    }
+    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 (recovery.failureSource) {
+    if (recoveryPlan) {
+        plan = recoveryPlan;
+    }
+    else if (recovery.failureSource) {
         plan = computeFrontendRecoveryPlanForSource({
             spec: parentSpec,
             parentRunId,
@@ -300,10 +351,10 @@ async function materializeChildStaging(input) {
             result: admissionRead.result,
         });
     }
-    const { ranks } = topoSortToRanks(parentSpec);
+    const { ranks } = topoSortToRanks(childSpec);
     const resetSet = new Set(plan.resetNodeIds);
     const importedSet = new Set(plan.importedNodeIds);
-    const tasksById = new Map(parentSpec.tasks.map((task) => [task.id, task]));
+    const tasksById = new Map(childSpec.tasks.map((task) => [task.id, task]));
     const nodes = {};
     const importedFacts = [];
     for (const nodeId of plan.importedNodeIds) {
@@ -328,7 +379,7 @@ async function materializeChildStaging(input) {
         }
         nodes[nodeId] = buildPendingNodeRecord(task);
     }
-    for (const task of parentSpec.tasks) {
+    for (const task of childSpec.tasks) {
         if (!resetSet.has(task.id) && !importedSet.has(task.id)) {
             throw new Error(`node ${task.id} missing from frontend recovery plan partition`);
         }
@@ -338,13 +389,29 @@ async function materializeChildStaging(input) {
     const canonicalContract = await copyArtifactVerified({
         parentRunDir,
         newRunDir: stagingDir,
-        relativePath: resolveCanonicalContractRelPath(parentSpec),
+        relativePath: resolveCanonicalContractRelPath(childSpec),
     });
     const writerAdmissionResult = await copyArtifactVerified({
         parentRunDir,
         newRunDir: stagingDir,
         relativePath: FRONTEND_WRITER_ADMISSION_RESULT_ARTIFACT,
     });
+    // The scheduler gates every shape boundary by its committed fact once the
+    // boundary's source node is FINISHED. Imported nodes stay FINISHED in the
+    // child, so their boundaries must inherit the parent's committed facts or
+    // the child hard-blocks at the first gated rank. Reset boundaries re-commit
+    // their own facts when their source nodes re-run.
+    const inheritedCommittedFacts = {};
+    if (isCanonicalFrontendShapeDag(new Map(childSpec.tasks.map((task) => [task.id, task])))) {
+        for (const entry of FRONTEND_SHAPE_BOUNDARIES) {
+            if (!importedSet.has(entry.sourceNodeId))
+                continue;
+            const parentFact = parentState.frontendShapeState?.committedFacts[entry.boundary];
+            if (parentFact) {
+                inheritedCommittedFacts[entry.boundary] = structuredClone(parentFact);
+            }
+        }
+    }
     const childState = {
         version: 1,
         title: parentSpec.title,
@@ -354,6 +421,18 @@ async function materializeChildStaging(input) {
         status: "pending",
         ranks,
         nodes,
+        // Mirror createInitialRunState: a canonical frontend child must carry its
+        // own frozen topology binding or executeDag's binding assert rejects the
+        // staged child before its first node runs.
+        ...(isCanonicalFrontendShapeDag(new Map(childSpec.tasks.map((task) => [task.id, task])))
+            ? {
+                frontendShapeState: {
+                    frozenTopology: buildFrontendTopologyBinding(childSpec.tasks.map((task) => task.id)),
+                    revision: 0,
+                    committedFacts: inheritedCommittedFacts,
+                },
+            }
+            : {}),
         frontendRecoveryState: {
             schemaVersion: 1,
             phase: "child-running",
@@ -362,8 +441,11 @@ async function materializeChildStaging(input) {
             parentRunId,
             childRunId,
             attemptId: recovery.attemptId,
-            attemptIndex: 1,
-            continuationCount: 1,
+            attemptIndex: recovery.attemptIndex + 1,
+            continuationCount: recovery.continuationCount + 1,
+            ...(recovery.failureSource
+                ? { failureSource: recovery.failureSource }
+                : {}),
             revision: 0,
         },
         ...(parentState.evaluation
@@ -432,7 +514,41 @@ export async function stageRecoveryChild(options) {
     const parentRunDir = getDagRunDir(cwd, "active", parentRunId);
     const parentState = await deps.readParentState(parentRunDir);
     const parentSpec = await readDagRunSpec(parentRunDir);
-    const recovery = parentState.frontendRecoveryState;
+    let recovery = parentState.frontendRecoveryState;
+    if (options.recoveryIntent) {
+        const intent = options.recoveryIntent;
+        if (intent.parentRunId !== parentRunId ||
+            intent.requestId.length === 0 ||
+            intent.phase !== "child-staging" ||
+            intent.childRunId !== undefined ||
+            intent.revision !== 0) {
+            throw new Error("frontend recovery intent binding mismatch");
+        }
+        if (recovery?.requestId === intent.requestId) {
+            if (recovery.parentRunId !== intent.parentRunId ||
+                recovery.recoveryRootRunId !== intent.recoveryRootRunId ||
+                recovery.attemptIndex !== intent.attemptIndex ||
+                recovery.continuationCount !== intent.continuationCount ||
+                recovery.failureSource !== intent.failureSource) {
+                throw new Error("frontend recovery intent replay binding mismatch");
+            }
+        }
+        else {
+            const previousAttemptIndex = recovery?.attemptIndex ?? 0;
+            const previousContinuationCount = recovery?.continuationCount ?? 0;
+            const expectedRoot = recovery?.recoveryRootRunId ?? parentRunId;
+            if (intent.recoveryRootRunId !== expectedRoot ||
+                intent.attemptIndex !== previousAttemptIndex ||
+                intent.continuationCount !== previousContinuationCount) {
+                throw new Error("frontend recovery intent lineage mismatch");
+            }
+            recovery = structuredClone(intent);
+            await deps.writeParentState(parentRunDir, {
+                ...parentState,
+                frontendRecoveryState: recovery,
+            });
+        }
+    }
     if (!recovery) {
         throw new Error(`parent run ${parentRunId} has no frontend recovery intent`);
     }
@@ -440,17 +556,49 @@ export async function stageRecoveryChild(options) {
     if (!requestId) {
         throw new Error(`parent run ${parentRunId} recovery intent has no requestId`);
     }
+    if (options.recoveryPlan) {
+        if (options.recoveryPlan.parentRunId !== parentRunId ||
+            options.recoveryPlan.requestId !== requestId ||
+            options.recoveryPlan.failureSource !== recovery.failureSource) {
+            throw new Error("frontend recovery plan binding mismatch");
+        }
+        const expectedPlan = computeFrontendRecoveryPlanForSource({
+            spec: parentSpec,
+            parentRunId,
+            requestId,
+            failureSource: recovery.failureSource,
+        });
+        if (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");
+        }
+    }
     // Idempotent short-circuit (D4.2): reserved childRunId + activated marker +
     // existing child dir means the request was already fully committed.
     if (recovery.childRunId) {
         const existingMarker = await readFrontendRecoveryMarker(parentRunDir, requestId);
         if (existingMarker) {
-            const existingChildDir = getDagRunDir(cwd, "active", existingMarker.childRunId);
-            if (await dagRunDirExists(existingChildDir)) {
+            const existingChild = await locateDagRun(cwd, existingMarker.childRunId);
+            if (existingChild &&
+                (existingChild.lifecycle === "active" ||
+                    existingChild.lifecycle === "paused" ||
+                    existingChild.lifecycle === "completed")) {
+                await verifyThreeWayConsistency({
+                    parentRunDir,
+                    activeChildDir: existingChild.runDir,
+                    marker: existingMarker,
+                    parentRunId,
+                    requestId,
+                    recoveryRootRunId: recovery.recoveryRootRunId,
+                    childRunId: existingMarker.childRunId,
+                    deps,
+                });
                 return {
                     ok: true,
                     childRunId: existingMarker.childRunId,
-                    childRunDir: existingChildDir,
+                    childRunDir: existingChild.runDir,
                     marker: existingMarker,
                     idempotentReplay: true,
                 };
@@ -461,8 +609,13 @@ export async function stageRecoveryChild(options) {
     // buildDagRunId is deterministic for the same task title on the same day. A
     // recovery child must never reuse its still-active parent directory, or the
     // staging path aliases the parent and the required import manifest is absent.
+    // The default builder must receive `{ cwd }` (its options object), not the
+    // bare string: only the options form enables the collision-safe `-rN`
+    // suffix across active/completed/paused runs.
     const childRunId = recovery.childRunId ?? await (async () => {
-        const generatedChildRunId = await (options.buildChildRunId ?? buildDagRunId)(parentSpec, cwd);
+        const generatedChildRunId = options.buildChildRunId
+            ? await options.buildChildRunId(parentSpec, cwd)
+            : await buildDagRunId(parentSpec, { cwd });
         return generatedChildRunId === parentRunId
             ? `${generatedChildRunId}-recovery-${requestId.slice(0, 8)}`
             : generatedChildRunId;
@@ -500,6 +653,7 @@ export async function stageRecoveryChild(options) {
             parentSpec,
             parentState,
             recovery,
+            recoveryPlan: options.recoveryPlan,
             requestId,
             childRunId,
             stagingDir,

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

@@ -226,6 +226,7 @@ export function parseTargetSurfaceFacts(text) {
 }
 export const PLAN_LEDGER_FACT_KINDS = [
     "target-surface",
+    "state-registry",
     "component-choice",
     "state-flow",
     "data-flow",
@@ -484,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-typed-event-store.js

@@ -95,6 +95,8 @@ export const CONTRACT_FACT_KINDS = [
     "open-question",
     "split-proposal",
     "openspec-selection",
+    "ui-state-declaration",
+    "required-deliverables",
     "contract-finalized",
 ];
 export const CONTRACT_TERMINAL_FACT_KINDS = ["contract-finalized"];
@@ -124,6 +126,7 @@ export const PLAN_RECORD_FACT_KINDS = [
     "plan-requirement",
     "plan-verification-target",
     "plan-evidence-gap",
+    "state-registry",
 ];
 /**
  * A+B (AC-009): typed issue category shared by review and design change

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);
@@ -226,7 +248,7 @@ async function evaluateTargetFileTrace(input) {
         workspaceRoot: input.workspaceRoot,
         file: input.target.file,
     });
-    if (fileIssues.length || input.target.type === "static") {
+    if (fileIssues.length || input.target.mode === "static") {
         return { issues: fileIssues };
     }
     const absolute = path.resolve(input.workspaceRoot, input.target.file);
@@ -261,10 +283,11 @@ export async function evaluateFrontendWriterTracePreflight(input) {
         }
         targets.push({
             id: target.id,
+            commandId: target.commandId,
             commandLabel: target.commandLabel,
             file: target.file,
             ...(target.symbol ? { symbol: target.symbol } : {}),
-            ...(target.type !== "static" ? { traceKey: target.id } : {}),
+            ...(target.mode !== "static" ? { traceKey: target.id } : {}),
             status: fileTrace.issues.length ? "failed" : "ok",
             matchedNodeIds: [],
             issues: fileTrace.issues,
@@ -301,15 +324,25 @@ 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}`));
         targets.push({
             id: target.id,
+            commandId: target.commandId,
             commandLabel: target.commandLabel,
             file: target.file,
             symbol: target.symbol,
-            ...(target.type !== "static" ? { traceKey: target.id } : {}),
+            ...(target.mode !== "static" ? { traceKey: target.id } : {}),
             status,
             matchedNodeIds: owners ?? [],
             issues,
@@ -383,7 +416,7 @@ export async function runFrontendVerificationTraceGate(input) {
             .join("; ")}`);
     }
     const contract = parsed.data;
-    const requiresBehaviorVerification = contract.verificationTargets.some((target) => target.type !== "static");
+    const requiresBehaviorVerification = contract.verificationTargets.some((target) => target.mode !== "static");
     // Prefer post-repair reverify nodes when present (M3); else initial verify nodes (M2).
     const staticCandidates = [
         "frontend-static-reverify-shell",
@@ -471,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("; ")}`);