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

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

@@ -1,20 +1,17 @@
-import { classifyFrontendPlanRecovery } from "../workflows/dag/frontend-plan-recovery-policy.js";
 import { collectFrontendExecutionGroups } from "../workflows/dag/frontend-execution-groups.js";
-import { FRONTEND_SCOPE_TARGET_BYTES, packFrontendInputUnits, parseFrontendInputBlock, projectFrontendContractPrompt, projectFrontendInputScope } from "../workflows/dag/frontend-input-projection.js";
+import { FRONTEND_SCOPE_TARGET_BYTES, parseFrontendInputBlock } from "../workflows/dag/frontend-input-projection.js";
 import { createDurableFrontendTools } from "../workflows/dag/frontend-durable-tools.js";
 import { sha256OfCanonicalJson } from "../task/contract/hash.js";
-import { z } from "zod";
 import { loadFrontendReviewScopes } from "../workflows/dag/frontend-review-scopes.js";
 import { observeFrontendFinalization, observeFrontendSession } from "../workflows/dag/frontend-session-budget.js";
 import path from "node:path";
 import { createHash } from "node:crypto";
-import { readFile, stat } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import { writeDagNodeJsonArtifact, writeTextArtifactFile, } from "../infrastructure/harness/artifact-store.js";
 import { executePiStep, resolvePiBackend, } from "./pi-executor.js";
 import { resolveDagPiExtensions, } from "./pi-extension-resolver.js";
 import { buildPiWriterToolPolicyContext, createPiReaderCustomTools, createPiWriterCustomTools, } from "./pi-writer-tool-policy.js";
 import { resolveDagPiModelConfig } from "./dag-pi/model-config.js";
-import { isRecordObject } from "./dag-pi/guards.js";
 import { createFrontendReviewTerminalTools } from "./dag-pi/tools/review-terminal-tools.js";
 import { createFrontendDesignTerminalTools } from "./dag-pi/tools/design-terminal-tools.js";
 import { createFrontendScoutEvidenceTools } from "./dag-pi/tools/scout-evidence-tools.js";
@@ -26,7 +23,7 @@ import { buildPlanSchemas } from "./dag-pi/plan/schema.js";
 import { buildPlanRecordTools } from "./dag-pi/plan/record-tools.js";
 import { buildPlanFinalizeTools } from "./dag-pi/plan/finalize-tools.js";
 import { createPlanFactAdopter } from "./dag-pi/plan/fact-adoption.js";
-import { collectFrontendPlanMissingFacts, collectFrontendPlanPhaseMissingFacts, committedFactFromPlanRecord, planFactStringList, planFactScopeIntersects } from "./dag-pi/plan/facts.js";
+import { planFactStringList } from "./dag-pi/plan/facts.js";
 import { createPiReadBudgetCustomTools, } from "./pi-read-budget-policy.js";
 import { cleanupPlaywrightCliDefaultSession, createPlaywrightCliTool, PI_COMMAND_CAPABILITY_REGISTRY, resolveCaseIdFromWriteSet, resolveEvidenceDirFromWriteSet, } from "./pi-playwright-cli-tool.js";
 import { dagCommandPolicyAllows, resolveDagCommandPolicy, } from "../workflows/dag/types.js";
@@ -44,16 +41,17 @@ import { assessBackendTestPlanProtocol } from "../workflows/dag/backend-test-pla
 import { frontendTestLayoutFromSpec } from "../workflows/dag/frontend-test-layout.js";
 import { redactSecrets, truncateUtf8Preview } from "../shared/preview.js";
 import { writeEffectiveContextReceipt } from "../workflows/dag/context-receipt.js";
+import { estimateFrontendPlanRequirementRecordCalls, isWriterThinkingExhausted, readWriterThinkingExhaustionEvidence, WRITER_BUDGET_EXHAUSTED_CATEGORY, WRITER_TOKEN_BUDGET, FRONTEND_PLAN_COVERAGE_MAX_CONCURRENCY, mapWithConcurrency, buildFrontendPlanWorkload, loadOrCreateFrontendPlanCoverageLayout, collectFrontendVerificationCommandFiles, aggregateParallelPiResults, combineSequentialPiResults, runFrontendScoutParallelSessions, runFrontendContractSegmentedSessions, runFrontendPlanSegmentedSessions, runFrontendReviewSegmentedSessions, runFrontendScoutSegmentedSessions, } from "./dag-pi/sessions/index.js";
+// 兼容既有测试导入路径：纯规划/投影符号经 entry 转发（逐步迁移后移除）。
+export { estimateFrontendPlanRequirementRecordCalls, batchFrontendPlanRequirements, mapWithConcurrency, buildFrontendPlanWorkload, collectFrontendPlanRequirementIds, loadOrCreateFrontendPlanCoverageLayout, collectFrontendVerificationCommandFiles, compactFrontendPlanLedgerContext, compactFrontendPlanPromptForRequirementSlice, aggregateParallelPiResults, combineSequentialPiResults, runFrontendScoutParallelSessions, runFrontendContractSegmentedSessions, runFrontendPlanSegmentedSessions, runFrontendReviewSegmentedSessions, runFrontendScoutSegmentedSessions } from "./dag-pi/sessions/index.js";
 /**
  * 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";
 /**
  * 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
@@ -260,34 +258,13 @@ export function normalizeParallelCoverageShardRecords(records, shardNumber) {
             : record;
     });
 }
-export function isPlannerThinkingExhausted(result, committedAnyFacts) {
-    if (result.ok)
-        return false;
-    const evidence = readWriterThinkingExhaustionEvidence(result);
-    if (evidence.stopReason !== "length")
-        return false;
-    if (evidence.thinkingObserved !== true)
-        return false;
-    if (committedAnyFacts)
-        return false;
-    if ((result.assistantText ?? "").trim())
-        return false;
-    // Gateways sometimes relabel a length-stopped stream as `network` or
-    // `nonzero-exit`; provider evidence outweighs the transport label.
-    if (result.failureCategory &&
-        !["empty-output", "network", "nonzero-exit", "unknown"].includes(result.failureCategory))
-        return false;
-    return true;
-}
 /**
  * The writer session burned an excessive token budget (a read-edit-test loop
  * that never converged) and still failed. Distinct from empty-output so the
  * report shows the real cause and recovery recommends a fresh compacted run.
  * Not auto-retried by default; operators may rerun after a model switch.
  */
-export const WRITER_BUDGET_EXHAUSTED_CATEGORY = "writer-budget-exhausted";
 /** Token ceiling for a single writer node before it is judged budget-exhausted. */
-export const WRITER_TOKEN_BUDGET = 2_000_000;
 export function allowsMissingChangedWriterOutcomeRecovery(task) {
     return (isBackendTestCompletenessRetryCandidate(task) ||
         isBackendTestPytestCollectionRepairOutcomeRecoveryCandidate(task) ||
@@ -302,51 +279,6 @@ export function allowsMissingChangedWriterOutcomeRecovery(task) {
             (task.writeSet?.length ?? 0) > 0 &&
             task.writerOutcomePolicy?.type === "implementation-outcome-v1"));
 }
-function readWriterThinkingExhaustionEvidence(result) {
-    const wider = result;
-    return {
-        ...(typeof wider.stopReason === "string"
-            ? { stopReason: wider.stopReason }
-            : {}),
-        ...(typeof wider.thinkingObserved === "boolean"
-            ? { thinkingObserved: wider.thinkingObserved }
-            : {}),
-        ...(typeof wider.writeToolCallCount === "number"
-            ? { writeToolCallCount: wider.writeToolCallCount }
-            : {}),
-    };
-}
-/**
- * Pure classification predicate for writer-thinking-exhausted (AC-002).
- * Requires ALL of: empty-output base category, stopReason exactly "length",
- * thinking observed, zero write/edit tool calls, and a confirmed empty
- * run-attributed diff. Recoverable partial writes stay incomplete-write-set
- * because the caller only consults this predicate when the completeness gate
- * did not upgrade the category.
- */
-export function isWriterThinkingExhausted(result, mapped, changeManifestChangedFiles) {
-    if (mapped.ok)
-        return false;
-    const evidence = readWriterThinkingExhaustionEvidence(result);
-    if (evidence.stopReason !== "length")
-        return false;
-    if (evidence.thinkingObserved !== true)
-        return false;
-    if ((evidence.writeToolCallCount ?? 0) !== 0)
-        return false;
-    // Gateways sometimes classify a length-stopped stream as `network` or
-    // `nonzero-exit` because the terminal event is carried in stderr. The
-    // provider evidence is stronger than that transport label when no write
-    // tool was called and the run produced no diff.
-    if (mapped.failureCategory &&
-        !["empty-output", "network", "nonzero-exit", "unknown"].includes(mapped.failureCategory))
-        return false;
-    if (changeManifestChangedFiles === undefined)
-        return false;
-    if (changeManifestChangedFiles.length !== 0)
-        return false;
-    return true;
-}
 export const DAG_PI_READONLY_TOOLS = ["read", "grep", "find", "ls"];
 /** Bounded writer tools include bash; edit/write remain policy-wrapped via SDK customTools. */
 export const DAG_PI_WRITE_TOOLS = [
@@ -1741,171 +1673,12 @@ async function validateFrontendDesignTerminal(input) {
 }
 /** Tool subsets for the frontend plan phases. Local UX decisions and global
  * policies intentionally have different sessions and different tool sets. */
-const FRONTEND_PLAN_SEGMENTS = [
-    {
-        id: "coverage",
-        toolNames: new Set([
-            "record_plan_requirement",
-            "record_plan_group_coverage",
-            "record_plan_verification_target",
-            "record_plan_evidence_gap",
-            "adopt_staged_fact",
-        ]),
-        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. Target ids identify contract entries, not test-title markers. Reuse affected existing test files and their names; do not add tests or rename titles just to carry generated ids. 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(" "),
-    },
-    {
-        id: "ux-registry",
-        toolNames: new Set(["record_state_registry", "adopt_staged_fact"]),
-        instruction: [
-            "PLAN PHASE — global UX vocabulary.",
-            "Bootstrap the global UX vocabulary from the execution-group index and authoritative declared states. This is navigation, not permission to decide unseen behavior. Detailed complete scopes may extend the registry with replace:true while preserving live names. UI states use declaredUiStates ids when present. Interaction names are stable kebab-case behavior domains; merge requirements that describe the same behavior instead of renaming it per AC slice. Empty arrays explicitly declare that no UX vocabulary applies. Do not record component choices or state-flow details in this phase.",
-            "Do not call finalize_plan; it is not available in this phase.",
-        ].join(" "),
-    },
-    {
-        id: "ux-local",
-        toolNames: new Set([
-            "record_state_registry",
-            "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 unchanged facts. Review the current complete execution-group scope and the committed global UX registry together, then record each component choice, UI state and interaction exactly once. 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; 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.",
-            "Do not call finalize_plan; it is not available in this phase.",
-        ].join(" "),
-    },
-    {
-        id: "global-route",
-        toolNames: new Set(["record_route_selection", "adopt_staged_fact"]),
-        instruction: [
-            "PLAN PHASE — global route decision.",
-            "Use the Scout target surface and record only the selected route(s). Do not record requirement-local UX, Mock/data, dependency, or deviation facts. Do not call finalize_plan.",
-        ].join(" "),
-    },
-    {
-        id: "global-mock-data",
-        toolNames: new Set(["record_data_flow", "record_mock_api", "record_mock_endpoint", "adopt_staged_fact"]),
-        instruction: [
-            "PLAN PHASE — global Mock/API and data policy.",
-            "Record the cross-cutting interaction-to-endpoint data flow and Mock/API strategy only. Keep this decision set separate from route, component, state, dependency, and deviation facts. Do not call finalize_plan.",
-        ].join(" "),
-    },
-    {
-        id: "global-dependency-deviation",
-        toolNames: new Set(["record_dependency", "record_design_deviation", "adopt_staged_fact"]),
-        instruction: [
-            "PLAN PHASE — global dependency and design-deviation policy.",
-            "Record only dependency policy and design-evidence conflicts. Do not record route, Mock/data, or requirement-local UX facts. Do not call finalize_plan.",
-        ].join(" "),
-    },
-];
 /** Estimate calls conservatively: requirement + one VT, with a second VT
  * reserved for behaviour-required requirements. Explicit declarations win. */
-export function estimateFrontendPlanRequirementRecordCalls(fact) {
-    const record = fact && typeof fact === "object" && !Array.isArray(fact)
-        ? fact
-        : {};
-    const declaredTargetCount = Array.isArray(record.verificationTargetIds)
-        ? record.verificationTargetIds.filter((value) => typeof value === "string" && value.trim()).length
-        : Array.isArray(record.verificationTargets)
-            ? record.verificationTargets.length
-            : 0;
-    const evidence = record.evidence && typeof record.evidence === "object"
-        ? record.evidence
-        : undefined;
-    const targetCount = Math.max(declaredTargetCount, evidence?.behavior === "required" ? 2 : 1);
-    return 1 + targetCount;
-}
 /** Pack requirements without splitting one requirement across sessions. */
-export function batchFrontendPlanRequirements(input) {
-    const batches = [];
-    let current = [];
-    let currentCost = 0;
-    for (const id of input.requirementIds) {
-        const cost = Math.max(1, input.requirementCosts?.get(id) ?? 2);
-        if (current.length > 0 &&
-            (currentCost + cost > input.maxEstimatedRecordCalls ||
-                (input.maxRequirements !== undefined &&
-                    current.length >= input.maxRequirements))) {
-            batches.push(current);
-            current = [];
-            currentCost = 0;
-        }
-        current.push(id);
-        currentCost += cost;
-    }
-    if (current.length > 0)
-        batches.push(current);
-    return batches;
-}
-const FRONTEND_PLAN_COVERAGE_MAX_RECORD_CALLS = 10;
-const FRONTEND_PLAN_COVERAGE_MAX_CONCURRENCY = 4;
 // A single registry owns global names; large UX work uses bounded serial
 // scopes against that registry. Keep a safety bound for adaptive 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, shouldReduceConcurrency) {
-    const results = new Array(items.length);
-    let nextIndex = 0;
-    let concurrency = Math.max(1, limit);
-    const running = new Map();
-    try {
-        while (nextIndex < items.length || running.size > 0) {
-            while (nextIndex < items.length && running.size < concurrency) {
-                const index = nextIndex++;
-                running.set(index, worker(items[index], index).then(result => ({ index, result })));
-            }
-            const { index, result } = await Promise.race(running.values());
-            running.delete(index);
-            results[index] = result;
-            // Drain existing work; only pending shards use the reduced cap.
-            // Failed shards remain failed and receive no extra retry allowance.
-            if (shouldReduceConcurrency(result))
-                concurrency = Math.max(1, Math.floor(concurrency / 2));
-        }
-    }
-    catch (error) {
-        await Promise.allSettled(running.values());
-        throw error;
-    }
-    return results;
-}
-function compactPromptString(value, _maxChars) {
-    return typeof value === "string" && value.trim().length ? value.trim() : undefined;
-}
-function compactPromptStringArray(value, _maxEntries = 12, maxChars = 180) {
-    if (!Array.isArray(value))
-        return [];
-    return value
-        .map((item) => compactPromptString(item, maxChars))
-        .filter((item) => item !== undefined);
-}
-function countFrontendPlanTargetSurfaces(basePrompt) {
-    const match = /<frontend_plan_input>[\s\S]*?<\/frontend_plan_input>/.exec(basePrompt);
-    if (!match)
-        return undefined;
-    for (const line of match[0].split(/\r?\n/)) {
-        try {
-            const payload = JSON.parse(line);
-            if (Array.isArray(payload.targetSurface))
-                return payload.targetSurface.length;
-        }
-        catch {
-            // surrounding lines are prose
-        }
-    }
-    return undefined;
-}
 /**
  * Deterministically extract repository file paths that frozen verification
  * commands operate on (`--config <file>`, `node --check <file>`). A frozen
@@ -1916,19 +1689,6 @@ function countFrontendPlanTargetSurfaces(basePrompt) {
  * compact session record the missing verification target inside the same
  * attempt instead.
  */
-export function collectFrontendVerificationCommandFiles(basePrompt) {
-    const files = new Set();
-    const configRe = /--config\s+([\w@./-]+\.(?:js|mjs|cjs|ts|json))/g;
-    const checkRe = /node\s+--check\s+([\w@./-]+\.(?:js|mjs|cjs))/g;
-    for (const re of [configRe, checkRe]) {
-        for (const match of basePrompt.matchAll(re)) {
-            const file = match[1];
-            if (file && file.includes("/"))
-                files.add(file);
-        }
-    }
-    return [...files].sort();
-}
 /**
  * Remove the repeated full planner input from a coverage batch. The normal
  * plan prompt already contains a bounded JSON handoff, but repeating all
@@ -1938,647 +1698,8 @@ export function collectFrontendVerificationCommandFiles(basePrompt) {
  * preserve the old prompt as a safe compatibility fallback rather than
  * silently giving the model an incomplete requirement.
  */
-export function compactFrontendPlanPromptForRequirementSlice(basePrompt, requirementIds, options = {}) {
-    const slice = [...new Set(requirementIds.filter((id) => id.trim().length > 0))];
-    if (slice.length === 0)
-        return basePrompt;
-    const planInputPattern = /<frontend_plan_input>[\s\S]*?<\/frontend_plan_input>/;
-    const planInputMatch = planInputPattern.exec(basePrompt);
-    if (!planInputMatch)
-        return basePrompt;
-    const blockLines = planInputMatch[0].split(/\r?\n/);
-    let payload;
-    for (const line of blockLines) {
-        try {
-            const parsed = JSON.parse(line);
-            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-                payload = parsed;
-                break;
-            }
-        }
-        catch {
-            // The surrounding block contains prose; only its JSON line is data.
-        }
-    }
-    if (!payload || !Array.isArray(payload.requirements))
-        throw Error("FRONTEND_INPUT_INVALID: plan inventory is not parseable");
-    const requirementsById = new Map();
-    for (const value of payload.requirements) {
-        if (!value || typeof value !== "object" || Array.isArray(value))
-            continue;
-        const requirement = value;
-        if (typeof requirement.id === "string") {
-            requirementsById.set(requirement.id, requirement);
-        }
-    }
-    const requirements = slice.map((id) => requirementsById.get(id));
-    if (requirements.some((requirement) => requirement === undefined)) {
-        throw Error(`FRONTEND_INPUT_SCOPE_MISSING: ${slice.filter(id => !requirementsById.has(id)).join(", ")}`);
-    }
-    const compactRequirements = requirements.map((requirement) => ({
-        id: compactPromptString(requirement.id, 80),
-        ...(options.includeRequirementText !== false && compactPromptString(requirement.text, 240)
-            ? { text: compactPromptString(requirement.text, 240) }
-            : {}),
-        sourceFragmentIds: compactPromptStringArray(requirement.sourceFragmentIds, 20, 80),
-    }));
-    const sliceSet = new Set(slice);
-    const compactVerificationTargets = options.includeVerificationTargets === false
-        ? []
-        : Array.isArray(payload.verificationTargets)
-            ? payload.verificationTargets.flatMap((value) => {
-                if (!value || typeof value !== "object" || Array.isArray(value))
-                    return [];
-                const target = value;
-                if (options.verificationTargetIds && !options.verificationTargetIds.includes(String(target.id)))
-                    return [];
-                const targetRequirementIds = planFactStringList(target.requirementIds);
-                const relatedRequirementIds = targetRequirementIds.filter((id) => sliceSet.has(id));
-                if (relatedRequirementIds.length === 0)
-                    return [];
-                return [
-                    {
-                        ...(typeof target.id === "string"
-                            ? { id: target.id }
-                            : {}),
-                        ...(typeof target.commandId === "string"
-                            ? { commandId: target.commandId }
-                            : {}),
-                        ...(compactPromptString(target.commandLabel, 180)
-                            ? { commandLabel: compactPromptString(target.commandLabel, 180) }
-                            : {}),
-                        ...(typeof target.file === "string"
-                            ? { file: target.file }
-                            : {}),
-                        requirementIds: relatedRequirementIds,
-                        uiStates: planFactStringList(target.uiStates),
-                    },
-                ];
-            })
-            : [];
-    const compactTargetSurface = Array.isArray(payload.targetSurface)
-        ? payload.targetSurface.flatMap((value) => {
-            if (!value || typeof value !== "object" || Array.isArray(value))
-                return [];
-            const surface = value;
-            return [
-                {
-                    ...(compactPromptString(surface.completeness, 32)
-                        ? { completeness: compactPromptString(surface.completeness, 32) }
-                        : {}),
-                    ...(compactPromptString(surface.entrypoint, 180)
-                        ? { entrypoint: compactPromptString(surface.entrypoint, 180) }
-                        : {}),
-                    ...(compactPromptString(surface.routeOrMount, 180)
-                        ? { routeOrMount: compactPromptString(surface.routeOrMount, 180) }
-                        : {}),
-                    implementationPaths: compactPromptStringArray(surface.implementationPaths),
-                    proposedPaths: compactPromptStringArray(surface.proposedPaths),
-                    testPaths: compactPromptStringArray(surface.testPaths),
-                    ...(compactPromptString(surface.dataSource, 180)
-                        ? { dataSource: compactPromptString(surface.dataSource, 180) }
-                        : {}),
-                    allowedPathConflicts: compactPromptStringArray(surface.allowedPathConflicts),
-                    unresolvedPaths: compactPromptStringArray(surface.unresolvedPaths),
-                },
-            ];
-        })
-        : [];
-    const compactDesignEvidence = options.includeDesignEvidence === true &&
-        Array.isArray(payload.designEvidence)
-        ? payload.designEvidence.flatMap((value) => {
-            if (!value || typeof value !== "object" || Array.isArray(value))
-                return [];
-            const evidence = value;
-            return [{
-                    ...(compactPromptString(evidence.source, 180)
-                        ? { source: compactPromptString(evidence.source, 180) }
-                        : {}),
-                    paths: compactPromptStringArray(evidence.paths, 12, 180),
-                    conflicts: compactPromptStringArray(evidence.conflicts, 24, 180),
-                }];
-        })
-        : [];
-    const compactDeclaredUiStates = Array.isArray(payload.declaredUiStates)
-        ? payload.declaredUiStates.flatMap((value) => {
-            if (!value || typeof value !== "object" || Array.isArray(value))
-                return [];
-            const state = value;
-            const id = typeof state.id === "string" ? state.id : undefined;
-            if (!id)
-                return [];
-            return [{
-                    id,
-                    ...(compactPromptString(state.trigger, 180)
-                        ? { trigger: compactPromptString(state.trigger, 180) }
-                        : {}),
-                    ...(compactPromptString(state.observableOutcome, 240)
-                        ? { observableOutcome: compactPromptString(state.observableOutcome, 240) }
-                        : {}),
-                }];
-        })
-        : [];
-    const committedUx = payload.committedUx &&
-        typeof payload.committedUx === "object" &&
-        !Array.isArray(payload.committedUx)
-        ? payload.committedUx
-        : undefined;
-    const compactPayload = {
-        inputManifest: { ...projectFrontendInputScope({ ...payload, requirements: [...requirementsById.values()] }, slice).inputManifest, semantics: options.includeRequirementText === false ? "navigation-only" : "full" },
-        constraints: payload.constraints,
-        executionGroups: Array.isArray(payload.executionGroups) ? payload.executionGroups.filter(g => isRecordObject(g) && Array.isArray(g.requirementIds) && g.requirementIds.some(id => slice.includes(String(id)))) : [],
-        requirements: compactRequirements,
-        requiredDeliverables: Array.isArray(payload.requiredDeliverables) ? payload.requiredDeliverables : [],
-        ...(compactTargetSurface.length > 0
-            ? { targetSurface: compactTargetSurface }
-            : {}),
-        ...(compactVerificationTargets.length > 0
-            ? { verificationTargets: compactVerificationTargets }
-            : {}),
-        ...(compactDesignEvidence.length > 0
-            ? { designEvidence: compactDesignEvidence }
-            : {}),
-        ...(compactDeclaredUiStates.length > 0
-            ? { declaredUiStates: compactDeclaredUiStates }
-            : {}),
-        ...(committedUx
-            ? {
-                committedUx: {
-                    uiStateNames: compactPromptStringArray(committedUx.uiStateNames, 40, 100),
-                    interactionNames: compactPromptStringArray(committedUx.interactionNames, 60, 120),
-                },
-            }
-            : {}),
-    };
-    const compactBlock = [
-        "<frontend_plan_input>",
-        `Committed Contract/Scout facts for ONLY the current requirement slice (${slice.join(", ")}); do not infer or record requirements outside this slice.`,
-        JSON.stringify(compactPayload),
-        "Do not read upstream artifacts, task sources, or repository files. If this slice cannot support a decision, record a genuine evidence gap.",
-        "</frontend_plan_input>",
-    ].join("\n");
-    let compactPrompt = basePrompt.replace(planInputPattern, compactBlock);
-    compactPrompt = compactPrompt.replace(/<upstream_context>[\s\S]*?<\/upstream_context>/, "<upstream_context>\n(full upstream prose omitted; use only the slice-specific typed facts above)\n</upstream_context>");
-    compactPrompt = compactPrompt.replace(/Cover each frozen requirement ID exactly once:[^\n]*/, `Cover ONLY the current requirement slice: ${slice.join(", ")}. Record each slice requirement exactly once.`);
-    const checklistPattern = /<plan_review_checklist>([\s\S]*?)<\/plan_review_checklist>/;
-    const checklistMatch = checklistPattern.exec(compactPrompt);
-    if (checklistMatch) {
-        if (options.includeChecklist === false) {
-            compactPrompt = compactPrompt.replace(checklistPattern, "");
-            return compactPrompt;
-        }
-        const checklist = checklistMatch[1]
-            .split(/\r?\n/)
-            .filter((line) => {
-            const requirementLine = /^Requirements requiring behavioural coverage:\s*(.*)$/.exec(line.trim());
-            if (requirementLine) {
-                return false;
-            }
-            const citationId = /^([^\s]+)\s+\+/.exec(line.trim())?.[1];
-            return citationId === undefined || sliceSet.has(citationId);
-        })
-            .concat([`Requirements requiring behavioural coverage: ${slice.join(", ") || "(none)"}`])
-            .join("\n");
-        compactPrompt = compactPrompt.replace(checklistPattern, `<plan_review_checklist>${checklist}</plan_review_checklist>`);
-    }
-    return compactPrompt;
-}
-function compactFrontendPlanLedgerContext(input) {
-    const slice = new Set(input.requirementIds);
-    const allowed = new Set(input.kinds);
-    const scopedKinds = new Set(input.scopedKinds ?? []);
-    const compactFacts = [];
-    for (const value of input.committedFacts) {
-        const fact = committedFactFromPlanRecord(value);
-        if (!fact || fact.origin !== "plan" || typeof fact.kind !== "string" || !allowed.has(fact.kind))
-            continue;
-        if (scopedKinds.has(fact.kind) && !planFactScopeIntersects(fact, slice)) {
-            continue;
-        }
-        const entry = fact.entry && typeof fact.entry === "object" && !Array.isArray(fact.entry)
-            ? fact.entry
-            : undefined;
-        if (fact.kind === "plan-requirement") {
-            if (!entry || typeof entry.id !== "string" || !slice.has(entry.id))
-                continue;
-            compactFacts.push({
-                kind: fact.kind,
-                entry: {
-                    id: entry.id,
-                    implementationTargets: planFactStringList(entry.implementationTargets).slice(0, 12),
-                    verificationTargetIds: planFactStringList(entry.verificationTargetIds).slice(0, 12),
-                    ...(compactPromptString(entry.expectedOutcome, 240)
-                        ? { expectedOutcome: compactPromptString(entry.expectedOutcome, 240) }
-                        : {}),
-                    ...(entry.evidenceGap && typeof entry.evidenceGap === "object"
-                        ? { evidenceGap: entry.evidenceGap }
-                        : {}),
-                },
-            });
-            continue;
-        }
-        if (fact.kind === "plan-verification-target") {
-            if (!entry)
-                continue;
-            // Scope against the complete canonical binding before compacting.
-            // A shared target may bind a late requirement beyond the preview cap.
-            const requirementIds = planFactStringList(entry.requirementIds).filter((id) => slice.has(id));
-            if (requirementIds.length === 0)
-                continue;
-            compactFacts.push({
-                kind: fact.kind,
-                entry: {
-                    id: entry.id,
-                    commandId: entry.commandId,
-                    file: entry.file,
-                    requirementIds,
-                    uiStates: planFactStringList(entry.uiStates).slice(0, 12),
-                },
-            });
-            continue;
-        }
-        if (fact.kind === "component-choice") {
-            const choices = Array.isArray(fact.uiComponentChoices)
-                ? fact.uiComponentChoices.flatMap((choice) => {
-                    if (!choice || typeof choice !== "object" || Array.isArray(choice))
-                        return [];
-                    const item = choice;
-                    return [{
-                            purpose: compactPromptString(item.purpose, 120),
-                            component: compactPromptString(item.component, 120),
-                            decision: compactPromptString(item.decision, 40),
-                            covers: compactPromptStringArray(item.covers, 40, 120),
-                            evidencePath: compactPromptString(item.evidencePath, 180),
-                        }];
-                })
-                : [];
-            if (choices.length > 0)
-                compactFacts.push({ kind: fact.kind, uiComponentChoices: choices });
-            continue;
-        }
-        if (fact.kind === "state-registry") {
-            compactFacts.push({
-                kind: fact.kind,
-                uiStateNames: planFactStringList(fact.uiStateNames).slice(0, 40),
-                interactionNames: planFactStringList(fact.interactionNames).slice(0, 60),
-            });
-            continue;
-        }
-        if (fact.kind === "state-flow") {
-            compactFacts.push({
-                kind: fact.kind,
-                uiStates: Array.isArray(fact.uiStates) ? fact.uiStates : [],
-                interactions: Array.isArray(fact.interactions) ? fact.interactions : [],
-                removeUiStateNames: compactPromptStringArray(fact.removeUiStateNames, 24, 100),
-                removeInteractionNames: compactPromptStringArray(fact.removeInteractionNames, 24, 100),
-            });
-            continue;
-        }
-        if (fact.kind === "data-flow") {
-            compactFacts.push({
-                kind: fact.kind,
-                interactions: compactPromptStringArray(fact.interactions, 32, 120),
-                endpoints: compactPromptStringArray(fact.endpoints, 32, 180),
-            });
-            continue;
-        }
-        if (fact.kind === "mock-api") {
-            const mockApi = fact.mockApi && typeof fact.mockApi === "object" && !Array.isArray(fact.mockApi)
-                ? fact.mockApi
-                : {};
-            compactFacts.push({
-                kind: fact.kind,
-                mockApi: {
-                    strategy: compactPromptString(mockApi.strategy, 40),
-                    activation: compactPromptString(mockApi.activation, 180),
-                    endpoints: Array.isArray(mockApi.endpoints) ? mockApi.endpoints : [],
-                },
-            });
-            continue;
-        }
-        if (fact.kind === "design-deviation") {
-            compactFacts.push({ kind: fact.kind, conflicts: compactPromptStringArray(fact.conflicts, 32, 180) });
-            continue;
-        }
-        if (fact.kind === "dependency") {
-            compactFacts.push({ kind: fact.kind, policy: compactPromptString(fact.policy, 300) });
-            continue;
-        }
-        if (fact.kind === "target-surface") {
-            compactFacts.push({ kind: fact.kind, routes: compactPromptStringArray(fact.routes, 24, 180), implementationPaths: compactPromptStringArray(fact.implementationPaths, 24, 180), proposedPaths: compactPromptStringArray(fact.proposedPaths, 24, 180), testPaths: compactPromptStringArray(fact.testPaths, 24, 180) });
-        }
-    }
-    if (compactFacts.length === 0)
-        return "";
-    const priorityFacts = compactFacts.filter((fact) => fact.kind === "plan-requirement" || fact.kind === "plan-verification-target");
-    const otherFacts = compactFacts.filter((fact) => fact.kind !== "plan-requirement" && fact.kind !== "plan-verification-target");
-    let previewBytes = 0;
-    const boundedFacts = [
-        ...priorityFacts.slice(0, 64),
-        ...otherFacts.slice(-32),
-    ].slice(0, 96).filter(fact => {
-        const bytes = Buffer.byteLength(JSON.stringify(fact));
-        if (previewBytes + bytes > 24_000)
-            return false;
-        previewBytes += bytes;
-        return true;
-    });
-    return [
-        "<frontend_plan_ledger>",
-        "Preview of committed plan facts; not a replacement payload. Fields and lists may be omitted or shortened. Use read_plan_facts with kind, entryId/eventId and optional field to retrieve complete values in bounded pages before corrections; preserve all other bindings. Absence from this preview is not absence from the ledger.",
-        JSON.stringify({ complete: false, matchingFacts: compactFacts.length, omittedFacts: compactFacts.length - boundedFacts.length }),
-        JSON.stringify(boundedFacts),
-        "</frontend_plan_ledger>",
-    ].join("\n");
-}
-export async function runFrontendReviewSegmentedSessions(input) {
-    const protocol = input.tools.scopeProtocol;
-    const terminalKinds = input.phase === "review" ? ["approve_review", "request_review_changes"] : ["approve_design", "request_design_changes"];
-    const terminal = () => protocol.committedFacts().some(r => terminalKinds.includes(String(r.fact.kind)));
-    const targetBytes = input.sessionOptions.frontendExecutionPolicy?.scopeTargetBytes ?? FRONTEND_SCOPE_TARGET_BYTES;
-    const queue = packFrontendInputUnits(input.inventory.scopes.filter(s => !protocol.completedScopeIds().has(s.id)), { targetBytes, maxUnits: input.sessionOptions.frontendExecutionPolicy?.maxScopeUnits }).map(scopes => ({ scopes, repairs: 0 }));
-    if (!queue.length)
-        queue.push({ scopes: [], repairs: 0 });
-    let calls = 0;
-    let last = { ok: true, assistantText: "", command: [], durationMs: 0, exitCode: 0, failureCategory: "success", modelDisplay: "unknown", parsedEvents: 0, stderr: "", stdout: "", timedOut: false, attemptedModels: [], fallbackUsed: false, tokensUsed: 0 };
-    for (let index = 0; index < queue.length; index++) {
-        await input.tools.flush();
-        await input.inventory.validate();
-        if (terminal()) {
-            protocol.assertComplete();
-            return last;
-        }
-        const item = queue[index];
-        const scopes = item.scopes.filter(s => !protocol.completedScopeIds().has(s.id));
-        protocol.setActiveScope(scopes.map(s => s.id));
-        const finalScope = input.inventory.scopes.every(s => protocol.completedScopeIds().has(s.id) || scopes.some(current => current.id === s.id));
-        const customTools = finalScope ? input.customTools : input.customTools.filter(t => !terminalKinds.includes(String(t.name)));
-        const prompt = `${input.basePrompt}\n<frontend_review_authority>\nThe Contract acceptance criteria, constraints, required deliverables, UI-state declarations, and verification expectations in the supplied input are authoritative. Review the actual diff and evidence against those facts; do not replace them with a Plan-derived interpretation.\n</frontend_review_authority>\n<frontend_review_scope>\n${JSON.stringify({ semantics: "full", inventoryDigest: input.inventory.digest, scopes, previouslyCompleted: [...protocol.completedScopeIds()], savedFindings: protocol.committedFacts().filter(r => String(r.fact.kind).endsWith("-finding")).map(r => ({ id: r.fact.id, finding: r.fact.finding })) })}\n</frontend_review_scope>\nReview the complete supplied scopes, saving each finding immediately. Call complete_review_scope for each exact id only after all its independent permissions, thresholds, errors and evidence have been checked. ${finalScope ? "After every scope is complete, make one independent overall approve/request_changes decision; persisted findings cannot be omitted." : "More scopes remain. Do not finalize or reread already completed scopes unless resolving a cross-scope issue."}`;
-        if (Buffer.byteLength(prompt) > targetBytes && scopes.length > 1) {
-            const at = Math.ceil(scopes.length / 2);
-            queue.splice(index, 1, { scopes: scopes.slice(0, at), repairs: 0 }, { scopes: scopes.slice(at), repairs: 0 });
-            index--;
-            continue;
-        }
-        const completionInstruction = `${item.repairs ? "REPAIR: the prior session did not commit all required checkpoints/verdict. Do not repeat the review narrative. " : ""}Complete these exact runtime scope IDs using complete_review_scope: ${JSON.stringify(scopes.map(scope => scope.id))}. These are scope IDs, not node IDs. ${finalScope ? `After those checkpoints succeed, call exactly one terminal tool: ${terminalKinds.join(" or ")}. A prose conclusion is not a committed verdict.` : "More scopes remain; do not submit an overall verdict yet."}`;
-        const userMessage = `${input.sessionOptions.userMessage}\n\n${completionInstruction}`;
-        if (++calls > 128)
-            return { ...last, ok: false, failureCategory: "frontend-input-exhausted", stderr: "FRONTEND_REVIEW_RECOVERY_EXHAUSTED: session quota reached" };
-        last = await observeFrontendSession({ ...input.observation, phase: `${input.phase}/scope`, scopeIds: scopes.map(s => s.id), prompt, userMessage, customTools,
-            artifactPath: input.observation?.artifactPath ? `${input.observation.artifactPath}-${calls}.json` : undefined,
-            committedCount: () => protocol.committedFacts().length, durableCommittedCount: () => protocol.committedFacts().length,
-        }, observer => input.piStepFn({ ...input.sessionOptions, prompt, userMessage, onAttemptObservation: observer, writerToolPolicy: { requireSdk: true, customTools } }));
-        await input.tools.flush();
-        await input.inventory.validate();
-        if (last.timedOut || /interrupt|termination-unconfirmed|budget_breach/.test(last.failureCategory))
-            return { ...last, ok: false };
-        const capacity = readWriterThinkingExhaustionEvidence(last).stopReason === "length" || ["context-overflow", "context-budget-exhausted"].includes(last.failureCategory);
-        const missing = scopes.filter(s => !protocol.completedScopeIds().has(s.id));
-        if (capacity && (missing.length || !terminal() && finalScope)) {
-            if (missing.length === 1 && scopes.length === 1 || !missing.length && !scopes.length)
-                return { ...last, ok: false, failureCategory: "frontend-input-exhausted", stderr: "FRONTEND_INPUT_UNIT_TOO_LARGE: complete review unit or terminal exhausted" };
-            const at = Math.ceil(missing.length / 2);
-            const smaller = missing.length ? [missing.slice(0, at), missing.slice(at)].filter(s => s.length) : [[]];
-            queue.splice(index, 1, ...smaller.map(scopes => ({ scopes, repairs: 0 })));
-            index--;
-            continue;
-        }
-        if (!last.ok && !capacity) {
-            // Terminal-only completion: this protocol finishes through durable
-            // tools (complete_review_scope -> approve_review/request_review_changes),
-            // so the model can end its turn with no closing prose and the step
-            // classifies as empty-output even though the review is complete
-            // (smoke r27/r31/r32 committed the terminal and still reported
-            // empty-output; the node then replayed the committed fact in an
-            // extra attempt). Accept the segment here instead, so a completed
-            // review neither spends a replay attempt nor depends on the retry
-            // ladder, and a misclassified category (smoke r28 read a finding id
-            // containing UNAUTHORIZED as an auth error, which is not retryable)
-            // can no longer turn a committed review into a node failure.
-            if (last.failureCategory === "empty-output" && terminal() && !missing.length) {
-                try {
-                    await input.tools.flush();
-                    protocol.assertComplete();
-                    return { ...last, ok: true, failureCategory: "success" };
-                }
-                catch {
-                    // Unfinished scope checkpoints still fail this segment.
-                }
-            }
-            return last;
-        }
-        if (missing.length || finalScope && !terminal()) {
-            if (item.repairs >= 1)
-                return { ...last, ok: false, failureCategory: "frontend-input-exhausted", stderr: "FRONTEND_REVIEW_SCOPE_INCOMPLETE: required checkpoint or verdict missing" };
-            queue.splice(index, 1, { scopes: missing, repairs: item.repairs + 1 });
-            index--;
-        }
-    }
-    protocol.assertComplete();
-    return terminal() ? { ...last, ok: true, failureCategory: "success" } : { ...last, ok: false, failureCategory: "frontend-input-exhausted", stderr: "FRONTEND_REVIEW_SCOPE_INCOMPLETE: missing independent verdict" };
-}
-export async function runFrontendScoutSegmentedSessions(input) {
-    const inventory = parseFrontendInputBlock(input.basePrompt, "scout");
-    if (!inventory)
-        throw Error("FRONTEND_INPUT_MISSING: Scout compiled inventory unavailable");
-    const units = collectFrontendExecutionGroups(inventory.payload.requirements).map(group => ({ ...group, id: `${group.kind === "unclassified" ? "requirement" : "group"}:${group.id}`, requirements: inventory.payload.requirements.filter(r => group.requirementIds.includes(r.id)) }));
-    const targetBytes = input.sessionOptions.frontendExecutionPolicy?.scopeTargetBytes ?? FRONTEND_SCOPE_TARGET_BYTES;
-    const queue = packFrontendInputUnits(units, { targetBytes, maxUnits: input.sessionOptions.frontendExecutionPolicy?.maxScopeUnits }).map(batch => ({ groups: batch, repairs: 0 }));
-    let last = { ok: true, assistantText: "", command: [], durationMs: 0, exitCode: 0, failureCategory: "success", modelDisplay: input.sessionOptions.modelConfig?.model ?? "unknown", parsedEvents: 0, stderr: "", stdout: "", timedOut: false, attemptedModels: [], fallbackUsed: false, tokensUsed: 0 };
-    let calls = 0;
-    for (let index = 0; index < queue.length; index++) {
-        await input.tools.flush();
-        const item = queue[index];
-        const completed = input.tools.completedRequirementIds();
-        const groups = item.groups.filter(g => g.requirementIds.some(id => !completed.has(id)));
-        if (!groups.length)
-            continue;
-        const ids = groups.flatMap(g => g.requirementIds);
-        const scopeId = input.tools.setActiveScope(ids);
-        const prompt = input.basePrompt.replace(inventory.block, `<frontend_scout_input>\n${JSON.stringify(projectFrontendInputScope(inventory.payload, ids))}\n</frontend_scout_input>`) +
-            `\nSCOUT SCOPE ${scopeId}: discover the related surfaces for exactly these complete obligations: ${ids.join(", ")}. Reuse proven paths from completed scope navigation; do not reread their content unless relevant new evidence is needed. Submit record_target_surface with scopeId="${scopeId}" after all discovery/design evidence for this scope. completeness=complete closes only this scope; runtime merges all scopes.\n` +
-            JSON.stringify({ completedScopePaths: input.tools.completedScopeFacts().map(f => ({ id: f.id, requirementIds: f.requirementIds, paths: f.surface?.implementationPaths })) });
-        const envelopeBytes = Buffer.byteLength(prompt + input.sessionOptions.userMessage + JSON.stringify(input.customTools.map(t => { const tool = t; return { name: tool.name, description: tool.description, parameters: tool.parameters }; })));
-        if (envelopeBytes > targetBytes && groups.length > 1) {
-            const at = Math.ceil(groups.length / 2);
-            queue.splice(index, 1, { groups: groups.slice(0, at), repairs: 0 }, { groups: groups.slice(at), repairs: 0 });
-            index--;
-            continue;
-        }
-        if (++calls > 128)
-            return { ...last, ok: false, failureCategory: "frontend-input-exhausted", stderr: "SCOUT_RECOVERY_EXHAUSTED: shared session quota reached" };
-        last = await observeFrontendSession({ ...input.observation, phase: "scout/scope", scopeIds: ids, prompt, userMessage: input.sessionOptions.userMessage, customTools: input.customTools,
-            artifactPath: input.observation?.artifactPath ? `${input.observation.artifactPath}-${calls}.json` : undefined,
-            committedCount: () => input.tools.committedFacts().length, durableCommittedCount: () => input.tools.committedFacts().length,
-        }, observer => input.piStepFn({ ...input.sessionOptions, prompt, onAttemptObservation: observer, writerToolPolicy: { requireSdk: true, customTools: input.customTools } }));
-        await input.tools.flush();
-        const missing = groups.filter(g => g.requirementIds.some(id => !input.tools.completedRequirementIds().has(id)));
-        if (last.timedOut || /interrupt|termination-unconfirmed|budget_breach/.test(last.failureCategory))
-            return { ...last, ok: false };
-        const capacity = readWriterThinkingExhaustionEvidence(last).stopReason === "length" || ["context-overflow", "context-budget-exhausted"].includes(last.failureCategory);
-        if (capacity && missing.length) {
-            if (missing.length === 1 && groups.length === 1)
-                return { ...last, ok: false, failureCategory: "frontend-input-exhausted", stderr: `${last.stderr}\nFRONTEND_INPUT_UNIT_TOO_LARGE: Scout ${missing[0].id}; refine the complete source unit; unchanged retries disabled` };
-            const at = Math.ceil(missing.length / 2);
-            queue.splice(index, 1, ...[missing.slice(0, at), missing.slice(at)].filter(batch => batch.length).map(batch => ({ groups: batch, repairs: 0 })));
-            index--;
-            continue;
-        }
-        if (!last.ok && !capacity)
-            return last;
-        if (missing.length) {
-            if (item.repairs >= 1)
-                return { ...last, ok: false, failureCategory: "frontend-input-exhausted", stderr: "SCOUT_SCOPE_INCOMPLETE: unresolved discovery remains after local correction" };
-            queue.splice(index, 1, { groups: missing, repairs: item.repairs + 1 });
-            index--;
-            continue;
-        }
-    }
-    await input.tools.flush();
-    const { readCompleteScoutTargetSurface } = await import("../workflows/dag/frontend-committed-facts.js");
-    const closure = readCompleteScoutTargetSurface(input.tools.committedFacts());
-    return closure.ok ? { ...last, ok: true, failureCategory: "success" } : { ...last, ok: false, failureCategory: "frontend-input-exhausted", stderr: closure.reason };
-}
-export async function runFrontendContractSegmentedSessions(input) {
-    // Requirement identity, text, and source fragments are frozen in the
-    // runtime ledger. Seed those facts once; model sessions spend their budget
-    // on execution grouping, evidence expectations, and genuine decisions.
-    await input.tools.seedCanonicalRequirements();
-    // Build from the frozen runtime inventory if the caller has not rendered it yet.
-    const basePrompt = parseFrontendInputBlock(input.basePrompt, "contract") ? input.basePrompt : input.basePrompt +
-        `\n<frontend_contract_input>\nFrozen complete source obligations.\n${JSON.stringify({ requirements: input.tools.inputRequirements() })}\n</frontend_contract_input>`;
-    const inventory = parseFrontendInputBlock(basePrompt, "contract");
-    const pending = inventory.payload.requirements.filter(r => !input.tools.completedScopeRequirementIds().has(r.id));
-    const batches = packFrontendInputUnits(pending, { targetBytes: input.sessionOptions.frontendExecutionPolicy?.scopeTargetBytes, maxUnits: input.sessionOptions.frontendExecutionPolicy?.maxScopeUnits });
-    if (!batches.length)
-        batches.push([]);
-    let last;
-    let invocation = 0;
-    const maxSessions = batches.length * 3 + 2;
-    const terminal = () => input.tools.committedFacts().some(r => r.fact.kind === "contract-finalized");
-    try {
-        for (let index = 0; index < batches.length; index += 1) {
-            let scopeIds = batches[index].map(r => r.id);
-            const finalScope = index === batches.length - 1;
-            for (let repair = 0; repair < 2; repair += 1) {
-                // Confirmed IDs remain visible until the model commits a scope checkpoint.
-                const completed = input.tools.completedScopeRequirementIds();
-                scopeIds = scopeIds.filter(id => !completed.has(id));
-                input.tools.setActiveRequirementScope(scopeIds);
-                const groupIndex = collectFrontendExecutionGroups(input.tools.committedFacts().filter(r => r.fact.kind === "requirement").map(r => ({ id: String(r.fact.id), execution: r.fact.execution })));
-                const shared = input.tools.committedFacts().filter(r => !["requirement", "contract-finalized", "contract-scope-completed"].includes(String(r.fact.kind))).map(r => r.fact);
-                const prompt = projectFrontendContractPrompt(basePrompt, scopeIds) +
-                    `\nCONTRACT SCOPE: analyze only ${scopeIds.join(", ") || "(all scopes complete; verify global facts and terminal)"}. Requirement identity/text/source fragments are already committed by runtime; do not call record_requirement. Use record_requirement_execution for model-owned execution grouping, then submit decisions and evidence records. Call complete_contract_scope after ALL decisions for this scope. ` +
-                    (finalScope ? "After complete scope coverage and source-bound deliverables, call finalize_contract. Correct rejected calls and retry." : "Do not finalize; subsequent complete scopes remain.") +
-                    `\n<committed_contract_facts>\n${JSON.stringify({ facts: shared, executionGroups: groupIndex })}\n</committed_contract_facts>`;
-                const customTools = input.tools.customTools.filter(t => finalScope || t.name !== "finalize_contract");
-                invocation += 1;
-                if (invocation > maxSessions)
-                    return { ...last, ok: false, failureCategory: "invalid-output", stderr: "CONTRACT_RECOVERY_EXHAUSTED: session quota exceeded" };
-                const committedBefore = input.tools.committedFacts().length;
-                last = await observeFrontendSession({
-                    ...input.observation, phase: "contract/scope", scopeIds, prompt, userMessage: input.sessionOptions.userMessage, customTools,
-                    artifactPath: input.observation?.artifactPath ? `${input.observation.artifactPath}-${invocation}.json` : undefined,
-                    committedCount: () => input.tools.committedFacts().length, durableCommittedCount: () => input.tools.committedFacts().length,
-                }, observer => input.piStepFn({ ...input.sessionOptions, prompt, onAttemptObservation: observer, writerToolPolicy: { requireSdk: true, customTools } }));
-                await input.tools.flush();
-                if (last.timedOut || /interrupt|termination-unconfirmed|budget_breach/.test(last.failureCategory))
-                    return { ...last, ok: false };
-                const capacityExhausted = readWriterThinkingExhaustionEvidence(last).stopReason === "length" || ["context-overflow", "context-budget-exhausted"].includes(last.failureCategory);
-                if (capacityExhausted && !last.timedOut) {
-                    const missing = scopeIds.filter(id => !input.tools.completedScopeRequirementIds().has(id));
-                    if (!missing.length) {
-                        if (finalScope && !terminal()) {
-                            if (!scopeIds.length)
-                                return { ...last, ok: false, failureCategory: "invalid-output", stderr: `${last.stderr}\nFRONTEND_INPUT_UNIT_TOO_LARGE: contract terminal exhausted; unchanged retry disabled` };
-                            batches.push([]);
-                        }
-                        break;
-                    }
-                    if (missing.length === 1 && scopeIds.length > 1) {
-                        batches.splice(index, 1, inventory.payload.requirements.filter(r => missing.includes(r.id)));
-                        index -= 1;
-                        break;
-                    }
-                    if (missing.length <= 1)
-                        return { ...last, ok: false, stderr: `${last.stderr}\nFRONTEND_INPUT_UNIT_TOO_LARGE: ${missing[0] ?? "contract terminal"}; atom could not complete; refine the source without dropping conditions` };
-                    const smaller = packFrontendInputUnits(inventory.payload.requirements.filter(r => missing.includes(r.id)), { maxUnits: Math.ceil(missing.length / 2) });
-                    batches.splice(index, 1, ...smaller);
-                    index -= 1;
-                    break;
-                }
-                // A session that ends with blank assistant text but committed new
-                // facts is not a node failure: small-output models legitimately
-                // stop after their tool calls. Continue so the scope/repair checks
-                // below decide, instead of burning a full node retry.
-                const committedFactsOnlySuccess = !(last.assistantText ?? "").trim() &&
-                    !last.stderr.trim() &&
-                    input.tools.committedFacts().length > committedBefore;
-                if (!last.ok && !committedFactsOnlySuccess)
-                    return last;
-                if (committedFactsOnlySuccess)
-                    last = { ...last, ok: true, failureCategory: "success" };
-                const missing = scopeIds.filter(id => !input.tools.completedScopeRequirementIds().has(id));
-                if (!missing.length && (!finalScope || terminal()))
-                    break;
-                if (repair === 1)
-                    return { ...last, ok: false, failureCategory: "invalid-output", stderr: `CONTRACT_SCOPE_INCOMPLETE: ${missing.join(", ") || "missing finalize_contract"}` };
-            }
-        }
-        return last;
-    }
-    finally {
-        input.tools.setActiveRequirementScope(null);
-    }
-}
 /** One workload view for both the outer parallel map and inner session queue.
  * A declared execution group is an indivisible unit during initial packing. */
-function buildFrontendPlanWorkload(input) {
-    const allRequirementIds = input.requirementIds;
-    const compiledInput = parseFrontendInputBlock(input.basePrompt, "plan")?.payload;
-    const fullUnits = new Map(compiledInput?.requirements.map(r => [r.id, r]) ?? []);
-    const declaredGroups = Array.isArray(compiledInput?.executionGroups)
-        ? compiledInput.executionGroups.filter(isRecordObject) : [];
-    const workGroups = declaredGroups.map(g => ({
-        id: String(g.id), kind: String(g.kind),
-        requirementIds: Array.isArray(g.requirementIds)
-            ? g.requirementIds.filter((id) => typeof id === "string" && allRequirementIds.includes(id)) : [],
-    })).filter(g => g.requirementIds.length);
-    const groupedIds = new Set(workGroups.flatMap(g => g.requirementIds));
-    for (const id of allRequirementIds) {
-        if (!groupedIds.has(id))
-            workGroups.push({ id, kind: "unclassified", requirementIds: [id] });
-    }
-    const workCost = (ids) => 1 + ids.reduce((total, id) => total + Math.max(1, (input.requirementCosts?.get(id) ?? 2) - 1), 0);
-    const policy = input.sessionOptions.frontendExecutionPolicy;
-    const targetBytes = policy?.scopeTargetBytes ?? FRONTEND_SCOPE_TARGET_BYTES;
-    const buildWorkBatches = (ids) => {
-        const work = workGroups.flatMap((g, index) => {
-            const members = g.requirementIds.filter(id => ids.includes(id));
-            return members.length ? [{ id: `${index}:${g.id}`, requirementIds: members,
-                    requirements: members.map(id => fullUnits.get(id) ?? { id }), estimatedCalls: workCost(members) }] : [];
-        });
-        // Pack complete work units, not the repeated request scaffold. Deducting
-        // fixed context/tools can leave a one-byte budget and force one AC per
-        // session without reducing that overhead. The SDK checks the actual
-        // request against model capacity; capacity recovery splits unfinished work.
-        return packFrontendInputUnits(work, {
-            targetBytes,
-            maxUnits: policy?.maxScopeUnits ?? 4,
-            maxCost: FRONTEND_PLAN_COVERAGE_MAX_RECORD_CALLS, cost: g => g.estimatedCalls,
-        }).map(batch => batch.flatMap(g => g.requirementIds));
-    };
-    // This renderer also carries the Plan's evolving UX checkpoint on resume.
-    // Only the Contract/Scout-derived input participates in ownership binding.
-    const { committedUx: _committedUx, ...frozenInput } = compiledInput ?? {};
-    return {
-        frozenInput, workGroups, buildWorkBatches,
-        compactEligible: input.requirementCosts !== undefined &&
-            workGroups.length <= FRONTEND_PLAN_SMALL_MAX_REQUIREMENTS &&
-            workGroups.reduce((total, group) => total + workCost(group.requirementIds), 0) <= FRONTEND_PLAN_SMALL_MAX_ESTIMATED_CALLS &&
-            countFrontendPlanTargetSurfaces(input.basePrompt) === 1,
-    };
-}
 /**
  * Requirement ids the plan coverage layout must own, in first-commit order.
  *
@@ -2591,1005 +1712,8 @@ function buildFrontendPlanWorkload(input) {
  * FRONTEND_PLAN_LAYOUT_INVALID with failureCategory tool-policy - killing the run
  * at the plan node over a completely ordinary ledger.
  */
-export function collectFrontendPlanRequirementIds(contractFacts) {
-    return [
-        ...new Set(contractFacts
-            .filter((record) => record.fact?.kind ===
-            "requirement")
-            .map((record) => record.fact?.id)
-            .filter((id) => typeof id === "string")),
-    ];
-}
-const frontendPlanCoverageLayoutSchema = z.object({
-    schemaVersion: z.literal(1),
-    bindingSha256: z.string(),
-    coverageBatches: z.array(z.array(z.string().min(1)).min(1)).min(1),
-    layoutSha256: z.string(),
-}).strict();
 /** Freeze ledger ownership before any provider call. Session packing remains
  * adaptive inside each owner, but retry instructions cannot rename its scope. */
-async function loadOrCreateFrontendPlanCoverageLayout(input) {
-    const fileName = "coverage-layout.json";
-    const file = path.join(input.runDir, input.nodeId, fileName);
-    const bindingSha256 = sha256OfCanonicalJson(input.binding);
-    let raw;
-    try {
-        raw = await readFile(file, "utf8");
-    }
-    catch (error) {
-        if (error.code !== "ENOENT")
-            throw error;
-    }
-    let layout;
-    if (raw !== undefined) {
-        layout = frontendPlanCoverageLayoutSchema.parse(JSON.parse(raw));
-    }
-    else {
-        // Losing the ownership receipt must never repartition acknowledged facts.
-        for (const relative of ["plan-typed-facts.jsonl", "parallel"]) {
-            const existing = await stat(path.join(input.runDir, input.nodeId, relative)).catch(error => {
-                if (error.code !== "ENOENT")
-                    throw error;
-                return undefined;
-            });
-            if (existing && (existing.isDirectory() || existing.size > 0)) {
-                throw Error("FRONTEND_PLAN_LAYOUT_MISSING: preserve the existing ledger and restart its owning phase");
-            }
-        }
-        const descriptor = {
-            schemaVersion: 1, bindingSha256,
-            coverageBatches: input.workload.compactEligible ? [input.requirementIds] : input.workload.buildWorkBatches(input.requirementIds),
-        };
-        layout = { ...descriptor, layoutSha256: sha256OfCanonicalJson(descriptor) };
-    }
-    const { layoutSha256, ...descriptor } = layout;
-    if (layout.bindingSha256 !== bindingSha256 || layoutSha256 !== sha256OfCanonicalJson(descriptor)) {
-        throw Error("FRONTEND_PLAN_LAYOUT_MISMATCH: frozen coverage ownership or input binding changed");
-    }
-    const members = layout.coverageBatches.flat();
-    const owners = new Map(layout.coverageBatches.flatMap((batch, index) => batch.map(id => [id, index])));
-    if (members.length !== owners.size || members.length !== input.requirementIds.length ||
-        input.requirementIds.some(id => !owners.has(id)) ||
-        input.workload.workGroups.some(group => new Set(group.requirementIds.map(id => owners.get(id))).size !== 1)) {
-        throw Error("FRONTEND_PLAN_LAYOUT_INVALID: coverage must partition complete execution groups exactly once");
-    }
-    if (raw === undefined)
-        await writeDagNodeJsonArtifact(input.runDir, input.nodeId, fileName, layout);
-    return layout.coverageBatches;
-}
-export async function runFrontendPlanSegmentedSessions(input) {
-    const queue = [];
-    const coverageSegment = FRONTEND_PLAN_SEGMENTS.find((segment) => segment.id === "coverage");
-    const uxRegistrySegment = FRONTEND_PLAN_SEGMENTS.find((segment) => segment.id === "ux-registry");
-    const uxSegment = FRONTEND_PLAN_SEGMENTS.find((segment) => segment.id === "ux-local");
-    const globalMockDataSegment = FRONTEND_PLAN_SEGMENTS.find((segment) => segment.id === "global-mock-data");
-    const allRequirementIds = input.requirementIds ?? [];
-    const buildPhasePrompt = (segment, missing = [], scopeIds = allRequirementIds) => {
-        const compact = allRequirementIds.length > 0
-            ? compactFrontendPlanPromptForRequirementSlice(input.basePrompt, scopeIds, {
-                includeRequirementText: segment.id === "global-mock-data" || segment.id === "finalize",
-                includeVerificationTargets: false,
-                includeDesignEvidence: segment.id === "global-dependency-deviation" || segment.id === "finalize",
-                includeChecklist: false,
-            })
-            : input.basePrompt;
-        const kinds = segment.id === "global-route"
-            ? ["target-surface"]
-            : segment.id === "global-mock-data"
-                ? ["plan-requirement", "plan-verification-target", "state-flow", "data-flow", "mock-api"]
-                : segment.id === "global-dependency-deviation"
-                    ? ["dependency", "design-deviation"]
-                    : ["plan-requirement", "plan-verification-target", "state-registry", "component-choice", "state-flow", "data-flow", "mock-api", "design-deviation", "dependency", "target-surface"];
-        const ledger = input.committedFacts
-            ? compactFrontendPlanLedgerContext({
-                committedFacts: input.committedFacts(),
-                requirementIds: scopeIds,
-                kinds,
-                ...(segment.id === "global-mock-data" ? { scopedKinds: ["state-flow"] } : {}),
-            })
-            : "";
-        return [
-            compact,
-            segment.instruction,
-            ledger,
-            ...(missing.length > 0
-                ? [
-                    "MISSING-FACT QUEUE: repair ONLY these items, then re-check the phase:",
-                    ...missing.map((item) => `- ${item.kind}${item.id ? ` ${item.id}` : ""} for ${item.requirementIds.join(", ")}: ${item.reason}`),
-                ]
-                : []),
-        ].filter(Boolean).join("\n\n");
-    };
-    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. 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:",
-                ...missing.map((item) => `- ${item.kind}${item.id ? ` ${item.id}` : ""} for ${item.requirementIds.join(", ")}: ${item.reason}`),
-            ]
-            : []),
-    ].join("\n\n");
-    const buildUxPrompt = (slice, missing = []) => {
-        const ledger = input.committedFacts
-            ? compactFrontendPlanLedgerContext({
-                committedFacts: input.committedFacts(),
-                requirementIds: slice,
-                kinds: [
-                    "plan-requirement",
-                    "plan-verification-target",
-                    "state-registry",
-                    "component-choice",
-                    "state-flow",
-                ],
-                // Include shared state bindings from other scopes; page full values before correcting.
-            })
-            : "";
-        return [
-            compactFrontendPlanPromptForRequirementSlice(input.basePrompt, slice),
-            uxSegment.instruction,
-            `UX SCOPE: process these complete behavior groups together: ${slice.join(", ")}. Reuse shared registry/component ownership; do not rename a behavior by requirement id. Constraint/exclusion groups do not create UI; preserve genuine verification gaps.`,
-            ledger,
-            ...(missing.length > 0
-                ? [
-                    "MISSING-FACT QUEUE: repair ONLY these items, then re-check this UX slice:",
-                    ...missing.map((item) => `- ${item.kind}${item.id ? ` ${item.id}` : ""} for ${item.requirementIds.join(", ")}: ${item.reason}`),
-                ]
-                : []),
-        ].filter(Boolean).join("\n\n");
-    };
-    const buildUxRegistryPrompt = (missing = []) => {
-        const ledger = input.committedFacts
-            ? compactFrontendPlanLedgerContext({
-                committedFacts: input.committedFacts(),
-                requirementIds: allRequirementIds,
-                kinds: [
-                    "plan-requirement",
-                    "plan-verification-target",
-                    "state-registry",
-                ],
-            })
-            : "";
-        const compact = allRequirementIds.length > 0
-            ? compactFrontendPlanPromptForRequirementSlice(input.basePrompt, allRequirementIds, {
-                includeRequirementText: false,
-                includeVerificationTargets: false,
-                includeDesignEvidence: false,
-                includeChecklist: false,
-            })
-            : input.basePrompt;
-        return [
-            compact,
-            uxRegistrySegment.instruction,
-            ledger,
-            ...(missing.length > 0
-                ? [
-                    "MISSING-FACT QUEUE: commit the global UX registry, then re-check this phase:",
-                    ...missing.map((item) => `- ${item.reason}`),
-                ]
-                : []),
-        ].filter(Boolean).join("\n\n");
-    };
-    const buildCompactLocalPrompt = (missing = []) => {
-        const ledger = input.committedFacts
-            ? compactFrontendPlanLedgerContext({
-                committedFacts: input.committedFacts(),
-                requirementIds: allRequirementIds,
-                kinds: [
-                    "plan-requirement",
-                    "plan-verification-target",
-                    "state-registry",
-                    "component-choice",
-                    "state-flow",
-                ],
-            })
-            : "";
-        return [
-            compactFrontendPlanPromptForRequirementSlice(input.basePrompt, allRequirementIds),
-            "PLAN PHASE — compact local planning for a small frontend request.",
-            "Review all listed requirements together and record_state_registry first with one global UX vocabulary. Then record every plan-requirement and verification-target fact, followed by component/state-flow facts and the minimal route, Mock/data, dependency, and design-deviation policy facts needed by the observable behavior. Do not read the repository or task source; use only the committed input above. Do not call finalize_plan in this session.",
-            "TOOL-FIRST: your first assistant actions must be record_* tool calls, at most 2-3 facts per message. Do not draft the whole analysis before recording; if a fact is uncertain, record it with an evidence gap instead of reasoning longer.",
-            ledger,
-            ...(missing.length > 0
-                ? [
-                    "MISSING-FACT QUEUE: repair ONLY these items, then re-check the compact local phase:",
-                    ...missing.map((item) => `- ${item.kind}${item.id ? ` ${item.id}` : ""} for ${item.requirementIds.join(", ")}: ${item.reason}`),
-                ]
-                : []),
-        ].filter(Boolean).join("\n\n");
-    };
-    const mapPlannerExhaustion = (r, committedAnyFacts) => isPlannerThinkingExhausted(r, committedAnyFacts)
-        ? {
-            ...r,
-            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
-    // unscoped coverage session; a non-empty list enables deterministic sharding.
-    const requirementIdsProvided = input.requirementIds !== undefined && input.requirementIds.length > 0;
-    const pending = (input.requirementIds ?? []).filter((id) => !input.committedRequirementIds?.().has(id));
-    const initialMissing = requirementIdsProvided && input.committedFacts
-        ? collectFrontendPlanMissingFacts({
-            requirementIds: input.requirementIds,
-            committedFacts: input.committedFacts(),
-        })
-        : [];
-    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 compiledInput = parseFrontendInputBlock(input.basePrompt, "plan")?.payload;
-    const fullUnits = new Map(compiledInput?.requirements.map(r => [r.id, r]) ?? []);
-    const workCost = (ids) => 1 + ids.reduce((total, id) => total + Math.max(1, (input.requirementCosts?.get(id) ?? 2) - 1), 0);
-    const { workGroups, buildWorkBatches, compactEligible } = buildFrontendPlanWorkload({
-        basePrompt: input.basePrompt, requirementIds: allRequirementIds,
-        requirementCosts: input.requirementCosts, sessionOptions: input.sessionOptions,
-    });
-    // Data decisions are grouped by observable data domain. Requirements that
-    // mention the same endpoint/resource or execution group share one session;
-    // unrelated domains remain isolated. This prevents the old requirement-by-
-    // requirement repetition while preserving the packer's size bound.
-    const buildDataBatches = (ids) => {
-        const selected = new Set(ids);
-        const domains = new Map();
-        for (const [index, group] of workGroups.entries()) {
-            const members = group.requirementIds.filter((id) => selected.has(id));
-            if (!members.length)
-                continue;
-            const texts = members.map((id) => String(fullUnits.get(id)?.text ?? ""));
-            const endpoint = texts
-                .map((text) => text.match(/\b(?:GET|POST|PUT|PATCH|DELETE)\s+(\/[^\s,;.)]+)/i)?.[1])
-                .find(Boolean);
-            const resource = endpoint
-                ? endpoint.split("/").filter(Boolean).slice(0, 2).join("/")
-                : undefined;
-            const domain = resource ? `endpoint:${resource}` : `group:${group.id}`;
-            const current = domains.get(domain);
-            if (current) {
-                current.requirementIds.push(...members);
-                current.requirements.push(...members.map((id) => fullUnits.get(id) ?? { id }));
-                current.estimatedCalls = workCost(current.requirementIds);
-            }
-            else {
-                domains.set(domain, {
-                    id: `${index}:${domain}`,
-                    requirementIds: [...members],
-                    requirements: members.map((id) => fullUnits.get(id) ?? { id }),
-                    estimatedCalls: workCost(members),
-                });
-            }
-        }
-        const work = [...domains.values()];
-        // Work-unit packing and full provider envelope capacity have separate budgets.
-        return packFrontendInputUnits(work, {
-            targetBytes: input.sessionOptions.frontendExecutionPolicy?.scopeTargetBytes ?? FRONTEND_SCOPE_TARGET_BYTES,
-            maxUnits: input.sessionOptions.frontendExecutionPolicy?.maxScopeUnits ?? 4,
-            maxCost: FRONTEND_PLAN_COVERAGE_MAX_RECORD_CALLS,
-            cost: (group) => group.estimatedCalls,
-        }).map((batch) => batch.flatMap((group) => group.requirementIds));
-    };
-    // Dependency/deviation is optional policy. For a pure local UI request with
-    // no dependency, package, design-conflict, or OpenSpec signal, opening a
-    // dedicated model session only produces an empty policy fact. Keep the
-    // session when the prompt or ledger contains any such signal so this is a
-    // conservative skip, not a blanket removal of the gate.
-    const dependencyDeviationNeeded = /(?:dependenc|package\.json|npm\s+(?:install|i)|yarn\s+add|pnpm\s+add|openspec|design\s+conflict|规范冲突|依赖)/i.test(input.basePrompt) ||
-        Boolean(input.committedFacts?.().some((record) => {
-            const fact = committedFactFromPlanRecord(record);
-            return fact?.kind === "dependency" || fact?.kind === "design-deviation";
-        }));
-    const globalPolicyToolNames = new Set([
-        "record_route_selection",
-        "record_dependency",
-        "record_design_deviation",
-        "adopt_staged_fact",
-    ]);
-    const globalPolicyPrompt = [
-        "PLAN PHASE — global implementation policy.",
-        "Use the Scout target surface to record the selected route(s), then record dependency policy and design-evidence conflicts only when they are relevant. Do not record requirement-local UX or Mock/data facts. Do not call finalize_plan.",
-        dependencyDeviationNeeded
-            ? "Dependency/design policy signals are present; inspect them and commit the minimal policy facts needed."
-            : "No dependency/design-conflict signal was found; do not invent a policy fact.",
-    ].join(" ");
-    let globalPolicyQueued = false;
-    // Small, single-surface requests do not benefit from six isolated Pi
-    // sessions. Keep the typed ledger as the authority, but let one local
-    // session establish requirement/UX facts and one final session establish
-    // cross-cutting policy + finalize. The old sharded ladder remains available
-    // for larger plans and for the unscoped compatibility path.
-    const useCompactSmallPlan = requirementIdsProvided &&
-        input.compactSmallPlan === true &&
-        compactEligible;
-    if (useCompactSmallPlan) {
-        const compactLocalTools = new Set([
-            "record_plan_requirement",
-            "record_plan_group_coverage",
-            "record_plan_verification_target",
-            "record_plan_evidence_gap",
-            "record_state_registry",
-            "record_component_choice",
-            "record_state_flow",
-            "record_route_selection",
-            "record_data_flow",
-            "record_mock_api",
-            "record_mock_endpoint",
-            "record_dependency",
-            "record_design_deviation",
-            "adopt_staged_fact",
-        ]);
-        queue.push({
-            id: "compact-local",
-            toolNames: compactLocalTools,
-            requirementSlice: [...allRequirementIds],
-            prompt: buildCompactLocalPrompt(),
-        });
-    }
-    else if (!requirementIdsProvided) {
-        queue.push({
-            id: "coverage",
-            toolNames: coverageSegment.toolNames,
-            prompt: `${input.basePrompt}\n\n${coverageSegment.instruction}`,
-        });
-    }
-    else if (coverageWorkIds.length > 0) {
-        const completeBatches = buildWorkBatches(coverageWorkIds);
-        completeBatches.forEach((slice, batchIndex) => queue.push({
-            id: `coverage-batch-${batchIndex + 1}`,
-            toolNames: coverageSegment.toolNames,
-            coverageSlice: slice,
-            coverageOnly: true,
-            prompt: buildCoveragePrompt(slice),
-        }));
-    }
-    if (useCompactSmallPlan) {
-        // Compact mode already queued both sessions above.
-    }
-    else if (!input.parallelCoverageOnly) {
-        if (requirementIdsProvided) {
-            queue.push({
-                id: uxRegistrySegment.id,
-                toolNames: uxRegistrySegment.toolNames,
-                prompt: buildUxRegistryPrompt(),
-            });
-        }
-        const uxWorkIds = workGroups.filter(g => !["constraint", "exclusion"].includes(g.kind) || g.requirementIds.some(id => input.behaviorRequiredRequirementIds?.includes(id))).flatMap(g => g.requirementIds);
-        const uxBatches = requirementIdsProvided ? buildWorkBatches(uxWorkIds) : [[]];
-        uxBatches.forEach((slice, batchIndex) => queue.push({
-            id: `ux-local-${batchIndex + 1}`,
-            toolNames: requirementIdsProvided ? uxSegment.toolNames : new Set([...(uxSegment.toolNames ?? []), "record_state_registry"]),
-            ...(slice.length ? { requirementSlice: slice } : {}),
-            prompt: slice.length ? buildUxPrompt(slice) : buildPhasePrompt(uxSegment),
-        }));
-        for (const segment of FRONTEND_PLAN_SEGMENTS) {
-            if (["coverage", "ux-registry", "ux-local"].includes(segment.id))
-                continue;
-            if (segment.id === "global-dependency-deviation" && !dependencyDeviationNeeded)
-                continue;
-            if (segment.id === "global-route") {
-                if (globalPolicyQueued)
-                    continue;
-                globalPolicyQueued = true;
-                queue.push({
-                    id: "global-policy",
-                    toolNames: globalPolicyToolNames,
-                    prompt: `${buildPhasePrompt(segment)}\n\n${globalPolicyPrompt}`,
-                });
-                continue;
-            }
-            if (segment.id === "global-dependency-deviation")
-                continue;
-            if (segment.id === "global-mock-data" && requirementIdsProvided) {
-                buildDataBatches(allRequirementIds).forEach((slice, i) => queue.push({ id: `global-mock-data-${i + 1}`, toolNames: segment.toolNames, requirementSlice: slice, prompt: buildPhasePrompt(segment, [], slice) }));
-            }
-            else {
-                queue.push({
-                    id: segment.id,
-                    toolNames: segment.toolNames,
-                    prompt: buildPhasePrompt(segment),
-                });
-            }
-        }
-    }
-    let accumulated;
-    let index = 0;
-    let invocationCount = 0;
-    let lastDurableCount = input.committedFactCount();
-    while (index < queue.length) {
-        const session = queue[index];
-        if (!session)
-            break;
-        if (input.attempt > 1 && input.committedFacts && session.id === "ux-registry" &&
-            collectFrontendPlanPhaseMissingFacts({ phase: "ux-registry", requirementIds: allRequirementIds, committedFacts: input.committedFacts() }).length === 0) {
-            index += 1;
-            continue;
-        }
-        // Reuse complete UX scopes on node retry. Require explicit per-requirement
-        // ownership; an unrelated/global fact must not prove a slice complete.
-        if (input.attempt > 1 && input.committedFacts && session.id.startsWith("ux-local-") && session.requirementSlice?.length) {
-            const facts = input.committedFacts();
-            const ownedIds = new Set(facts.flatMap(value => {
-                const fact = committedFactFromPlanRecord(value);
-                return fact ? planFactStringList(fact.scopeRequirementIds) : [];
-            }));
-            const complete = session.requirementSlice.every(id => ownedIds.has(id)) &&
-                collectFrontendPlanPhaseMissingFacts({ phase: "ux-local", requirementIds: session.requirementSlice,
-                    committedFacts: facts, behaviorRequiredRequirementIds: input.behaviorRequiredRequirementIds }).length === 0;
-            if (complete) {
-                index += 1;
-                continue;
-            }
-        }
-        const remaining = (session.coverageOnly ? session.coverageSlice ?? [] : []).filter((id) => !input.committedRequirementIds?.().has(id));
-        const preexistingMissing = session.coverageOnly && session.coverageSlice && input.committedFacts
-            ? collectFrontendPlanMissingFacts({
-                requirementIds: session.coverageSlice,
-                committedFacts: input.committedFacts(),
-            })
-            : [];
-        // Resume/earlier-batch commits may already cover this slice.
-        if (session.coverageOnly &&
-            session.coverageSlice &&
-            remaining.length === 0 &&
-            preexistingMissing.length === 0) {
-            index += 1;
-            continue;
-        }
-        // Resume only unfinished UX scopes. The registry and local decisions are
-        // durable facts; replaying a completed scope wastes a model session and
-        // can make a previously valid shared decision look like a duplicate.
-        if (session.id === "ux-registry" &&
-            input.committedFacts &&
-            !collectFrontendPlanPhaseMissingFacts({
-                phase: "ux-registry",
-                requirementIds: allRequirementIds,
-                committedFacts: input.committedFacts(),
-            }).length) {
-            index += 1;
-            continue;
-        }
-        if (session.id.startsWith("ux-local-") &&
-            session.requirementSlice &&
-            (input.behaviorRequiredRequirementIds?.length ?? 0) > 0 &&
-            input.committedFacts &&
-            !collectFrontendPlanPhaseMissingFacts({
-                phase: "ux-local",
-                requirementIds: session.requirementSlice,
-                committedFacts: input.committedFacts(),
-                behaviorRequiredRequirementIds: input.behaviorRequiredRequirementIds,
-            }).length) {
-            index += 1;
-            continue;
-        }
-        let prompt = session.prompt;
-        if (session.coverageOnly && session.coverageSlice) {
-            const promptSlice = [...new Set([...remaining, ...preexistingMissing.flatMap(item => item.requirementIds)])];
-            prompt = buildCoveragePrompt(promptSlice, session.missingFacts ?? preexistingMissing);
-        }
-        else if (session.id === "compact-local") {
-            prompt = buildCompactLocalPrompt(session.missingFacts);
-        }
-        else if (session.id === "ux-registry") {
-            prompt = buildUxRegistryPrompt(session.missingFacts);
-        }
-        else if (session.id.startsWith("ux-local-")) {
-            // Build this at execution time: coverage facts are committed by the
-            // preceding sessions and must be visible to the UX-local model.
-            prompt = session.requirementSlice
-                ? buildUxPrompt(session.requirementSlice, session.missingFacts)
-                : buildPhasePrompt(uxSegment, session.missingFacts);
-        }
-        else {
-            // Global phases consume the latest committed ledger;
-            // constructing their prompt only when the session starts prevents a
-            // stale queue entry from dropping facts written by earlier phases.
-            const segment = FRONTEND_PLAN_SEGMENTS.find((candidate) => candidate.id === session.id || (candidate.id === "global-mock-data" && session.id.startsWith("global-mock-data-")));
-            if (session.id === "global-policy") {
-                const routePrompt = buildPhasePrompt(FRONTEND_PLAN_SEGMENTS.find((candidate) => candidate.id === "global-route"));
-                prompt = `${routePrompt}\n\n${globalPolicyPrompt}`;
-            }
-            else if (segment) {
-                prompt = buildPhasePrompt(segment, session.missingFacts, session.requirementSlice ?? allRequirementIds);
-            }
-        }
-        const atomicFocus = session.atomicRecovery ? session.missingFacts?.[0] : undefined;
-        if (atomicFocus) {
-            prompt = [
-                compactFrontendPlanPromptForRequirementSlice(input.basePrompt, atomicFocus.requirementIds, {
-                    includeChecklist: false,
-                    ...(atomicFocus.kind === "plan-verification-target" && atomicFocus.id
-                        ? { verificationTargetIds: [atomicFocus.id] } : {}),
-                }),
-                `ATOMIC FACT: ${atomicFocus.kind}${atomicFocus.id ? ` ${atomicFocus.id}` : ""}`,
-                atomicFocus.reason,
-                "Commit ONLY this missing fact with one record_* call, then end this session. Other facts are queued separately. Preserve canonical IDs and shared bindings; use read_plan_facts for existing values. Do not summarize or plan the entire requirement. Capacity exhaustion is not evidence of a requirement gap.",
-            ].join("\n\n");
-        }
-        const committedBefore = input.committedFactCount();
-        input.setActiveRequirementScope?.(session.coverageOnly ? session.coverageSlice ?? [] : session.requirementSlice ?? []);
-        if (invocationCount >= FRONTEND_PLAN_BATCH_MAX_SESSIONS)
-            break;
-        invocationCount += 1;
-        const atomicTools = {
-            "plan-requirement": "record_plan_requirement", "plan-verification-target": "record_plan_verification_target",
-            "state-registry": "record_state_registry", "component-choice": "record_component_choice",
-            "state-flow": "record_state_flow", "data-flow": "record_data_flow", "mock-api": "record_mock_api",
-        };
-        const customTools = input.segmentCustomTools(atomicFocus ? new Set([atomicTools[atomicFocus.kind]]) : session.toolNames);
-        const result = await observeFrontendSession({
-            ...input.observation, phase: `plan/${session.id}`, dispatchReason: (session.retryCount ?? 0) > 0 || !!session.missingFacts?.length || /capacity|recovery|split/.test(session.id) ? "correction" : "initial", scopeIds: session.requirementSlice ?? session.coverageSlice ?? allRequirementIds,
-            prompt, userMessage: input.sessionOptions.userMessage, customTools, committedCount: input.committedFactCount, durableCommittedCount: () => lastDurableCount,
-            artifactPath: input.observation?.artifactPath ? `${input.observation.artifactPath}-${invocationCount}.json` : undefined,
-        }, async (observer) => {
-            const result = await input.piStepFn({
-                ...input.sessionOptions,
-                onAttemptObservation: observer,
-                prompt,
-                ...(customTools.length > 0
-                    ? {
-                        writerToolPolicy: {
-                            requireSdk: true,
-                            customTools,
-                        },
-                    }
-                    : {}),
-            });
-            try {
-                await input.flushLedger();
-                lastDurableCount = input.committedFactCount();
-            }
-            catch {
-                // best-effort: the node-level flush runs again after the attempt
-            }
-            return result;
-        });
-        accumulated = accumulated
-            ? combineSequentialPiResults(accumulated, result)
-            : result;
-        const committedAfter = input.committedFactCount();
-        const committedFactsOnlySuccess = !(result.assistantText ?? "").trim() &&
-            !result.stderr.trim() &&
-            !result.timedOut &&
-            committedAfter > committedBefore;
-        const missingCoverage = session.coverageOnly && session.coverageSlice && input.committedFacts
-            ? collectFrontendPlanMissingFacts({
-                requirementIds: session.coverageSlice,
-                committedFacts: input.committedFacts(),
-            })
-            : [];
-        const isCompactLocalSession = session.id === "compact-local";
-        const isUxRegistrySession = session.id === "ux-registry";
-        const isUxLocalSession = session.id.startsWith("ux-local-");
-        const missingPhase = isCompactLocalSession && input.committedFacts
-            ? [
-                ...collectFrontendPlanMissingFacts({
-                    requirementIds: allRequirementIds,
-                    committedFacts: input.committedFacts(),
-                }),
-                ...collectFrontendPlanPhaseMissingFacts({
-                    phase: "ux-registry",
-                    requirementIds: allRequirementIds,
-                    committedFacts: input.committedFacts(),
-                }),
-                ...collectFrontendPlanPhaseMissingFacts({
-                    phase: "ux-local",
-                    requirementIds: allRequirementIds,
-                    committedFacts: input.committedFacts(),
-                    behaviorRequiredRequirementIds: input.behaviorRequiredRequirementIds,
-                }),
-            ]
-            : isUxRegistrySession && input.committedFacts
-                ? collectFrontendPlanPhaseMissingFacts({
-                    phase: "ux-registry",
-                    requirementIds: allRequirementIds,
-                    committedFacts: input.committedFacts(),
-                })
-                : isUxLocalSession && session.requirementSlice && input.committedFacts
-                    ? collectFrontendPlanPhaseMissingFacts({
-                        phase: "ux-local",
-                        requirementIds: session.requirementSlice,
-                        committedFacts: input.committedFacts(),
-                        behaviorRequiredRequirementIds: input.behaviorRequiredRequirementIds,
-                    })
-                    : session.id.startsWith("global-mock-data") && allRequirementIds.length > 0 && input.committedFacts
-                        ? collectFrontendPlanPhaseMissingFacts({
-                            phase: "global-mock-data",
-                            requirementIds: session.requirementSlice ?? allRequirementIds,
-                            committedFacts: input.committedFacts(),
-                        })
-                        : [];
-        const missingPhaseFacts = [...missingCoverage, ...missingPhase];
-        // Frozen verification commands must operate on files the planner has
-        // committed verification targets for; otherwise the admission writeSet
-        // cannot authorize the file and verify-shell deterministically fails.
-        const verificationCommandFiles = collectFrontendVerificationCommandFiles(input.basePrompt);
-        if (verificationCommandFiles.length > 0 && allRequirementIds.length > 0 && input.committedFacts) {
-            const coveredVerificationFiles = new Set(input
-                .committedFacts()
-                .map(committedFactFromPlanRecord)
-                .filter((fact) => Boolean(fact && fact.origin === "plan" && fact.kind === "plan-verification-target"))
-                .map((fact) => fact.entry?.file)
-                .filter((file) => typeof file === "string"));
-            for (const file of verificationCommandFiles) {
-                if (coveredVerificationFiles.has(file))
-                    continue;
-                missingPhaseFacts.push({
-                    kind: "plan-verification-target",
-                    id: file,
-                    requirementIds: allRequirementIds.slice(0, 1),
-                    reason: `frozen verification command references ${file} but no committed verification target covers it; record a static verification target for this file so it joins the writeSet`,
-                });
-            }
-        }
-        const promptForMissingPhase = (missing) => session.coverageOnly
-            ? buildCoveragePrompt(session.coverageSlice ?? [], missing)
-            : isCompactLocalSession
-                ? buildCompactLocalPrompt(missing)
-                : isUxRegistrySession
-                    ? buildUxRegistryPrompt(missing)
-                    : isUxLocalSession
-                        ? buildUxPrompt(session.requirementSlice ?? [], missing)
-                        : buildPhasePrompt(globalMockDataSegment, missing, session.requirementSlice ?? allRequirementIds);
-        const recovery = classifyFrontendPlanRecovery({ ...result, stopReason: readWriterThinkingExhaustionEvidence(result).stopReason });
-        if (recovery === "stop")
-            return { ...result, ok: false };
-        if ((recovery === "output" || (session.atomicRecovery && result.ok)) && input.committedFacts &&
-            !(missingPhaseFacts.length === 1 && missingPhaseFacts[0]?.kind === "plan-requirement") &&
-            (session.coverageOnly || isUxRegistrySession || isUxLocalSession || session.id.startsWith("global-mock-data"))) {
-            if (missingPhaseFacts.length === 0) {
-                // A complete validated slice does not need a successful prose turn.
-                // This never accepts finalize or bypasses the final contract validator.
-                accumulated = { ...accumulated, ok: true, failureCategory: "success" };
-                index += 1;
-                continue;
-            }
-            const missingIds = [...new Set(missingPhaseFacts.flatMap(item => item.requirementIds))];
-            const scope = session.coverageSlice ?? session.requirementSlice;
-            if (scope && missingIds.length < scope.length) {
-                queue[index] = { ...session, missingFacts: missingPhaseFacts,
-                    ...(session.coverageOnly ? { coverageSlice: missingIds } : { requirementSlice: missingIds }),
-                    retryCount: 0 };
-                continue;
-            }
-            if (scope && missingIds.length > 1 && (session.coverageOnly || isUxLocalSession)) {
-                const half = Math.ceil(missingIds.length / 2);
-                queue.splice(index, 1, ...[missingIds.slice(0, half), missingIds.slice(half)].map(ids => ({
-                    ...session, retryCount: 0,
-                    ...(session.coverageOnly ? { coverageSlice: ids } : { requirementSlice: ids }),
-                    missingFacts: missingPhaseFacts.filter(item => item.requirementIds.some(id => ids.includes(id))),
-                })));
-                continue;
-            }
-            const focusStillMissing = atomicFocus && missingPhaseFacts.some(item => item.kind === atomicFocus.kind && item.id === atomicFocus.id &&
-                item.requirementIds.join("\0") === atomicFocus.requirementIds.join("\0"));
-            const retries = focusStillMissing ? (session.retryCount ?? 0) + 1 : 0;
-            if (retries < 2) {
-                queue[index] = { ...session, atomicRecovery: true, missingFacts: missingPhaseFacts, retryCount: retries };
-                continue;
-            }
-            return { ...accumulated, ok: false, failureCategory: OUTPUT_LIMIT_RETRY_CATEGORY,
-                stderr: `${accumulated.stderr}\nfrontend plan capacity recovery exhausted: preserve committed facts; phase=${session.id}; scope=${missingIds.join(",")}; strategy=atomic-fact; missing=${JSON.stringify(missingPhaseFacts)}`.trim() };
-        }
-        const capacityExhausted = recovery === "output" || recovery === "context";
-        if (capacityExhausted && !result.timedOut) {
-            const failure = () => mapPlannerExhaustion({ ...result, ok: false, stderr: `${result.stderr}\nFRONTEND_INPUT_UNIT_TOO_LARGE: ${session.id}; no smaller complete scope can finish; unchanged retries are disabled` }, committedAfter > committedBefore);
-            const missingCoverageIds = input.committedFacts ? [...new Set(collectFrontendPlanMissingFacts({ requirementIds: session.coverageSlice ?? session.requirementSlice ?? allRequirementIds, committedFacts: input.committedFacts() }).flatMap(f => f.requirementIds))] : [...(session.coverageSlice ?? session.requirementSlice ?? allRequirementIds)];
-            const splitScope = (ids, allowMemberSplit) => {
-                const groups = workGroups.map(g => g.requirementIds.filter(id => ids.includes(id))).filter(g => g.length);
-                if (groups.length > 1) {
-                    const half = Math.ceil(groups.length / 2);
-                    return [groups.slice(0, half).flat(), groups.slice(half).flat()];
-                }
-                if (allowMemberSplit && ids.length > 1) {
-                    const half = Math.ceil(ids.length / 2);
-                    return [ids.slice(0, half), ids.slice(half)];
-                }
-                return [];
-            };
-            if (isCompactLocalSession) {
-                let scopes = splitScope(missingCoverageIds, true);
-                if (!scopes.length && missingCoverageIds.length) {
-                    if (missingCoverageIds.length === allRequirementIds.length && committedAfter === committedBefore)
-                        return failure();
-                    scopes = [missingCoverageIds];
-                }
-                // UX ownership is independent of coverage completion. Preserve all groups.
-                const recovery = scopes.map((slice, i) => ({ id: `coverage-capacity-${invocationCount}-${i}`, coverageOnly: true, coverageSlice: slice, toolNames: coverageSegment.toolNames, prompt: buildCoveragePrompt(slice) }));
-                recovery.push({ id: "ux-registry", toolNames: uxRegistrySegment.toolNames, prompt: buildUxRegistryPrompt() });
-                recovery.push(...buildWorkBatches([...allRequirementIds]).map((slice, i) => ({ id: `ux-local-capacity-${invocationCount}-${i}`, requirementSlice: slice, toolNames: uxSegment.toolNames, prompt: buildUxPrompt(slice) })));
-                queue.splice(index, 1, ...recovery);
-                continue;
-            }
-            if (session.coverageOnly || isUxLocalSession) {
-                const missingIds = session.coverageOnly ? missingCoverageIds : [...new Set(missingPhase.flatMap(f => f.requirementIds))];
-                if (!missingIds.length) {
-                    index += 1;
-                    continue;
-                }
-                const scopes = splitScope(missingIds, Boolean(session.coverageOnly));
-                if (scopes.length) {
-                    queue.splice(index, 1, ...scopes.map(slice => ({ ...session, ...(session.coverageOnly ? { coverageSlice: slice } : { requirementSlice: slice }), missingFacts: missingPhaseFacts.filter(f => f.requirementIds.some(id => slice.includes(id))), retryCount: 0 })));
-                    continue;
-                }
-                const originalIds = session.coverageSlice ?? session.requirementSlice ?? [];
-                if ((missingIds.length < originalIds.length || committedAfter > committedBefore) && (session.retryCount ?? 0) < 2) {
-                    queue[index] = { ...session, ...(session.coverageOnly ? { coverageSlice: missingIds } : { requirementSlice: missingIds }), missingFacts: missingPhaseFacts, retryCount: (session.retryCount ?? 0) + 1 };
-                    continue;
-                }
-            }
-            return failure();
-        }
-        if (result.ok) {
-            if (missingPhaseFacts.length === 0) {
-                index += 1;
-                continue;
-            }
-            if ((session.retryCount ?? 0) < 2) {
-                queue[index] = {
-                    ...session,
-                    retryCount: (session.retryCount ?? 0) + 1,
-                    missingFacts: missingPhaseFacts,
-                    prompt: promptForMissingPhase(missingPhaseFacts),
-                };
-                continue;
-            }
-            return {
-                ...accumulated,
-                ok: false,
-                stderr: `${accumulated.stderr}\nfrontend plan completeness check failed: ${missingPhaseFacts.map((item) => item.reason).join("; ")}`.trim(),
-                failureCategory: "invalid-output",
-            };
-        }
-        if (committedFactsOnlySuccess) {
-            // The session died but banked facts: keep the progress and move on.
-            if (missingPhaseFacts.length > 0 && (session.retryCount ?? 0) < 2) {
-                queue[index] = {
-                    ...session,
-                    retryCount: (session.retryCount ?? 0) + 1,
-                    missingFacts: missingPhaseFacts,
-                    prompt: promptForMissingPhase(missingPhaseFacts),
-                };
-                continue;
-            }
-            if (missingPhaseFacts.length > 0) {
-                return {
-                    ...accumulated,
-                    ok: false,
-                    stderr: `${accumulated.stderr}\nfrontend plan completeness check failed: ${missingPhaseFacts.map((item) => item.reason).join("; ")}`.trim(),
-                    failureCategory: "invalid-output",
-                };
-            }
-            index += 1;
-            continue;
-        }
-        // Option 5: a multi-requirement coverage batch that failed with ZERO
-        // new facts and no provider stderr is the upfront-reasoning burn —
-        // halve the slice and retry instead of failing the attempt. The compact
-        // local session participates through its requirementSlice so a
-        // thinking-burned small plan degrades into smaller batched sessions
-        // instead of replaying one full-scope prompt until the repair budget
-        // runs out.
-        const coverageSlice = session.coverageOnly
-            ? session.coverageSlice
-            : isCompactLocalSession
-                ? session.requirementSlice
-                : undefined;
-        const zeroProgressBurn = coverageSlice !== undefined &&
-            coverageSlice.length > 1 &&
-            (capacityExhausted || (["empty-output", "unknown"].includes(result.failureCategory) && committedAfter === committedBefore && !(result.assistantText ?? "").trim() && !result.stderr.trim())) &&
-            !result.timedOut;
-        if (zeroProgressBurn && coverageSlice) {
-            const missingIds = input.committedFacts ? new Set(collectFrontendPlanMissingFacts({ requirementIds: coverageSlice, committedFacts: input.committedFacts() }).flatMap(f => f.requirementIds)) : undefined;
-            const unfinished = coverageSlice.filter(id => !missingIds || missingIds.has(id));
-            if (unfinished.length <= 1)
-                return mapPlannerExhaustion({ ...result, ok: false, stderr: `${result.stderr}\nFRONTEND_INPUT_UNIT_TOO_LARGE: ${unfinished[0] ?? session.id}; no smaller complete scope can finish` }, committedAfter > committedBefore);
-            const half = Math.ceil(unfinished.length / 2);
-            const firstSlice = unfinished.slice(0, half);
-            const secondSlice = unfinished.slice(half);
-            if (isCompactLocalSession) {
-                queue.splice(index + 1, 0, { id: "ux-registry", toolNames: uxRegistrySegment.toolNames, prompt: buildUxRegistryPrompt() }, ...buildWorkBatches([...firstSlice, ...secondSlice]).map((slice, i) => ({ id: `ux-local-recovery-${i}`, toolNames: uxSegment.toolNames, requirementSlice: slice, prompt: buildUxPrompt(slice) })));
-                // The split halves leave compact mode: continue them as ordinary
-                // coverage sessions so every downstream ladder branch applies.
-                queue.splice(index, 1, {
-                    ...session,
-                    id: `coverage-compact-split-1`,
-                    toolNames: coverageSegment.toolNames, retryCount: 0,
-                    coverageOnly: true,
-                    coverageSlice: firstSlice,
-                    requirementSlice: firstSlice,
-                    prompt: buildCoveragePrompt(firstSlice),
-                }, {
-                    ...session,
-                    id: `coverage-compact-split-2`,
-                    toolNames: coverageSegment.toolNames, retryCount: 0,
-                    coverageOnly: true,
-                    coverageSlice: secondSlice,
-                    requirementSlice: secondSlice,
-                    prompt: buildCoveragePrompt(secondSlice),
-                });
-                continue;
-            }
-            queue.splice(index, 1, {
-                ...session,
-                coverageSlice: firstSlice,
-                prompt: buildCoveragePrompt(firstSlice),
-            }, {
-                ...session,
-                coverageSlice: secondSlice,
-                prompt: buildCoveragePrompt(secondSlice),
-            });
-            continue;
-        }
-        if (readWriterThinkingExhaustionEvidence(result).stopReason === "length" || ["context-overflow", "context-budget-exhausted"].includes(result.failureCategory))
-            return mapPlannerExhaustion({ ...result, ok: false, stderr: `${result.stderr}\nFRONTEND_INPUT_UNIT_TOO_LARGE: ${session.id}; refine the remaining complete scope; unchanged retries are disabled` }, committedAfter > committedBefore);
-        if ((session.coverageOnly || isUxRegistrySession || isUxLocalSession || session.id.startsWith("global-mock-data")) &&
-            missingPhaseFacts.length > 0 &&
-            !result.stderr.trim() &&
-            !result.timedOut &&
-            (session.retryCount ?? 0) < 2) {
-            queue[index] = {
-                ...session,
-                retryCount: (session.retryCount ?? 0) + 1,
-                missingFacts: missingPhaseFacts,
-                prompt: promptForMissingPhase(missingPhaseFacts),
-            };
-            continue;
-        }
-        return mapPlannerExhaustion(accumulated, committedAfter > committedBefore);
-    }
-    if (index < queue.length) {
-        return {
-            ...(accumulated ?? {
-                ok: false,
-                stdout: "",
-                stderr: "",
-                assistantText: "",
-                command: [],
-                durationMs: 0,
-                exitCode: null,
-                failureCategory: "invalid-output",
-                modelDisplay: "unknown",
-                parsedEvents: 0,
-                timedOut: false,
-                attemptedModels: [],
-                fallbackUsed: false,
-                tokensUsed: 0,
-            }),
-            ok: false,
-            stderr: `${accumulated?.stderr ?? ""}\nfrontend plan segmentation exceeded the ${FRONTEND_PLAN_BATCH_MAX_SESSIONS}-session safety limit before finalize`.trim(),
-            failureCategory: "invalid-output",
-        };
-    }
-    if (!input.parallelCoverageOnly && input.finalizePlan) {
-        // Preserve optional closeout context if an earlier correction or future
-        // ledger producer committed it. The old model-only finalize session was
-        // the only writer of these fields; runtime-owned finalization must not
-        // silently erase them when they are already available.
-        const optionalPlanFields = {};
-        for (const record of input.committedFacts?.() ?? []) {
-            const fact = committedFactFromPlanRecord(record);
-            if (!fact)
-                continue;
-            if (Array.isArray(fact.residualRisks)) {
-                optionalPlanFields.residualRisks = fact.residualRisks.filter((item) => typeof item === "string" && item.trim().length > 0);
-            }
-            if (typeof fact.realIntegrationGap === "string" && fact.realIntegrationGap.trim()) {
-                optionalPlanFields.realIntegrationGap = fact.realIntegrationGap;
-            }
-        }
-        let finalizationCount = 0;
-        const finalize = () => observeFrontendFinalization({
-            ...input.observation,
-            artifactPath: input.observation?.artifactPath ? `${input.observation.artifactPath}-runtime-finalize-${++finalizationCount}.json` : undefined,
-        }, () => input.finalizePlan(optionalPlanFields));
-        let finalizeResult = await finalize();
-        const finalizeDetails = finalizeResult && typeof finalizeResult === "object"
-            ? (finalizeResult.details ?? finalizeResult)
-            : finalizeResult;
-        if (!finalizeDetails ||
-            typeof finalizeDetails !== "object" ||
-            finalizeDetails.ok !== true) {
-            // Normal plans never open a finalize model session. Keep the old
-            // correction/recovery semantic only for a rejected deterministic
-            // compile: give the planner one bounded repair pass, then retry the
-            // same runtime authority. The correction prompt explicitly forbids
-            // calling finalize_plan, so terminal ownership remains deterministic.
-            const correctionPrompt = [
-                input.basePrompt,
-                "PLAN FINALIZE CORRECTION — the runtime compile rejected the committed ledger.",
-                `Runtime error: ${String(finalizeDetails?.error ?? "plan finalize rejected")}`,
-                "Repair only the reported facts with the typed record_* tools. Do not call finalize_plan; the runtime will retry it after this correction.",
-                input.committedFacts ? compactFrontendPlanLedgerContext({ committedFacts: input.committedFacts(), requirementIds: input.requirementIds ?? [], kinds: ["plan-requirement", "plan-verification-target", "state-registry", "component-choice", "state-flow", "data-flow", "mock-api", "design-deviation", "dependency", "target-surface"] }) : "",
-            ].filter(Boolean).join("\n\n");
-            input.setActiveRequirementScope?.([]);
-            const correctionTools = input.segmentCustomTools(null);
-            const correction = await observeFrontendSession({
-                ...input.observation, phase: "plan/finalize-correction", dispatchReason: "correction",
-                scopeIds: input.requirementIds, prompt: correctionPrompt, userMessage: input.sessionOptions.userMessage,
-                customTools: correctionTools, committedCount: input.committedFactCount, durableCommittedCount: () => lastDurableCount,
-                artifactPath: input.observation?.artifactPath ? `${input.observation.artifactPath}-finalize-correction.json` : undefined,
-            }, async (observer) => {
-                const result = await input.piStepFn({
-                    ...input.sessionOptions, onAttemptObservation: observer, prompt: correctionPrompt,
-                    writerToolPolicy: { requireSdk: true, customTools: correctionTools },
-                });
-                try {
-                    await input.flushLedger();
-                    lastDurableCount = input.committedFactCount();
-                }
-                catch { /* node-level flush retries below */ }
-                return result;
-            });
-            accumulated = accumulated
-                ? combineSequentialPiResults(accumulated, correction)
-                : correction;
-            if (!correction.ok && !["invalid-output", "empty-output", "success"].includes(correction.failureCategory))
-                return { ...accumulated, ok: false, failureCategory: correction.failureCategory };
-            if (correction.ok) {
-                finalizeResult = await finalize();
-            }
-            const retriedDetails = finalizeResult && typeof finalizeResult === "object"
-                ? (finalizeResult.details ?? finalizeResult)
-                : finalizeResult;
-            if (retriedDetails && typeof retriedDetails === "object" && retriedDetails.ok === true) {
-                return mapPlannerExhaustion(accumulated ?? { ok: true, stdout: "", stderr: "", assistantText: "", command: [], durationMs: 0, exitCode: 0, failureCategory: "success", modelDisplay: "runtime-finalize", parsedEvents: 0, timedOut: false, attemptedModels: [], fallbackUsed: false, tokensUsed: 0 }, true);
-            }
-            const detail = retriedDetails && typeof retriedDetails === "object"
-                ? String(retriedDetails.error ?? "plan finalize rejected")
-                : "plan finalize rejected";
-            return {
-                ...(accumulated ?? {
-                    ok: false,
-                    stdout: "",
-                    stderr: "",
-                    assistantText: "",
-                    command: [],
-                    durationMs: 0,
-                    exitCode: null,
-                    failureCategory: "invalid-output",
-                    modelDisplay: "unknown",
-                    parsedEvents: 0,
-                    timedOut: false,
-                    attemptedModels: [],
-                    fallbackUsed: false,
-                    tokensUsed: 0,
-                }),
-                ok: false,
-                stderr: `${accumulated?.stderr ?? ""}\nfrontend plan deterministic finalize failed: ${detail}`.trim(),
-                failureCategory: "invalid-output",
-            };
-        }
-    }
-    return mapPlannerExhaustion(accumulated ?? {
-        ok: false,
-        stdout: "",
-        stderr: "frontend plan segmentation produced no session",
-        failureCategory: "empty-output",
-        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
@@ -3597,199 +1721,11 @@ export async function runFrontendPlanSegmentedSessions(input) {
  * 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 existing test entrypoints. Inspect project source/config first; do not recursively explore dependency internals merely to reconfirm standard test-runner behavior. If a concrete required capability cannot be established from project evidence, report the precise gap.",
-                "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 project-owned frontend framework, styling/theme conventions, reusable components, and relevant design/spec files. The surface shard owns test-runner/environment discovery; do not duplicate its Vitest/happy-dom investigation. Stop discovery once the design evidence is sufficient and commit it.",
-                "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) => {
-        const cacheKey = JSON.stringify([input.runDir, input.nodeId, shard.id, input.sessionOptions.modelConfig, input.observation?.model, input.observation?.sourceDigest, input.sourceDeclaredPaths]);
-        const cached = input.completedShards?.get(cacheKey);
-        if (cached)
-            return { shard, facts: cached.facts, result: { ...cached.result, durationMs: 0, tokensUsed: 0, parsedEvents: 0, attemptedModels: [], fallbackUsed: false } };
-        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"),
-            };
-            const prompt = `${input.basePrompt}\n\n${shard.instruction}`;
-            const tools = [...customTools, ...(input.readBudgetTools ?? [])];
-            shardResult = await observeFrontendSession({
-                ...input.observation,
-                phase: `scout/parallel/${shard.id}`,
-                scopeIds: [shard.id],
-                prompt,
-                userMessage: sessionOptions.userMessage,
-                customTools: tools,
-                artifactPath: input.observation?.artifactPath ? `${input.observation.artifactPath}-${shard.id}.json` : undefined,
-                committedCount: () => shardTools?.committedFacts().length ?? 0,
-                durableCommittedCount: () => shardTools?.committedFacts().length ?? 0,
-            }, observer => input.piStepFn({
-                ...sessionOptions,
-                onAttemptObservation: observer,
-                prompt,
-                writerToolPolicy: {
-                    requireSdk: true,
-                    customTools: tools,
-                },
-            }));
-            await shardTools.flush();
-            const facts = shardTools.committedFacts();
-            const expectedKind = shard.id === "design" ? "design-evidence" : "target-surface";
-            if (shardResult.ok && facts.some(record => { const fact = record.fact; return fact.kind === expectedKind && (shard.id !== "surface" || fact.completeness === "complete"); })) {
-                input.completedShards?.set(cacheKey, { result: structuredClone(shardResult), facts: structuredClone(facts) });
-            }
-            return { shard, result: shardResult, tools: shardTools, facts };
-        }
-        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) {
-                await input.mainTools.adoptCommittedFacts(outcome.facts ?? 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.facts ?? 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));
-}
+/**
+ * 主执行入口：四个阶段顺序组织（准备 → 会话执行 → 写证据判定 → 结果映射）。
+ * 阶段边界即函数内注释界碑；进一步函数级拆分需把跨阶段可变状态打包为显式
+ * state 对象，属高风险机械改写，暂缓（见执行计划 Step 5 决策）。
+ */
 export async function executeDagPiNode(input, meta, piStepFn = executePiStep, writeGuardDependencies = DEFAULT_DAG_PI_WRITE_GUARD_DEPENDENCIES) {
     const started = Date.now();
     const persona = resolveDagPiPersona(input.task);
@@ -4971,6 +2907,7 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
         }
         return mapped;
     }
+    // ── 阶段 3/4：写证据判定（write guard / 变更清单 / writerOutcome / completeness）──
     let writeGuardOk = true;
     let writeGuardViolations = [];
     let changeManifestAfterStatus;