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

package/dist/executors/dag-pi-executor.js

@@ -17,9 +17,9 @@ import { redactPromptForLog, truncateOutput, } from "../shared/output-truncation
 import { GitStatusUnavailableError, pathsChangedDuringRun, readGitStatusPorcelain, recoverRootNulArtifact, snapshotGitStatusPathFingerprints, snapshotGitStatusPorcelain, validateShellWriteGuard, } from "./shell-write-guard.js";
 import { captureWorkspaceWriteSnapshot, diffWorkspaceWriteSnapshots, } from "./workspace-write-snapshot.js";
 import { pathMatchesPattern } from "../shared/git-progress.js";
-import { readTypedEventStoreFromJsonl } from "../workflows/dag/frontend-typed-event-store.js";
+import { readTypedEventStoreFromJsonl, typedEventPayloadSha256, } from "../workflows/dag/frontend-typed-event-store.js";
 import { collectCanonicalStateFlowNames, frontendEvidenceExpectationSchema, resolveFrontendContractRequirements, validateFrontendRequiredDeliverables, } from "../workflows/dag/frontend-contract-facts.js";
-import { isTargetTemplateTransientRetryNode, isWriterEmptyDiffRetryCandidate, isWriterTransportRetryCandidate, INCOMPLETE_WRITE_SET_RETRY_CATEGORY, STRUCTURED_OUTPUT_RETRY_CATEGORY, WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY, WRITER_EMPTY_DIFF_RETRY_CATEGORY, } from "../workflows/dag/retry-policy.js";
+import { isTargetTemplateTransientRetryNode, isWriterEmptyDiffRetryCandidate, isWriterTransportRetryCandidate, INCOMPLETE_WRITE_SET_RETRY_CATEGORY, OUTPUT_LIMIT_RETRY_CATEGORY, STRUCTURED_OUTPUT_RETRY_CATEGORY, WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY, WRITER_EMPTY_DIFF_RETRY_CATEGORY, } from "../workflows/dag/retry-policy.js";
 import { assessBackendTestMdPlanCompleteness, assessBackendTestMdWriterCompleteness, assessBackendTestPytestPlanCompleteness, assessBackendTestPytestWriterCompleteness, assessBackendTestShardChildCompleteness, backendTestWriterProgressRoleForTask, classifyBackendTestWriterCompletenessFailure, isBackendTestCompletenessRetryCandidate, isBackendTestMdPlanTask, isBackendTestPytestCollectionRepairOutcomeRecoveryCandidate, isBackendTestPytestPlanTask, isBackendTestShardChildTask, writeBackendTestWriterProgressArtifacts, } from "../workflows/dag/backend-test-writer-completeness.js";
 import { resolveBackendTestLayout } from "../workflows/dag/backend-test-layout.js";
 import { assessBackendTestPlanProtocol } from "../workflows/dag/backend-test-plan-protocol.js";
@@ -27,23 +27,221 @@ import { frontendTestLayoutFromSpec } from "../workflows/dag/frontend-test-layou
 import { redactSecrets, truncateUtf8Preview } from "../shared/preview.js";
 import { writeEffectiveContextReceipt } from "../workflows/dag/context-receipt.js";
 /**
- * Writer classification for a length-stopped thinking-only attempt: the model
- * exhausted its output budget thinking but never issued a write/edit tool call
- * and produced zero attributed diff. This is a terminal, non-retryable
- * diagnosis (the same prompt + model will hit the same budget wall); the
- * recommendation is a model switch plus a fresh run. It must NOT mask a
- * recoverable partial-write-set (incomplete-write-set) upgrade.
+ * Legacy diagnostic label retained for artifact compatibility. New executions
+ * classify this signal as output-limit so the node can retry incrementally.
  */
 export const WRITER_THINKING_EXHAUSTED_CATEGORY = "writer-thinking-exhausted";
 /**
- * Planner classification mirroring writer-thinking-exhausted: a read-only
- * planning session stopped on length, observed thinking, and committed zero
- * typed facts with no assistant text. By the time this survives the segmented
- * ladder the scope has already been degraded, so the durable fix is a
- * thinking-capped or non-thinking model for the tier — not another replay of
- * the same full-scope prompt.
+ * Legacy diagnostic label retained for artifact compatibility. New executions
+ * classify this signal as output-limit and preserve committed typed facts.
  */
 export const PLANNER_THINKING_EXHAUSTED_CATEGORY = "planner-thinking-exhausted";
+/**
+ * Parallel coverage shards namespace their verification target ids with
+ * `VT-SHARD-<shard>-` so the reducer can detect cross-shard conflicts. Once
+ * every shard's facts are known the namespace must be restored: the canonical
+ * contract has to carry the exact ids the task source froze (a surviving
+ * `VT-SHARD-N-…` id is a contract-requirement gap that design review
+ * rejects). Stripping happens per shard before adoption — after the strip,
+ * the existing identity-conflict check catches genuine cross-shard
+ * duplicate base ids and fails the merge closed.
+ */
+/**
+ * Deterministic pre-reduce for parallel coverage shard facts. Shards partition
+ * requirements, but a frozen verification target can legitimately be derived
+ * by several shards (one VT covers multiple ACs across shard boundaries), so
+ * same-id verification targets are MERGED: requirementIds and uiStates union,
+ * while divergent file/commandId is a real conflict. Everything else passes
+ * through unchanged.
+ */
+export function reduceParallelCoverageShardRecords(records) {
+    // Resolve replacements inside each source shard before comparing shards.
+    // A correction is an event-log operation, not a second independent target;
+    // retaining both records makes a valid same-shard correction look like a
+    // cross-shard conflict during the later reduction.
+    const byShard = new Map();
+    for (const record of records) {
+        const shard = byShard.get(record.attemptId) ?? [];
+        shard.push(record);
+        byShard.set(record.attemptId, shard);
+    }
+    const effectiveRecords = [];
+    for (const shardRecords of byShard.values()) {
+        const effective = [];
+        for (const record of shardRecords) {
+            const fact = record.fact;
+            const entry = fact?.entry;
+            const kind = typeof fact?.kind === "string" ? fact.kind : "";
+            const identity = (kind === "plan-requirement" || kind === "plan-verification-target") &&
+                typeof entry?.id === "string"
+                ? `${kind}:${entry.id}`
+                : undefined;
+            if (!identity) {
+                effective.push(record);
+                continue;
+            }
+            const replaces = typeof fact?.replaces === "string" ? `${kind}:${fact.replaces}` : undefined;
+            if (replaces) {
+                for (let index = effective.length - 1; index >= 0; index -= 1) {
+                    const prior = effective[index];
+                    const priorFact = prior.fact;
+                    const priorEntry = priorFact?.entry;
+                    const priorIdentity = typeof priorFact?.kind === "string" &&
+                        typeof priorEntry?.id === "string"
+                        ? `${priorFact.kind}:${priorEntry.id}`
+                        : undefined;
+                    if (priorIdentity === replaces)
+                        effective.splice(index, 1);
+                }
+            }
+            // Keep the source record immutable. The replacement is represented by
+            // the latest event and its own payload hash.
+            effective.push(record);
+        }
+        effectiveRecords.push(...effective);
+    }
+    const verificationTargets = new Map();
+    const merged = [];
+    for (const record of effectiveRecords) {
+        const fact = record.fact;
+        if (!fact || typeof fact !== "object")
+            continue;
+        if (fact.kind !== "plan-verification-target") {
+            merged.push(record);
+            continue;
+        }
+        const entry = fact.entry;
+        if (!entry || typeof entry.id !== "string")
+            continue;
+        const existing = verificationTargets.get(entry.id);
+        if (!existing) {
+            verificationTargets.set(entry.id, {
+                record, entry: { ...entry },
+                sources: [`${record.attemptId}:${record.eventId}:${record.payloadSha256}`],
+            });
+            continue;
+        }
+        // Never mutate the entry held by the source record. The reducer creates
+        // a new merged entry and recomputes the payload hash for that derived
+        // fact, leaving source-event replay integrity intact.
+        const baseEntry = { ...existing.entry };
+        for (const field of ["commandId", "commandLabel", "file", "scope"]) {
+            if (entry[field] !== baseEntry[field]) {
+                throw new Error(`frontend plan coverage shard reduce conflict: verification target ${entry.id} has divergent ${field} "${String(entry[field])}" vs "${String(baseEntry[field])}"`);
+            }
+        }
+        const unionSorted = (a, b) => {
+            const left = Array.isArray(a) ? a : [];
+            const right = Array.isArray(b) ? b : [];
+            return [...new Set([...left, ...right])].sort();
+        };
+        baseEntry.requirementIds = unionSorted(baseEntry.requirementIds, entry.requirementIds);
+        baseEntry.uiStates = unionSorted(baseEntry.uiStates, entry.uiStates);
+        const mergedFact = { ...fact, entry: { ...baseEntry } };
+        existing.entry = baseEntry;
+        existing.sources.push(`${record.attemptId}:${record.eventId}:${record.payloadSha256}`);
+        existing.record = {
+            ...existing.record,
+            fact: mergedFact,
+            payloadSha256: typedEventPayloadSha256(mergedFact),
+        };
+    }
+    merged.push(...[...verificationTargets.values()].map((item) => {
+        // The reducer owns every VT revision, including a one-shard partial
+        // result. Content-addressed revisions replay idempotently, while an
+        // expanded/replaced source set appends an explicit replacement rather
+        // than masquerading as a changed source event or deleting audit facts.
+        const fact = {
+            ...item.record.fact,
+            replaces: item.entry.id,
+            entry: {
+                ...item.entry,
+                requirementIds: [...new Set(planFactStringList(item.entry.requirementIds))].sort(),
+                uiStates: [...new Set(planFactStringList(item.entry.uiStates))].sort(),
+            },
+        };
+        const payloadSha256 = typedEventPayloadSha256(fact);
+        const revisionId = createHash("sha256")
+            .update(JSON.stringify({ sources: [...new Set(item.sources)].sort(), payloadSha256 }))
+            .digest("hex");
+        return {
+            ...item.record,
+            attemptId: "frontend-plan-coverage-reducer",
+            eventId: `coverage-reduced:${revisionId}`,
+            requestId: `coverage-reduced:${revisionId}`,
+            fact, payloadSha256,
+        };
+    }));
+    return merged;
+}
+export function normalizeParallelCoverageShardRecords(records, shardNumber) {
+    const prefix = `VT-SHARD-${shardNumber}-`;
+    // Models sometimes drop the `VT-` stem when applying the shard namespace
+    // (observed: frozen `VT-X` became `VT-SHARD-2-X`), so restoring the
+    // canonical id requires re-adding the stem after the strip.
+    const stripId = (id) => {
+        if (typeof id !== "string" || !id.startsWith(prefix))
+            return id;
+        const base = id.slice(prefix.length);
+        return base.startsWith("VT-") ? base : `VT-${base}`;
+    };
+    const stripIdList = (ids) => Array.isArray(ids) ? ids.map((id) => stripId(id)) : ids;
+    return records.map((record) => {
+        const fact = record.fact;
+        if (!fact || typeof fact !== "object")
+            return record;
+        const kind = fact.kind;
+        const entry = fact.entry;
+        if (!entry || typeof entry !== "object")
+            return record;
+        let rewritten;
+        const replaces = kind === "plan-verification-target" ? stripId(fact.replaces) : fact.replaces;
+        if (kind === "plan-verification-target") {
+            const id = stripId(entry.id);
+            if (id !== entry.id || replaces !== fact.replaces)
+                rewritten = { ...entry, id };
+        }
+        else if (kind === "plan-requirement") {
+            const verificationTargetIds = stripIdList(entry.verificationTargetIds);
+            if (verificationTargetIds !== entry.verificationTargetIds) {
+                rewritten = { ...entry, verificationTargetIds };
+            }
+        }
+        else if (kind === "state-flow") {
+            const rewriteBoundTargets = (item) => {
+                if (!item || typeof item !== "object")
+                    return item;
+                return {
+                    ...item,
+                    verificationTargetIds: stripIdList(item.verificationTargetIds),
+                };
+            };
+            const uiStates = Array.isArray(entry.uiStates)
+                ? entry.uiStates.map(rewriteBoundTargets)
+                : entry.uiStates;
+            const interactions = Array.isArray(entry.interactions)
+                ? entry.interactions.map(rewriteBoundTargets)
+                : entry.interactions;
+            if (uiStates !== entry.uiStates || interactions !== entry.interactions) {
+                rewritten = { ...entry, uiStates, interactions };
+            }
+        }
+        return rewritten
+            ? {
+                ...record,
+                fact: { ...fact, ...(replaces !== undefined ? { replaces } : {}), entry: rewritten },
+                // Keep the integrity hash consistent with the rewritten
+                // payload, or the adoption replay check reports the
+                // normalized record as a tampered source event.
+                payloadSha256: typedEventPayloadSha256({
+                    ...fact,
+                    ...(replaces !== undefined ? { replaces } : {}),
+                    entry: rewritten,
+                }),
+            }
+            : record;
+    });
+}
 export function isPlannerThinkingExhausted(result, committedAnyFacts) {
     if (result.ok)
         return false;
@@ -985,6 +1183,36 @@ async function resolveFrontendDeclaredUiStateIds(input) {
         return [];
     }
 }
+/**
+ * Resolve the frozen canonical behavior verification-target ids the PRD
+ * declares. The requirement text is the same authority the design review reads
+ * when it rejects `VT-SHARD-N-…` / variant ids as a contract-requirement gap,
+ * so extracting `VT-…` tokens from the frozen contract requirement facts makes
+ * that authority deterministic instead of prose-only. An empty result (no PRD
+ * declared any behavior target id) disables the canonical check and keeps the
+ * historical free-form path.
+ */
+export async function resolveFrontendCanonicalVerificationTargetIds(input) {
+    try {
+        const records = await readTypedEventStoreFromJsonl(path.join(input.runDir, "frontend-contract-pi", "contract-typed-facts.jsonl"));
+        const ids = new Set();
+        for (const record of records) {
+            const fact = record.fact;
+            if (record.phase !== "committed" || fact.kind !== "requirement") {
+                continue;
+            }
+            const text = typeof fact.text === "string" ? fact.text : "";
+            for (const match of text.matchAll(/\bVT-[A-Z0-9][A-Z0-9_-]*\b/g)) {
+                ids.add(match[0]);
+            }
+        }
+        return [...ids].sort();
+    }
+    catch {
+        // No contract facts (or unreadable): fall back to no canonical set.
+        return [];
+    }
+}
 /**
  * A+B: `frontend-plan-pi` records its decision ledger through incremental
  * `record_*` tools (origin=plan) and closes with exactly one
@@ -1717,6 +1945,15 @@ export async function createFrontendPlanLedgerTools(input) {
                     });
                 }
             }
+            if (id &&
+                activeRequirementScope.length > 0 &&
+                !activeRequirementScope.includes(id)) {
+                return planToolReceipt({
+                    ok: false,
+                    kind: "plan-requirement",
+                    error: `record_plan_requirement id "${id}" is outside this session's requirement scope [${activeRequirementScope.join(", ")}]`,
+                });
+            }
             const result = await adoptPlanFact("plan-requirement", `${attemptId}:record_plan_requirement:${randomUUID()}`, {
                 kind: "plan-requirement",
                 origin: "plan",
@@ -1729,7 +1966,11 @@ export async function createFrontendPlanLedgerTools(input) {
     const recordPlanVerificationTargetTool = defineTool({
         name: "record_plan_verification_target",
         label: "record_plan_verification_target",
-        description: "Commit one plan verification target entry (origin=plan plan-verification-target fact). Reference a frozen verification command by commandId (see the frozen command directory in your prompt: static commands are project-wide checks traced by file and command only; behavior commands need a test file whose describe/it/test title contains the target id). For behavior targets, call once per distinct behavior, not mechanically once per requirement: one target may cover multiple related requirementIds. For a correction, re-submit the same id with replace=true; the ledger compiles the latest replacement. A behavior target id is the stable trace token that implementation must place in a real describe/it/test title. Entry carries id, commandId, file, requirementIds, and uiStates; optional scope (unit | component | integration) is display-only. Free-form symbol text is not accepted. IMPORTANT: batch up to 4 record_* calls per assistant message; never batch more than 4 — a larger single message risks output truncation under a small output window. Example: {\"entry\": {\"id\": \"VT-DASHBOARD-SHELL\", \"commandId\": \"<frozen behavior command id>\", \"file\": \"<test file>\", \"requirementIds\": [\"AC-001\", \"AC-002\"], \"uiStates\": []}}",
+        description: "Commit one plan verification target entry (origin=plan plan-verification-target fact). Reference a frozen verification command by commandId (see the frozen command directory in your prompt: static commands are project-wide checks traced by file and command only; behavior commands need a test file whose describe/it/test title contains the target id). For behavior targets, call once per distinct behavior, not mechanically once per requirement: one target may cover multiple related requirementIds. For a correction, re-submit the same id with replace=true; the ledger compiles the latest replacement. A behavior target id is the stable trace token that implementation must place in a real describe/it/test title. Entry carries id, commandId, file, requirementIds, and uiStates; optional scope (unit | component | integration) is display-only. Free-form symbol text is not accepted. IMPORTANT: batch up to 4 record_* calls per assistant message; never batch more than 4 — a larger single message risks output truncation under a small output window. Example: {\"entry\": {\"id\": \"VT-DASHBOARD-SHELL\", \"commandId\": \"<frozen behavior command id>\", \"file\": \"<test file>\", \"requirementIds\": [\"AC-001\", \"AC-002\"], \"uiStates\": []}}" +
+            (input.canonicalVerificationTargetIds &&
+                input.canonicalVerificationTargetIds.length > 0
+                ? ` Frozen canonical behavior target ids (use exactly for behavior targets): ${input.canonicalVerificationTargetIds.join(", ")}.`
+                : ""),
         promptSnippet: "Commit 1-4 plan verification target entries (up to 4 per message).",
         parameters: Type.Object({
             entry: verificationTargetSchema,
@@ -1780,6 +2021,24 @@ export async function createFrontendPlanLedgerTools(input) {
                         error: `record_plan_verification_target verification-target-phase-mismatch: behavior command "${directoryEntry.label}" (${directoryEntry.commandId}) must bind a test file (__tests__/, tests?/, e2e/, cypress/, *.test.*, *.spec.*, *.cy.*); received file "${rawEntry.file}"`,
                     });
                 }
+                // Canonical-identity check for behavior targets: the PRD freezes
+                // the exact behavior verification-target ids (e.g.
+                // VT-SMOKE-COUNTER-BEHAVIOR). A committed non-canonical id is
+                // immutable and design review rejects it as a
+                // contract-requirement gap, so reject invented ids here.
+                if (directoryEntry.mode === "behavior" &&
+                    input.canonicalVerificationTargetIds &&
+                    input.canonicalVerificationTargetIds.length > 0) {
+                    const canonicalTargetId = typeof rawEntry.id === "string" ? rawEntry.id.trim() : "";
+                    if (canonicalTargetId &&
+                        !input.canonicalVerificationTargetIds.includes(canonicalTargetId)) {
+                        return planToolReceipt({
+                            ok: false,
+                            kind: "plan-verification-target",
+                            error: `record_plan_verification_target id "${canonicalTargetId}" is not a frozen canonical behavior verification target; canonical ids are: ${input.canonicalVerificationTargetIds.join(", ")}`,
+                        });
+                    }
+                }
             }
             // Duplicate-id rejection: committed typed facts are immutable, so
             // re-recording the same VT id would deadlock the compile by default.
@@ -1849,6 +2108,15 @@ export async function createFrontendPlanLedgerTools(input) {
                     : [];
             }));
             const unknownRequirementIds = stringList(rawEntry.requirementIds).filter((id) => !declaredRequirementIds.has(id));
+            const outOfScopeRequirementIds = stringList(rawEntry.requirementIds).filter((id) => activeRequirementScope.length > 0 &&
+                !activeRequirementScope.includes(id));
+            if (outOfScopeRequirementIds.length > 0) {
+                return planToolReceipt({
+                    ok: false,
+                    kind: "plan-verification-target",
+                    error: `record_plan_verification_target references requirements outside this session's scope [${activeRequirementScope.join(", ")}]: ${outOfScopeRequirementIds.join(", ")}`,
+                });
+            }
             if (unknownRequirementIds.length > 0) {
                 return planToolReceipt({
                     ok: false,
@@ -1895,6 +2163,18 @@ export async function createFrontendPlanLedgerTools(input) {
                     error: "record_plan_evidence_gap requires a non-empty description describing the gap",
                 });
             }
+            const requirementId = typeof entry.requirementId === "string"
+                ? entry.requirementId
+                : undefined;
+            if (requirementId &&
+                activeRequirementScope.length > 0 &&
+                !activeRequirementScope.includes(requirementId)) {
+                return planToolReceipt({
+                    ok: false,
+                    kind: "plan-evidence-gap",
+                    error: `record_plan_evidence_gap requirementId "${requirementId}" is outside this session's requirement scope [${activeRequirementScope.join(", ")}]`,
+                });
+            }
             const result = await adoptPlanFact("plan-evidence-gap", `${attemptId}:record_plan_evidence_gap:${randomUUID()}`, { kind: "plan-evidence-gap", origin: "plan", entry });
             return planToolReceipt(result);
         },
@@ -2088,6 +2368,66 @@ export async function createFrontendPlanLedgerTools(input) {
             adoptStagedFactTool,
             finalizePlanTool,
         ],
+        adoptCommittedFacts: async (records) => {
+            for (const record of records) {
+                if (record.phase !== "committed")
+                    continue;
+                const fact = record.fact;
+                if (!fact || typeof fact !== "object" || Array.isArray(fact))
+                    continue;
+                const kind = typeof fact.kind === "string"
+                    ? fact.kind
+                    : "plan-fact";
+                const entry = fact.entry;
+                const identity = (kind === "plan-requirement" || kind === "plan-verification-target") &&
+                    typeof entry?.id === "string"
+                    ? `${kind}:${entry.id}`
+                    : undefined;
+                const sourceShardPrefix = `${attemptId}:parallel-merge:${record.attemptId}:`;
+                const requestId = `${sourceShardPrefix}${record.eventId}`;
+                const committed = readCommittedEvents(store, attemptId);
+                const replay = committed.find((candidate) => candidate.requestId === requestId);
+                if (replay) {
+                    if (replay.payloadSha256 !== record.payloadSha256) {
+                        throw new Error(`frontend plan shard fact merge replay conflict: source event ${record.eventId} changed payload`);
+                    }
+                    continue;
+                }
+                const explicitReplacement = typeof fact.replaces === "string" &&
+                    fact.replaces === entry?.id;
+                const conflicting = committed.find((candidate) => {
+                    const candidateFact = candidate.fact;
+                    const candidateEntry = candidateFact.entry;
+                    const sameSourceShard = candidate.requestId.startsWith(sourceShardPrefix);
+                    return (candidateFact.kind === kind &&
+                        typeof candidateEntry?.id === "string" &&
+                        `${kind}:${candidateEntry.id}` === identity &&
+                        !(sameSourceShard && explicitReplacement));
+                });
+                if (conflicting) {
+                    // Two shards may honestly emit the same fact (e.g. both
+                    // derive the same frozen verification target). Identical
+                    // payloads are duplicates to skip; divergent payloads are
+                    // a real conflict the ladder must resolve.
+                    if (conflicting.payloadSha256 === record.payloadSha256) {
+                        continue;
+                    }
+                    const fromSameSourceShard = conflicting.requestId.startsWith(sourceShardPrefix);
+                    if (fromSameSourceShard) {
+                        throw new Error(`frontend plan shard fact merge conflict: ${identity} was already committed by another shard with a different payload`);
+                    }
+                    // Divergent payload from a different source attempt means a
+                    // ladder retry re-derived the coverage phase: the fresh
+                    // derivation supersedes the stored record.
+                    const storeWithRecords = store;
+                    storeWithRecords.records = storeWithRecords.records.filter((candidate) => candidate.eventId !== conflicting.eventId);
+                }
+                const result = await adoptPlanFact(kind, requestId, fact);
+                if (!result.ok) {
+                    throw new Error(`frontend plan shard fact merge failed: ${result.error}`);
+                }
+            }
+        },
         setActiveRequirementScope: (requirementIds) => {
             activeRequirementScope = [
                 ...new Set(requirementIds.filter((id) => id.trim().length > 0)),
@@ -2717,6 +3057,22 @@ export async function createFrontendScoutEvidenceTools(input) {
     });
     return {
         customTools: [recordTargetSurfaceTool, recordDesignEvidenceTool],
+        committedFacts: () => readCommittedEvents(store, attemptId),
+        adoptCommittedFacts: async (records) => {
+            for (const record of records) {
+                if (record.phase !== "committed")
+                    continue;
+                const fact = record.fact;
+                if (!fact || typeof fact !== "object" || Array.isArray(fact))
+                    continue;
+                const result = await adoptScoutFact(typeof fact.kind === "string"
+                    ? fact.kind
+                    : "scout-fact", fact);
+                if (!result.ok) {
+                    throw new Error(`frontend scout shard fact merge failed: ${result.error}`);
+                }
+            }
+        },
         flush: async () => {
             const committed = readCommittedEvents(store, attemptId);
             await writeTypedEventStoreJsonl(path.join(input.runDir, input.nodeId, "scout-typed-facts.jsonl"), committed);
@@ -3109,6 +3465,7 @@ const FRONTEND_PLAN_SEGMENTS = [
         instruction: [
             "PLAN PHASE — requirement coverage only.",
             "Your ONLY job: for every frozen requirement, emit record_plan_requirement (requirement → implementation files) and record_plan_verification_target facts (verification target bound to requirement ids and files). Group related requirements under one non-static behavior target when one observable test behavior proves them together; do not mechanically create one target per requirement. A non-static target id is the stable machine trace token; never submit prose as a symbol. Do NOT record components, UI states, mock, dependency, or routes — a follow-up session owns those.",
+            "A coverage session is complete only when EVERY requirement assigned to this session (the full inventory, or the exact COVERAGE BATCH / shard list when present) has committed coverage facts: a record_plan_requirement entry plus verification targets, or a committed evidence gap. Keep committing in batches of up to 4 record_* calls per assistant message until then; do not write a concluding summary while any assigned requirement is still uncommitted — an early stop strands the remainder into a MISSING-FACT repair session and doubles the sessions needed.",
             "If a requirement genuinely cannot have a verification target, record a non-empty record_plan_evidence_gap. Do not call finalize_plan; it is not available in this phase.",
         ].join(" "),
     },
@@ -3126,11 +3483,12 @@ const FRONTEND_PLAN_SEGMENTS = [
         toolNames: new Set([
             "record_component_choice",
             "record_state_flow",
+            "record_plan_verification_target",
             "adopt_staged_fact",
         ]),
         instruction: [
             "PLAN PHASE — global UX decisions.",
-            "Requirements and verification targets are already committed in the ledger (do NOT re-record them; duplicates are rejected). Review the complete requirement set and the committed global UX registry together, then record each component choice, UI state and interaction exactly once. Multiple requirements that describe one behavior share one registry name and one state-flow entry; never repeat or rename it per AC. Cross-cutting data flow belongs to the global Mock/data phase. Do not record routes, Mock/API policy, dependencies, or design deviations here.",
+            "Requirements and verification targets are already committed in the ledger. Review the complete requirement set and the committed global UX registry together, then record each component choice, UI state and interaction. Bind each applicable state to its verificationTargetIds; the runtime derives the reverse VT.uiStates relation. If a VT requires correction, record_plan_verification_target with replace:true is available after declaring its states; preserve its requirement coverage. Multiple requirements describing one behavior share one registry name and state-flow entry. Cross-cutting data flow belongs to the global Mock/data phase. Do not record routes, Mock/API policy, dependencies, or design deviations here.",
             "Do not call finalize_plan; it is not available in this phase.",
         ].join(" "),
     },
@@ -3374,12 +3732,28 @@ export function batchFrontendPlanRequirements(input) {
     return batches;
 }
 const FRONTEND_PLAN_COVERAGE_MAX_RECORD_CALLS = 10;
-// A large requirement set creates coverage shards; UX remains one global
-// decision session so behavior names and component/state facts are not
-// reinvented per AC batch. Keep a safety bound for adaptive coverage retries.
+const FRONTEND_PLAN_COVERAGE_MAX_CONCURRENCY = 4;
+// A large requirement set creates parallel coverage shards; UX remains one
+// global decision session so behavior names and component/state facts are not
+// reinvented per AC batch. Keep a safety bound for adaptive coverage retries
+// without letting the old 32-session ceiling skip finalize.
 const FRONTEND_PLAN_BATCH_MAX_SESSIONS = 128;
 const FRONTEND_PLAN_SMALL_MAX_REQUIREMENTS = 8;
 const FRONTEND_PLAN_SMALL_MAX_ESTIMATED_CALLS = 24;
+async function mapWithConcurrency(items, limit, worker) {
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    const workerCount = Math.min(Math.max(1, limit), items.length);
+    await Promise.all(Array.from({ length: workerCount }, async () => {
+        while (true) {
+            const index = nextIndex++;
+            if (index >= items.length)
+                return;
+            results[index] = await worker(items[index], index);
+        }
+    }));
+    return results;
+}
 function compactPromptString(value, maxChars) {
     if (typeof value !== "string" || value.trim().length === 0)
         return undefined;
@@ -3827,7 +4201,7 @@ export async function runFrontendPlanSegmentedSessions(input) {
     const buildCoveragePrompt = (slice, missing = []) => [
         compactFrontendPlanPromptForRequirementSlice(input.basePrompt, slice),
         coverageSegment.instruction,
-        `COVERAGE BATCH: process ONLY these requirements in this session: ${slice.join(", ")}. Other requirements are handled by separate sessions; do not record them.`,
+        `COVERAGE BATCH: process ONLY these requirements in this session: ${slice.join(", ")}. Other requirements are handled by separate sessions; do not record them. Finish the whole list before concluding: commit every listed requirement's coverage facts (verification targets or an evidence gap), batching up to 4 record_* calls per message; an early stop re-queues the remainder as a MISSING-FACT repair session.`,
         ...(missing.length > 0
             ? [
                 "MISSING-FACT QUEUE: the previous session did not establish complete coverage. Repair ONLY these items, then re-check the slice:",
@@ -3927,8 +4301,8 @@ export async function runFrontendPlanSegmentedSessions(input) {
     const mapPlannerExhaustion = (r, committedAnyFacts) => isPlannerThinkingExhausted(r, committedAnyFacts)
         ? {
             ...r,
-            failureCategory: PLANNER_THINKING_EXHAUSTED_CATEGORY,
-            stderr: `${r.stderr}\n${PLANNER_THINKING_EXHAUSTED_CATEGORY}: stopReason=length, thinking observed, 0 typed facts committed; the batch ladder degraded the scope without converging — set thinking=off for this tier or switch to a non-thinking model`.trim(),
+            failureCategory: OUTPUT_LIMIT_RETRY_CATEGORY,
+            stderr: `${r.stderr}\n${OUTPUT_LIMIT_RETRY_CATEGORY}: stopReason=length ended the turn before the next typed fact; preserve committed facts and retry only the unfinished phase`.trim(),
         }
         : r;
     // An empty list means "ledger unreadable / unknown" and falls back to one
@@ -3943,6 +4317,29 @@ export async function runFrontendPlanSegmentedSessions(input) {
         : [];
     const incompleteRequirementIds = new Set(initialMissing.flatMap((item) => item.requirementIds));
     const coverageWorkIds = (input.requirementIds ?? []).filter((id) => pending.includes(id) || incompleteRequirementIds.has(id));
+    if (input.parallelCoverageOnly === true &&
+        requirementIdsProvided &&
+        coverageWorkIds.length === 0) {
+        // A retry may reopen a shard whose committed facts are already complete.
+        // Treat that shard as an idempotent no-op; returning the normal empty
+        // session failure would make a partially failed map impossible to resume.
+        return {
+            ok: true,
+            assistantText: "",
+            command: [],
+            durationMs: 0,
+            exitCode: 0,
+            failureCategory: "success",
+            modelDisplay: "reused-coverage-facts",
+            parsedEvents: 0,
+            stderr: "",
+            stdout: "",
+            timedOut: false,
+            attemptedModels: [],
+            fallbackUsed: false,
+            tokensUsed: 0,
+        };
+    }
     const estimatedCalls = (input.requirementIds ?? []).reduce((total, id) => total + Math.max(1, input.requirementCosts?.get(id) ?? 2), 0);
     const targetSurfaceCount = countFrontendPlanTargetSurfaces(input.basePrompt);
     // Small, single-surface requests do not benefit from six isolated Pi
@@ -4004,7 +4401,7 @@ export async function runFrontendPlanSegmentedSessions(input) {
     if (useCompactSmallPlan) {
         // Compact mode already queued both sessions above.
     }
-    else {
+    else if (!input.parallelCoverageOnly) {
         if (requirementIdsProvided) {
             queue.push({
                 id: uxRegistrySegment.id,
@@ -4041,7 +4438,7 @@ export async function runFrontendPlanSegmentedSessions(input) {
             prompt: buildPhasePrompt(finalizeSegment),
         });
     }
-    let last;
+    let accumulated;
     let index = 0;
     let invocationCount = 0;
     while (index < queue.length) {
@@ -4092,8 +4489,10 @@ export async function runFrontendPlanSegmentedSessions(input) {
             }
         }
         const committedBefore = input.committedFactCount();
-        input.setActiveRequirementScope?.(session.id === "compact-local" || session.id.startsWith("ux-local-")
-            ? session.requirementSlice ?? []
+        input.setActiveRequirementScope?.(session.coverageOnly ||
+            session.id === "compact-local" ||
+            session.id.startsWith("ux-local-")
+            ? session.coverageSlice ?? session.requirementSlice ?? []
             : []);
         if (invocationCount >= FRONTEND_PLAN_BATCH_MAX_SESSIONS)
             break;
@@ -4111,7 +4510,9 @@ export async function runFrontendPlanSegmentedSessions(input) {
                 }
                 : {}),
         });
-        last = result;
+        accumulated = accumulated
+            ? combineSequentialPiResults(accumulated, result)
+            : result;
         try {
             await input.flushLedger();
         }
@@ -4220,9 +4621,9 @@ export async function runFrontendPlanSegmentedSessions(input) {
                 continue;
             }
             return {
-                ...result,
+                ...accumulated,
                 ok: false,
-                stderr: `${result.stderr}\nfrontend plan completeness check failed: ${missingPhaseFacts.map((item) => item.reason).join("; ")}`.trim(),
+                stderr: `${accumulated.stderr}\nfrontend plan completeness check failed: ${missingPhaseFacts.map((item) => item.reason).join("; ")}`.trim(),
                 failureCategory: "invalid-output",
             };
         }
@@ -4239,9 +4640,9 @@ export async function runFrontendPlanSegmentedSessions(input) {
             }
             if (missingPhaseFacts.length > 0) {
                 return {
-                    ...result,
+                    ...accumulated,
                     ok: false,
-                    stderr: `frontend plan completeness check failed: ${missingPhaseFacts.map((item) => item.reason).join("; ")}`,
+                    stderr: `${accumulated.stderr}\nfrontend plan completeness check failed: ${missingPhaseFacts.map((item) => item.reason).join("; ")}`.trim(),
                     failureCategory: "invalid-output",
                 };
             }
@@ -4332,11 +4733,11 @@ export async function runFrontendPlanSegmentedSessions(input) {
             };
             continue;
         }
-        return mapPlannerExhaustion(result, committedAfter > committedBefore);
+        return mapPlannerExhaustion(accumulated, committedAfter > committedBefore);
     }
     if (index < queue.length) {
         return {
-            ...(last ?? {
+            ...(accumulated ?? {
                 ok: false,
                 stdout: "",
                 stderr: "",
@@ -4353,11 +4754,11 @@ export async function runFrontendPlanSegmentedSessions(input) {
                 tokensUsed: 0,
             }),
             ok: false,
-            stderr: `${last?.stderr ?? ""}\nfrontend plan segmentation exceeded the ${FRONTEND_PLAN_BATCH_MAX_SESSIONS}-session safety limit before finalize`.trim(),
+            stderr: `${accumulated?.stderr ?? ""}\nfrontend plan segmentation exceeded the ${FRONTEND_PLAN_BATCH_MAX_SESSIONS}-session safety limit before finalize`.trim(),
             failureCategory: "invalid-output",
         };
     }
-    return mapPlannerExhaustion(last ?? {
+    return mapPlannerExhaustion(accumulated ?? {
         ok: false,
         stdout: "",
         stderr: "frontend plan segmentation produced no session",
@@ -4365,6 +4766,184 @@ export async function runFrontendPlanSegmentedSessions(input) {
         durationMs: 0,
     }, false);
 }
+/**
+ * Run the two independent Scout evidence surfaces concurrently while keeping
+ * their typed-event stores isolated. The main Scout store is the only store
+ * visible to Plan; shard facts are merged in completion-order-independent
+ * order after both sessions settle. This gives discovery real parallelism
+ * without allowing sibling models to race a shared revision counter.
+ */
+function aggregateParallelPiResults(results) {
+    const first = results[0];
+    const failed = results.find((result) => !result.ok);
+    const representative = failed ?? first;
+    return {
+        ...representative,
+        ok: failed === undefined,
+        failureCategory: failed?.failureCategory ?? "success",
+        durationMs: Math.max(...results.map((result) => result.durationMs), 0),
+        exitCode: failed ? failed.exitCode : 0,
+        stderr: results.map((result) => result.stderr).filter(Boolean).join("\n"),
+        tokensUsed: results.reduce((total, result) => total + result.tokensUsed, 0),
+        parsedEvents: results.reduce((total, result) => total + result.parsedEvents, 0),
+        attemptedModels: [
+            ...new Set(results.flatMap((result) => result.attemptedModels)),
+        ],
+        fallbackUsed: results.some((result) => result.fallbackUsed),
+        timedOut: results.some((result) => result.timedOut),
+    };
+}
+function combineSequentialPiResults(first, second) {
+    return {
+        ...second,
+        durationMs: first.durationMs + second.durationMs,
+        stderr: [first.stderr, second.stderr].filter(Boolean).join("\n"),
+        tokensUsed: first.tokensUsed + second.tokensUsed,
+        parsedEvents: first.parsedEvents + second.parsedEvents,
+        attemptedModels: [
+            ...new Set([...first.attemptedModels, ...second.attemptedModels]),
+        ],
+        fallbackUsed: first.fallbackUsed || second.fallbackUsed,
+        timedOut: first.timedOut || second.timedOut,
+    };
+}
+async function runFrontendScoutParallelSessions(input) {
+    const [{ createTypedEventStore }] = await Promise.all([
+        import("../workflows/dag/frontend-typed-event-store.js"),
+    ]);
+    const shards = [
+        {
+            id: "surface",
+            toolName: "record_target_surface",
+            instruction: [
+                "PARALLEL SCOUT SHARD — target surface only.",
+                "Inspect routes, entrypoints, implementation ownership, data source, and applicable test paths.",
+                "Call record_target_surface exactly once with the complete runtime-evidenced surface. Do not call record_design_evidence.",
+            ].join(" "),
+        },
+        {
+            id: "design",
+            toolName: "record_design_evidence",
+            instruction: [
+                "PARALLEL SCOUT SHARD — design evidence only.",
+                "Inspect the frontend framework, styling/theme conventions, reusable components, and relevant design/spec files.",
+                "Call record_design_evidence for the evidence you actually read. Do not call record_target_surface.",
+            ].join(" "),
+        },
+    ];
+    const outcomes = await Promise.all(shards.map(async (shard) => {
+        let shardTools;
+        let shardResult;
+        try {
+            const store = createTypedEventStore();
+            const shardNodeId = `${input.nodeId}/parallel/${shard.id}`;
+            shardTools = await createFrontendScoutEvidenceTools({
+                attemptId: `${input.attemptId}:parallel:${shard.id}`,
+                store,
+                runDir: input.runDir,
+                nodeId: shardNodeId,
+                workspaceRoot: input.workspaceRoot,
+                sourceDeclaredPaths: input.sourceDeclaredPaths,
+            });
+            const customTools = shardTools.customTools.filter((tool) => typeof tool === "object" &&
+                tool !== null &&
+                tool.name === shard.toolName);
+            const sessionOptions = {
+                ...input.sessionOptions,
+                sessionEventsPath: path.join(input.runDir, shardNodeId, "session-events.jsonl"),
+            };
+            shardResult = await input.piStepFn({
+                ...sessionOptions,
+                prompt: `${input.basePrompt}\n\n${shard.instruction}`,
+                writerToolPolicy: {
+                    requireSdk: true,
+                    customTools: [...customTools, ...(input.readBudgetTools ?? [])],
+                },
+            });
+            await shardTools.flush();
+            return { shard, result: shardResult, tools: shardTools };
+        }
+        catch (error) {
+            const crashMessage = `frontend scout parallel shard ${shard.id} crashed: ${error instanceof Error ? error.message : String(error)}`;
+            return {
+                shard,
+                tools: shardTools,
+                result: shardResult
+                    ? {
+                        ...shardResult,
+                        ok: false,
+                        failureCategory: shardResult.ok
+                            ? "invalid-output"
+                            : shardResult.failureCategory,
+                        stderr: [shardResult.stderr, crashMessage]
+                            .filter(Boolean)
+                            .join("\n"),
+                    }
+                    : {
+                        ok: false,
+                        assistantText: "",
+                        command: [],
+                        durationMs: 0,
+                        exitCode: null,
+                        failureCategory: "tool-policy",
+                        modelDisplay: "unknown",
+                        parsedEvents: 0,
+                        stderr: crashMessage,
+                        stdout: "",
+                        timedOut: false,
+                        attemptedModels: [],
+                        fallbackUsed: false,
+                        tokensUsed: 0,
+                    },
+            };
+        }
+    }));
+    const ordered = [...outcomes].sort((left, right) => left.shard.id.localeCompare(right.shard.id));
+    try {
+        for (const outcome of ordered) {
+            if (outcome.result.ok && outcome.tools) {
+                await input.mainTools.adoptCommittedFacts(outcome.tools.committedFacts());
+            }
+        }
+    }
+    catch (error) {
+        const aggregate = aggregateParallelPiResults(ordered.map((outcome) => outcome.result));
+        return {
+            ...aggregate,
+            ok: false,
+            failureCategory: "invalid-output",
+            stderr: [
+                aggregate.stderr,
+                `frontend scout parallel fact merge failed: ${error instanceof Error ? error.message : String(error)}`,
+            ]
+                .filter(Boolean)
+                .join("\n"),
+        };
+    }
+    const failed = ordered.find((outcome) => !outcome.result.ok);
+    if (failed) {
+        const aggregate = aggregateParallelPiResults(ordered.map((outcome) => outcome.result));
+        return {
+            ...aggregate,
+            ok: false,
+            stderr: `${aggregate.stderr}\nfrontend scout parallel shard failed: ${failed.shard.id}`.trim(),
+        };
+    }
+    const committedKinds = new Set(ordered.flatMap((outcome) => (outcome.tools?.committedFacts() ?? [])
+        .map((record) => record.fact?.kind)
+        .filter((kind) => typeof kind === "string")));
+    const missing = ["target-surface", "design-evidence"].filter((kind) => !committedKinds.has(kind));
+    if (missing.length > 0) {
+        const fallback = aggregateParallelPiResults(ordered.map((outcome) => outcome.result));
+        return {
+            ...fallback,
+            ok: false,
+            failureCategory: "invalid-output",
+            stderr: `${fallback.stderr}\nfrontend scout parallel shards committed no ${missing.join(" or ")} fact`.trim(),
+        };
+    }
+    return aggregateParallelPiResults(ordered.map((outcome) => outcome.result));
+}
 export async function executeDagPiNode(input, meta, piStepFn = executePiStep, writeGuardDependencies = DEFAULT_DAG_PI_WRITE_GUARD_DEPENDENCIES) {
     const started = Date.now();
     const persona = resolveDagPiPersona(input.task);
@@ -4459,6 +5038,7 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
     let planLedgerTools;
     let contractTools;
     let scoutEvidenceTools;
+    let scoutSourceDeclaredPaths;
     let readBudgetTools;
     const commandPolicy = resolveDagCommandPolicy(input.task.commandPolicy);
     const allowsPlaywrightCli = dagCommandPolicyAllows(input.task.commandPolicy, "playwright-cli");
@@ -4626,16 +5206,17 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
         try {
             const { createTypedEventStore } = await import("../workflows/dag/frontend-typed-event-store.js");
             const store = createTypedEventStore();
+            scoutSourceDeclaredPaths = await resolveFrontendScoutSourceDeclaredPaths({
+                cwd: input.cwd,
+                spec: meta.spec,
+            });
             scoutEvidenceTools = await createFrontendScoutEvidenceTools({
                 attemptId: `${meta.runId}:${input.task.id}`,
                 store,
                 runDir: meta.runDir,
                 nodeId: input.task.id,
                 workspaceRoot: input.cwd,
-                sourceDeclaredPaths: await resolveFrontendScoutSourceDeclaredPaths({
-                    cwd: input.cwd,
-                    spec: meta.spec,
-                }),
+                sourceDeclaredPaths: scoutSourceDeclaredPaths,
             });
             writerToolPolicy = {
                 requireSdk: true,
@@ -4671,6 +5252,9 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
                 declaredUiStateIds: await resolveFrontendDeclaredUiStateIds({
                     runDir: meta.runDir,
                 }),
+                canonicalVerificationTargetIds: await resolveFrontendCanonicalVerificationTargetIds({
+                    runDir: meta.runDir,
+                }),
                 workspaceRoot: input.cwd,
             });
             writerToolPolicy = {
@@ -4811,11 +5395,27 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
                 }
                 : undefined,
         };
-        if (isFrontendPlanLedgerNode(input.task) && planLedgerTools) {
-            // Frontend-only split: sequential sessions with independent
-            // output budgets (coverage -> UX decisions -> finalize), mirroring the
-            // backend-test template's module sharding. Every other template keeps
-            // the single-session path below.
+        if (isFrontendScoutEvidenceNode(input.task) &&
+            scoutEvidenceTools &&
+            input.task.complexity !== "LOW") {
+            result = await runFrontendScoutParallelSessions({
+                piStepFn,
+                sessionOptions: piSessionOptions,
+                basePrompt: input.prompt,
+                mainTools: scoutEvidenceTools,
+                runDir: meta.runDir,
+                nodeId: input.task.id,
+                attemptId: `${meta.runId}:${input.task.id}`,
+                workspaceRoot: input.cwd,
+                sourceDeclaredPaths: scoutSourceDeclaredPaths,
+                readBudgetTools: readBudgetTools?.customTools,
+            });
+        }
+        else if (isFrontendPlanLedgerNode(input.task) && planLedgerTools) {
+            // Frontend-only split: independent coverage map sessions feed a single
+            // reducer (UX decisions -> global policy -> finalize), mirroring the
+            // backend-test template's module sharding. Small plans normally have one
+            // coverage batch and retain the compact path below.
             let planRequirementIds = [];
             const planRequirementCosts = new Map();
             const behaviorRequiredRequirementIds = [];
@@ -4842,26 +5442,189 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
             catch {
                 // Unreadable ledger falls back to a single coverage session.
             }
-            result = await runFrontendPlanSegmentedSessions({
+            // Independent requirement-coverage batches are map workers. Each worker
+            // owns an isolated typed-event store; only after all workers settle do we
+            // merge facts into the main Plan ledger and run the single UX/global/
+            // finalize reducer. This avoids revision races while shortening the
+            // longest coverage phase for large plans.
+            const runPlanSessions = (options) => runFrontendPlanSegmentedSessions({
                 piStepFn,
-                sessionOptions: piSessionOptions,
-                basePrompt: input.prompt,
+                sessionOptions: options.sessionOptions,
+                basePrompt: options.basePrompt ?? input.prompt,
                 attempt: input.attempt ?? 1,
-                committedFactCount: () => planLedgerTools.committedFactCount(),
-                requirementIds: planRequirementIds,
+                committedFactCount: () => options.ledgerTools.committedFactCount(),
+                requirementIds: options.requirementIds ?? planRequirementIds,
                 requirementCosts: planRequirementCosts,
-                compactSmallPlan: true,
-                committedRequirementIds: () => planLedgerTools.committedRequirementIds(),
-                committedFacts: () => planLedgerTools.committedFacts(),
+                ...(options.parallelCoverageOnly !== undefined
+                    ? { parallelCoverageOnly: options.parallelCoverageOnly }
+                    : {}),
+                ...(options.compactSmallPlan !== undefined
+                    ? { compactSmallPlan: options.compactSmallPlan }
+                    : {}),
+                committedRequirementIds: () => options.ledgerTools.committedRequirementIds(),
+                committedFacts: () => options.ledgerTools.committedFacts(),
                 behaviorRequiredRequirementIds,
-                setActiveRequirementScope: (requirementIds) => planLedgerTools.setActiveRequirementScope(requirementIds),
+                setActiveRequirementScope: (requirementIds) => options.ledgerTools.setActiveRequirementScope(requirementIds),
                 segmentCustomTools: (toolNames) => toolNames === null
-                    ? planLedgerTools.customTools
-                    : planLedgerTools.customTools.filter((tool) => typeof tool === "object" &&
+                    ? options.ledgerTools.customTools
+                    : options.ledgerTools.customTools.filter((tool) => typeof tool === "object" &&
                         tool !== null &&
                         toolNames.has(tool.name)),
-                flushLedger: () => planLedgerTools.flush(),
+                flushLedger: () => options.ledgerTools.flush(),
             });
+            if (planRequirementIds.length > 1) {
+                const estimatedPlanCalls = planRequirementIds.reduce((total, id) => total + Math.max(1, planRequirementCosts.get(id) ?? 2), 0);
+                const compactEligibleBeforeSharding = planRequirementIds.length <= FRONTEND_PLAN_SMALL_MAX_REQUIREMENTS &&
+                    estimatedPlanCalls > 12 &&
+                    estimatedPlanCalls <= FRONTEND_PLAN_SMALL_MAX_ESTIMATED_CALLS &&
+                    countFrontendPlanTargetSurfaces(input.prompt) === 1;
+                if (compactEligibleBeforeSharding) {
+                    // Decide the small-plan topology before creating coverage shards.
+                    // Sharding first would make the compact two-session path unreachable.
+                    result = await runPlanSessions({
+                        ledgerTools: planLedgerTools,
+                        sessionOptions: piSessionOptions,
+                        compactSmallPlan: true,
+                    });
+                }
+                else {
+                    const coverageBatches = batchFrontendPlanRequirements({
+                        requirementIds: planRequirementIds,
+                        maxEstimatedRecordCalls: FRONTEND_PLAN_COVERAGE_MAX_RECORD_CALLS,
+                        maxRequirements: 4,
+                        requirementCosts: planRequirementCosts,
+                    });
+                    if (coverageBatches.length > 1) {
+                        const shardResults = await mapWithConcurrency(coverageBatches, FRONTEND_PLAN_COVERAGE_MAX_CONCURRENCY, async (slice, index) => {
+                            let shardTools;
+                            let shardResult;
+                            try {
+                                const { createTypedEventStore } = await import("../workflows/dag/frontend-typed-event-store.js");
+                                shardTools = await createFrontendPlanLedgerTools({
+                                    attemptId: `${meta.runId}:${input.task.id}:parallel:${index + 1}`,
+                                    store: createTypedEventStore(),
+                                    runDir: meta.runDir,
+                                    nodeId: `${input.task.id}/parallel/coverage-${index + 1}`,
+                                    skeleton: input.task.structuredContractOutput?.skeleton,
+                                    sourceBinding: meta.spec.sourceBinding,
+                                    requirementIds: slice,
+                                    writeSetPatterns: input.task.writeSet,
+                                    canonicalVerificationTargetIds: await resolveFrontendCanonicalVerificationTargetIds({
+                                        runDir: meta.runDir,
+                                    }),
+                                    componentNewSourceReferences: await resolveFrontendPlanNewComponentSourceReferences({
+                                        cwd: input.cwd,
+                                        sourceBinding: meta.spec.sourceBinding,
+                                    }),
+                                });
+                                const shardSessionOptions = {
+                                    ...piSessionOptions,
+                                    sessionEventsPath: path.join(meta.runDir, input.task.id, "parallel", `coverage-${index + 1}`, "session-events.jsonl"),
+                                };
+                                shardResult = await runPlanSessions({
+                                    ledgerTools: shardTools,
+                                    sessionOptions: shardSessionOptions,
+                                    requirementIds: slice,
+                                    basePrompt: `${input.prompt}\n\nPARALLEL COVERAGE SHARD ${index + 1}: use the frozen canonical behavior verification-target ids listed in the record_plan_verification_target tool description — do not prefix ids with a shard namespace or invent variant ids; identical cross-shard targets are deduped, divergent ones fail the merge.`,
+                                    parallelCoverageOnly: true,
+                                });
+                                await shardTools.flush();
+                                return { index, result: shardResult, tools: shardTools };
+                            }
+                            catch (error) {
+                                const crashMessage = `frontend plan coverage shard ${index + 1} crashed: ${error instanceof Error ? error.message : String(error)}`;
+                                return {
+                                    index,
+                                    tools: shardTools,
+                                    result: shardResult
+                                        ? {
+                                            ...shardResult,
+                                            ok: false,
+                                            failureCategory: shardResult.ok
+                                                ? "invalid-output"
+                                                : shardResult.failureCategory,
+                                            stderr: [shardResult.stderr, crashMessage]
+                                                .filter(Boolean)
+                                                .join("\n"),
+                                        }
+                                        : {
+                                            ok: false,
+                                            assistantText: "",
+                                            command: [],
+                                            durationMs: 0,
+                                            exitCode: null,
+                                            failureCategory: "tool-policy",
+                                            modelDisplay: "unknown",
+                                            parsedEvents: 0,
+                                            stderr: crashMessage,
+                                            stdout: "",
+                                            timedOut: false,
+                                            attemptedModels: [],
+                                            fallbackUsed: false,
+                                            tokensUsed: 0,
+                                        },
+                                };
+                            }
+                        });
+                        const coverageResult = aggregateParallelPiResults(shardResults.map((shard) => shard.result));
+                        let mergeFailure;
+                        try {
+                            // Flatten every shard's facts FIRST, then pre-reduce: shards
+                            // partition requirements but a frozen verification target can
+                            // span shards, so same-id targets must merge across shards
+                            // before adoption, not per shard.
+                            await planLedgerTools.adoptCommittedFacts(reduceParallelCoverageShardRecords(shardResults
+                                .filter((item) => item.result.ok && item.tools)
+                                .flatMap((shard) => normalizeParallelCoverageShardRecords(shard.tools.committedFacts(), shard.index + 1))));
+                        }
+                        catch (error) {
+                            mergeFailure = error;
+                        }
+                        const failedShard = shardResults.find((shard) => !shard.result.ok);
+                        if (mergeFailure) {
+                            result = {
+                                ...coverageResult,
+                                ok: false,
+                                failureCategory: "invalid-output",
+                                stderr: [
+                                    coverageResult.stderr,
+                                    `frontend plan coverage shard merge failed: ${mergeFailure instanceof Error ? mergeFailure.message : String(mergeFailure)}`,
+                                ]
+                                    .filter(Boolean)
+                                    .join("\n"),
+                            };
+                        }
+                        else if (failedShard) {
+                            result = {
+                                ...coverageResult,
+                                ok: false,
+                                stderr: `${coverageResult.stderr}\nfrontend plan coverage shard ${failedShard.index + 1} failed before reduce`.trim(),
+                            };
+                        }
+                        else {
+                            const reducerResult = await runPlanSessions({
+                                ledgerTools: planLedgerTools,
+                                sessionOptions: piSessionOptions,
+                            });
+                            result = combineSequentialPiResults(coverageResult, reducerResult);
+                        }
+                    }
+                    else {
+                        result = await runPlanSessions({
+                            ledgerTools: planLedgerTools,
+                            sessionOptions: piSessionOptions,
+                            compactSmallPlan: true,
+                        });
+                    }
+                }
+            }
+            else {
+                result = await runPlanSessions({
+                    ledgerTools: planLedgerTools,
+                    sessionOptions: piSessionOptions,
+                    compactSmallPlan: true,
+                });
+            }
         }
         else {
             result = await piStepFn({
@@ -5408,7 +6171,7 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
                 runDir: meta.runDir,
                 progress,
                 attempt: input.attempt ?? 1,
-                maxAttempts: input.task.retryPolicy?.maxAttempts ?? 3,
+                maxAttempts: input.task.retryPolicy?.maxAttempts ?? 5,
             });
             if (progress.status !== "PASS") {
                 const classified = classifyBackendTestWriterCompletenessFailure(progress);
@@ -5458,7 +6221,7 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
         stderrParts.push(completenessFailure.detail);
     }
     if (writerThinkingExhausted) {
-        stderrParts.push(`${WRITER_THINKING_EXHAUSTED_CATEGORY}: stopReason=length, thinking observed, 0 write tool calls, 0 attributed diff; recommend a model switch and a new run`);
+        stderrParts.push(`${OUTPUT_LIMIT_RETRY_CATEGORY}: stopReason=length ended the turn before any write tool call; retry from the existing workspace and complete only unfinished targets`);
     }
     if (meta.writeGuardAttribution === "best-effort") {
         stderrParts.push("write guard note: concurrent rank writers use best-effort per-node attribution; keep same-rank writeSet entries disjoint");
@@ -5531,14 +6294,11 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
                         rawFailureCategory === "context-overflow" &&
                             (changeManifestChangedFiles?.length ?? 0) > 0
                             ? "partial-success-with-context-overflow"
-                            : // writer-thinking-exhausted: a length-stopped thinking-only attempt with
-                                // zero write tool calls and zero attributed diff is terminal and
-                                // non-retryable; recommend a model switch + fresh run. Only applies on
-                                // the empty-output base category so provider/transport failures keep
-                                // their original category, and only when the completeness gate did not
-                                // upgrade to incomplete-write-set above.
+                            : // output-limit: a length-stopped attempt is capacity truncation, not
+                                // empty output. Preserve the raw category for diagnostics and let the
+                                // node retry from committed facts/current workspace state.
                                 writerThinkingExhausted
-                                    ? WRITER_THINKING_EXHAUSTED_CATEGORY
+                                    ? OUTPUT_LIMIT_RETRY_CATEGORY
                                     : writerCleanTimeout
                                         ? WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY
                                         : // writer-budget-exhausted: the provider session consumed an