@tea-agent/loop-agent 0.43.0-next.1 → 0.43.0-next.2

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

@@ -1,3 +1,8 @@
+import { collectFrontendExecutionGroups, frontendExecutionSchema } from "../workflows/dag/frontend-execution-groups.js";
+import { FRONTEND_SCOPE_TARGET_BYTES, packFrontendInputUnits, parseFrontendInputBlock, projectFrontendContractPrompt, projectFrontendInputScope } from "../workflows/dag/frontend-input-projection.js";
+import { createDurableFrontendTools } from "../workflows/dag/frontend-durable-tools.js";
+import { createFrontendReviewScopeProtocol, loadFrontendReviewScopes } from "../workflows/dag/frontend-review-scopes.js";
+import { observeFrontendSession } from "../workflows/dag/frontend-session-budget.js";
 import path from "node:path";
 import { createHash, randomUUID } from "node:crypto";
 import { readFile, stat } from "node:fs/promises";
@@ -454,6 +459,7 @@ export const FRONTEND_CONTRACT_RECORD_TOOL_NAMES = [
     "record_split_proposal",
     "record_ui_state",
     "record_required_deliverables",
+    "complete_contract_scope",
 ];
 export const FRONTEND_CONTRACT_TERMINAL_TOOL_NAMES = [
     "finalize_contract",
@@ -471,9 +477,11 @@ export const FRONTEND_PLAN_RECORD_TOOL_NAMES = [
     "record_state_flow",
     "record_data_flow",
     "record_mock_api",
+    "record_mock_endpoint",
     "record_design_deviation",
     "record_dependency",
     "record_plan_requirement",
+    "record_plan_group_coverage",
     "record_plan_verification_target",
     "record_plan_evidence_gap",
 ];
@@ -548,6 +556,7 @@ export function resolveDagPiToolNames(task) {
     if (isFrontendReviewTypedTerminalNode(task)) {
         return [
             ...DAG_PI_READONLY_TOOLS,
+            "record_review_finding",
             "approve_review",
             "request_review_changes",
         ];
@@ -555,6 +564,7 @@ export function resolveDagPiToolNames(task) {
     if (isFrontendDesignTypedTerminalNode(task)) {
         return [
             ...DAG_PI_READONLY_TOOLS,
+            "record_design_finding",
             "approve_design",
             "request_design_changes",
         ];
@@ -759,21 +769,35 @@ export async function createFrontendReviewTerminalTools(input) {
     ]);
     const { approveReviewFactSchema, readCommittedEvents, requestReviewChangesFactSchema, writeTypedEventStoreJsonl, } = await import("../workflows/dag/frontend-typed-event-store.js");
     const { adoptTypedEventFact, stageTypedEventFact } = await import("../workflows/dag/frontend-typed-event-transaction.js");
-    const store = input.store;
+    let store = input.store;
     const attemptId = input.attemptId;
     const findingSchema = Type.Object({
-        severity: Type.String({
-            description: "Critical | Important | Minor | Info",
-        }),
-        file: Type.Optional(Type.String({})),
-        line: Type.Optional(Type.Number({})),
-        issue: Type.String({}),
-        requiredChange: Type.Optional(Type.String({})),
+        severity: Type.Enum({ Critical: "Critical", Important: "Important", Minor: "Minor", Info: "Info" }),
+        file: Type.Optional(Type.String({ minLength: 1 })),
+        line: Type.Optional(Type.Integer({ minimum: 1 })),
+        issue: Type.String({ minLength: 1 }),
+        requiredChange: Type.Optional(Type.String({ minLength: 1 })),
     }, { additionalProperties: false });
+    const scopeProtocol = createFrontendReviewScopeProtocol({ phase: "review", inventory: input.inventory, getStore: () => store, attemptId });
+    const savedFindings = () => [...new Map(readCommittedEvents(store, attemptId).filter(r => r.fact.kind === "review-finding").map(r => [r.fact.id, r.fact.finding])).values()];
+    const allFindings = (direct) => [...new Map([...savedFindings(), ...(Array.isArray(direct) ? direct : [])].map(finding => [JSON.stringify(finding), finding])).values()];
+    const recordFindingTool = defineTool({
+        name: "record_review_finding", label: "record_review_finding",
+        description: "Save one finding with a stable id. Submit findings incrementally, then finalize without repeating the findings array. Saved blocking findings cannot be omitted from approval; correct a finding explicitly with replace:true.",
+        parameters: Type.Object({ id: Type.String({ minLength: 1 }), finding: findingSchema }, { additionalProperties: false }),
+        async execute(_callId, params) {
+            const fact = { kind: "review-finding", id: params.id, finding: params.finding };
+            const requestId = `${attemptId}:finding:${randomUUID()}`;
+            const staged = stageTypedEventFact({ store, requestId, attemptId, fact });
+            const adopted = await adoptTypedEventFact({ store, requestId, attemptId, fact, eventId: staged.eventId, expectedRevision: store.revision });
+            const details = { ok: true, eventId: adopted.eventId, revision: adopted.revision };
+            return { content: [{ type: "text", text: JSON.stringify(details) }], details };
+        },
+    });
     const approveParameters = Type.Object({
-        findings: Type.Array(findingSchema, {
+        findings: Type.Optional(Type.Array(findingSchema, {
             description: "Optional informational findings (Minor/Info only; no Critical/Important on approval)",
-        }),
+        })),
     }, { additionalProperties: false });
     const requestParameters = Type.Object({
         issueCategory: Type.Enum({
@@ -783,16 +807,17 @@ export async function createFrontendReviewTerminalTools(input) {
             "contract-requirement-gap": "contract-requirement-gap",
             "unknown": "unknown",
         }, { description: "Typed issue category (five-value enum)" }),
-        evidenceRefs: Type.Array(Type.String({}), {
-            description: "Evidence refs (paths or artifact ids); at least one",
-        }),
-        findings: Type.Array(findingSchema, {
-            description: "At least one finding",
+        evidenceRefs: Type.Array(Type.String({ minLength: 1 }), {
+            description: "Evidence refs (paths or artifact ids); at least one", minItems: 1,
         }),
+        findings: Type.Optional(Type.Array(findingSchema, {
+            description: "At least one finding", minItems: 1,
+        })),
     }, { additionalProperties: false });
     async function adoptReviewFact(kind, fact) {
         const requestId = randomUUID();
         try {
+            scopeProtocol.assertComplete();
             const parsed = kind === "approve_review"
                 ? approveReviewFactSchema.parse(fact)
                 : requestReviewChangesFactSchema.parse(fact);
@@ -854,7 +879,7 @@ export async function createFrontendReviewTerminalTools(input) {
             return adoptReviewFact("approve_review", {
                 kind: "approve_review",
                 verdict: "approve_review",
-                findings: params?.findings ?? [],
+                findings: allFindings(params?.findings),
             });
         },
     });
@@ -870,17 +895,15 @@ export async function createFrontendReviewTerminalTools(input) {
                 verdict: "request_review_changes",
                 issueCategory: params?.issueCategory,
                 evidenceRefs: params?.evidenceRefs,
-                findings: params?.findings,
+                findings: allFindings(params?.findings),
             });
         },
     });
-    return {
-        customTools: [approveReviewTool, requestReviewChangesTool],
-        flush: async () => {
-            const committed = readCommittedEvents(store, attemptId);
-            await writeTypedEventStoreJsonl(path.join(input.runDir, input.nodeId, "review-typed-facts.jsonl"), committed);
-        },
-    };
+    const durable = await createDurableFrontendTools({
+        file: path.join(input.runDir, input.nodeId, "review-typed-facts.jsonl"), attemptId, store: input.store,
+        binding: { inputDigest: input.inputDigest, scopeDigest: input.inventory?.digest }, setWorkingStore: next => { store = next; }, tools: [...scopeProtocol.customTools, recordFindingTool, approveReviewTool, requestReviewChangesTool], validateRestored: async () => { await input.inventory?.validate(); },
+    });
+    return { ...durable, scopeProtocol };
 }
 /**
  * M8: build the two committed typed design terminal tools (approve_design /
@@ -897,21 +920,35 @@ export async function createFrontendDesignTerminalTools(input) {
     ]);
     const { approveDesignFactSchema, readCommittedEvents, requestDesignChangesFactSchema, writeTypedEventStoreJsonl, } = await import("../workflows/dag/frontend-typed-event-store.js");
     const { adoptTypedEventFact, stageTypedEventFact } = await import("../workflows/dag/frontend-typed-event-transaction.js");
-    const store = input.store;
+    let store = input.store;
     const attemptId = input.attemptId;
     const findingSchema = Type.Object({
-        severity: Type.String({
-            description: "Critical | Important | Minor | Info",
-        }),
-        file: Type.Optional(Type.String({})),
-        line: Type.Optional(Type.Number({})),
-        issue: Type.String({}),
-        requiredChange: Type.Optional(Type.String({})),
+        severity: Type.Enum({ Critical: "Critical", Important: "Important", Minor: "Minor", Info: "Info" }),
+        file: Type.Optional(Type.String({ minLength: 1 })),
+        line: Type.Optional(Type.Integer({ minimum: 1 })),
+        issue: Type.String({ minLength: 1 }),
+        requiredChange: Type.Optional(Type.String({ minLength: 1 })),
     }, { additionalProperties: false });
+    const scopeProtocol = createFrontendReviewScopeProtocol({ phase: "design", inventory: input.inventory, getStore: () => store, attemptId });
+    const savedFindings = () => [...new Map(readCommittedEvents(store, attemptId).filter(r => r.fact.kind === "design-finding").map(r => [r.fact.id, r.fact.finding])).values()];
+    const allFindings = (direct) => [...new Map([...savedFindings(), ...(Array.isArray(direct) ? direct : [])].map(finding => [JSON.stringify(finding), finding])).values()];
+    const recordFindingTool = defineTool({
+        name: "record_design_finding", label: "record_design_finding",
+        description: "Save one finding with a stable id. Submit findings incrementally, then finalize without repeating the findings array. Saved blocking findings cannot be omitted from approval; correct a finding explicitly with replace:true.",
+        parameters: Type.Object({ id: Type.String({ minLength: 1 }), finding: findingSchema }, { additionalProperties: false }),
+        async execute(_callId, params) {
+            const fact = { kind: "design-finding", id: params.id, finding: params.finding };
+            const requestId = `${attemptId}:finding:${randomUUID()}`;
+            const staged = stageTypedEventFact({ store, requestId, attemptId, fact });
+            const adopted = await adoptTypedEventFact({ store, requestId, attemptId, fact, eventId: staged.eventId, expectedRevision: store.revision });
+            const details = { ok: true, eventId: adopted.eventId, revision: adopted.revision };
+            return { content: [{ type: "text", text: JSON.stringify(details) }], details };
+        },
+    });
     const approveParameters = Type.Object({
-        findings: Type.Array(findingSchema, {
+        findings: Type.Optional(Type.Array(findingSchema, {
             description: "Optional informational findings (Minor/Info only; no Critical/Important on approval)",
-        }),
+        })),
     }, { additionalProperties: false });
     const requestParameters = Type.Object({
         issueCategory: Type.Enum({
@@ -921,16 +958,17 @@ export async function createFrontendDesignTerminalTools(input) {
             "contract-requirement-gap": "contract-requirement-gap",
             "unknown": "unknown",
         }, { description: "Typed issue category (five-value enum)" }),
-        evidenceRefs: Type.Array(Type.String({}), {
-            description: "Evidence refs (paths or artifact ids); at least one",
-        }),
-        findings: Type.Array(findingSchema, {
-            description: "At least one finding",
+        evidenceRefs: Type.Array(Type.String({ minLength: 1 }), {
+            description: "Evidence refs (paths or artifact ids); at least one", minItems: 1,
         }),
+        findings: Type.Optional(Type.Array(findingSchema, {
+            description: "At least one finding", minItems: 1,
+        })),
     }, { additionalProperties: false });
     async function adoptDesignFact(kind, fact) {
         const requestId = randomUUID();
         try {
+            scopeProtocol.assertComplete();
             const parsed = kind === "approve_design"
                 ? approveDesignFactSchema.parse(fact)
                 : requestDesignChangesFactSchema.parse(fact);
@@ -992,7 +1030,7 @@ export async function createFrontendDesignTerminalTools(input) {
             return adoptDesignFact("approve_design", {
                 kind: "approve_design",
                 verdict: "approve_design",
-                findings: params?.findings ?? [],
+                findings: allFindings(params?.findings),
             });
         },
     });
@@ -1008,17 +1046,15 @@ export async function createFrontendDesignTerminalTools(input) {
                 verdict: "request_design_changes",
                 issueCategory: params?.issueCategory,
                 evidenceRefs: params?.evidenceRefs,
-                findings: params?.findings,
+                findings: allFindings(params?.findings),
             });
         },
     });
-    return {
-        customTools: [approveDesignTool, requestDesignChangesTool],
-        flush: async () => {
-            const committed = readCommittedEvents(store, attemptId);
-            await writeTypedEventStoreJsonl(path.join(input.runDir, input.nodeId, "design-typed-facts.jsonl"), committed);
-        },
-    };
+    const durable = await createDurableFrontendTools({
+        file: path.join(input.runDir, input.nodeId, "design-typed-facts.jsonl"), attemptId, store: input.store,
+        binding: { inputDigest: input.inputDigest, scopeDigest: input.inventory?.digest }, setWorkingStore: next => { store = next; }, tools: [...scopeProtocol.customTools, recordFindingTool, approveDesignTool, requestDesignChangesTool], validateRestored: async () => { await input.inventory?.validate(); },
+    });
+    return { ...durable, scopeProtocol };
 }
 /**
  * Source fidelity ledger (AC-005/AC-006): load the contract node's committed
@@ -1063,6 +1099,8 @@ async function loadContractRequirementInheritance(runDir) {
             : undefined;
         if (sourceFragmentIds || sourceRefs) {
             byId.set(id, {
+                ...(typeof recordFact.text === "string" ? { text: recordFact.text } : {}),
+                ...(recordFact.execution !== undefined ? { execution: frontendExecutionSchema.parse(recordFact.execution) } : {}),
                 ...(sourceFragmentIds ? { sourceFragmentIds } : {}),
                 ...(sourceRefs ? { sourceRefs } : {}),
             });
@@ -1228,26 +1266,12 @@ export async function createFrontendPlanLedgerTools(input) {
     const { loadTypedEventStore, readCommittedEvents, writeTypedEventStoreJsonl, } = await import("../workflows/dag/frontend-typed-event-store.js");
     const { adoptStagedFact, adoptTypedEventFact, stageTypedEventFact } = await import("../workflows/dag/frontend-typed-event-transaction.js");
     const { assemblePlanPatchFromCommittedFacts } = await import("../workflows/dag/frontend-shadow-dual-write.js");
-    const store = input.store;
+    let store = input.store;
     const attemptId = input.attemptId;
     let activeRequirementScope = [];
     const scopedRequirementIds = () => [...activeRequirementScope];
-    // A retry creates a fresh executor-local store, but the plan ledger is the
-    // cross-attempt authority. Restore the committed prefix before registering
-    // tools; otherwise the first flush of a retry can overwrite facts that the
-    // previous attempt had already committed. The on-disk file contains only
-    // committed records, so loading it is also fail-closed with respect to
-    // staged/quarantined facts.
-    const persisted = await loadTypedEventStore(path.join(input.runDir, input.nodeId, "plan-typed-facts.jsonl"));
-    if (persisted.records.length > 0) {
-        const existingEventIds = new Set(store.records.map((record) => record.eventId));
-        for (const record of persisted.records) {
-            if (!existingEventIds.has(record.eventId)) {
-                store.records.push(record);
-            }
-        }
-        store.revision = Math.max(store.revision, persisted.revision);
-    }
+    const contractInheritance = await loadContractRequirementInheritance(input.runDir);
+    const executionGroups = collectFrontendExecutionGroups([...contractInheritance].map(([id, r]) => ({ id, ...r })));
     const stringArray = Type.Array(Type.String({}));
     const optionalString = Type.Optional(Type.String({}));
     const optionalStringArray = Type.Optional(stringArray);
@@ -1282,9 +1306,7 @@ export async function createFrontendPlanLedgerTools(input) {
         verificationTargetIds: stringArray,
     }, { additionalProperties: false });
     const mockEndpointSchema = Type.Object({
-        method: Type.String({
-            description: "GET | POST | PUT | PATCH | DELETE | HEAD | OPTIONS",
-        }),
+        method: Type.Enum({ GET: "GET", POST: "POST", PUT: "PUT", PATCH: "PATCH", DELETE: "DELETE", HEAD: "HEAD", OPTIONS: "OPTIONS" }),
         path: Type.String({}),
         fixture: optionalString,
         consumer: optionalString,
@@ -1346,9 +1368,9 @@ export async function createFrontendPlanLedgerTools(input) {
         specReference: Type.Optional(Type.Object({
             path: Type.String({}),
             section: Type.String({}),
-            line: Type.Optional(Type.Number({})),
+            line: Type.Optional(Type.Integer({ minimum: 1 })),
         }, { additionalProperties: false })),
-        rationale: Type.String({}),
+        rationale: Type.Optional(Type.String({ minLength: 1 })),
         covers: Type.Optional(Type.Array(Type.String({}), {
             description: "UI state and/or interaction names this single component choice covers (one choice may cover many ids).",
         })),
@@ -1805,13 +1827,14 @@ export async function createFrontendPlanLedgerTools(input) {
         label: "record_data_flow",
         description: "Record interaction/endpoint data flow as an origin=plan data-flow fact. Example: {\"interactions\": [\"<interaction name>\"], \"endpoints\": [\"GET <path>\"]}",
         promptSnippet: "Record the plan data-flow fact.",
-        parameters: Type.Object({ interactions: stringArray, endpoints: stringArray }, { additionalProperties: false }),
+        parameters: Type.Object({ interactions: stringArray, endpoints: stringArray, replace: Type.Optional(Type.Boolean()) }, { additionalProperties: false }),
         async execute(_toolCallId, params) {
+            const previous = params.replace ? undefined : readCommittedEvents(store, attemptId).filter(r => r.fact.kind === "data-flow").at(-1)?.fact;
             const result = await adoptPlanFact("data-flow", `${attemptId}:record_data_flow:${randomUUID()}`, {
                 kind: "data-flow",
                 origin: "plan",
-                interactions: stringList(params?.interactions),
-                endpoints: stringList(params?.endpoints),
+                interactions: [...new Set([...stringList(previous?.interactions), ...stringList(params?.interactions)])],
+                endpoints: [...new Set([...stringList(previous?.endpoints), ...stringList(params?.endpoints)])],
             });
             return planToolReceipt(result);
         },
@@ -1839,6 +1862,16 @@ export async function createFrontendPlanLedgerTools(input) {
             return planToolReceipt(result);
         },
     });
+    const recordMockEndpointTool = defineTool({
+        name: "record_mock_endpoint", label: "record_mock_endpoint",
+        description: "Record one Mock/API endpoint. First record_mock_api with the policy and endpoints: []; then submit each endpoint separately. Never regenerate the whole endpoint collection. Use replace:true to revise an existing method/path, or replace:true plus remove:true to withdraw it.",
+        parameters: Type.Object({ endpoint: mockEndpointSchema, remove: Type.Optional(Type.Boolean()) }, { additionalProperties: false }),
+        async execute(_callId, params) {
+            if (!readCommittedEvents(store, attemptId).some(r => r.fact.kind === "mock-api"))
+                return planToolReceipt({ ok: false, kind: "mock-endpoint", code: "MOCK_POLICY_MISSING", error: "Record the mock policy before its endpoints" });
+            return planToolReceipt(await adoptPlanFact("mock-endpoint", `${attemptId}:endpoint:${randomUUID()}`, { kind: "mock-endpoint", origin: "plan", endpoint: params.endpoint, ...(params.remove ? { removed: true } : {}) }));
+        },
+    });
     const recordDesignDeviationTool = defineTool({
         name: "record_design_deviation",
         label: "record_design_deviation",
@@ -1914,6 +1947,8 @@ export async function createFrontendPlanLedgerTools(input) {
             // canonical-coverage gate rejects with no in-node cure. Reject here
             // and name the allowed ids.
             const id = typeof entry.id === "string" ? entry.id : "";
+            if (activeRequirementScope.length && !activeRequirementScope.includes(id))
+                return planToolReceipt({ ok: false, kind: "plan-requirement", code: "FRONTEND_INPUT_SCOPE_VIOLATION", error: `Requirement ${id} is outside this session` });
             if (id &&
                 input.requirementIds &&
                 input.requirementIds.length > 0 &&
@@ -1963,6 +1998,29 @@ export async function createFrontendPlanLedgerTools(input) {
             return planToolReceipt(result);
         },
     });
+    const recordPlanGroupCoverageTool = defineTool({
+        name: "record_plan_group_coverage", label: "record_plan_group_coverage",
+        description: "Submit shared implementation/verification references for one declared execution group. Runtime expands to every canonical member and retains its full outcome and source bindings. A shared VT must actually verify each independent condition. Use per-requirement records for differences; never create UI for constraints or exclusions. replace:true explicitly revises the group.",
+        parameters: Type.Object({ id: Type.String({ minLength: 1 }), implementationTargets: stringArray, verificationTargetIds: stringArray, replace: Type.Optional(Type.Boolean()) }, { additionalProperties: false }),
+        async execute(callId, params, signal, onUpdate, ctx) {
+            const group = executionGroups.find(g => g.id === params.id && g.kind !== "unclassified");
+            if (!group || (activeRequirementScope.length && group.requirementIds.some(id => !activeRequirementScope.includes(id))))
+                return planToolReceipt({ ok: false, kind: "plan-requirement", code: "EXECUTION_GROUP_SCOPE_INVALID", error: "A known complete group must be present in this session; submit individual member records when the group spans scopes" });
+            let last;
+            for (const id of group.requirementIds) {
+                const existing = readCommittedEvents(store, attemptId).filter(r => r.fact.kind === "plan-requirement" && r.fact.entry?.id === id).at(-1)?.fact.entry;
+                if (existing && !params.replace) {
+                    if (JSON.stringify(existing.implementationTargets) !== JSON.stringify(params.implementationTargets) || JSON.stringify(existing.verificationTargetIds) !== JSON.stringify(params.verificationTargetIds))
+                        return planToolReceipt({ ok: false, kind: "plan-requirement", code: "FACT_IDENTITY_CONFLICT", error: `${id}: existing coverage differs; use replace:true to revise explicitly` });
+                    continue;
+                }
+                last = await recordPlanRequirementTool.execute(`${callId}:${id}`, { entry: { id, implementationTargets: params.implementationTargets, verificationTargetIds: params.verificationTargetIds }, ...(params.replace ? { replace: true } : {}) }, signal, onUpdate, ctx);
+                if (!last.details?.ok)
+                    return last;
+            }
+            return planToolReceipt(await adoptPlanFact("plan-group-coverage", `${attemptId}:group:${randomUUID()}`, { kind: "plan-group-coverage", origin: "plan", id: group.id, requirementIds: group.requirementIds }));
+        },
+    });
     const recordPlanVerificationTargetTool = defineTool({
         name: "record_plan_verification_target",
         label: "record_plan_verification_target",
@@ -2182,7 +2240,7 @@ export async function createFrontendPlanLedgerTools(input) {
     const finalizePlanTool = defineTool({
         name: "finalize_plan",
         label: "finalize_plan",
-        description: "Commit the finalize_plan terminal. Requirements, verification targets, and evidence gaps (optional) were already committed incrementally through record_plan_requirement / record_plan_verification_target / record_plan_evidence_gap; finalize_plan assembles them from the ledger together with these optional remaining fields, publishes the canonical editable patch on a target-surface fact, and commits the terminal. Call exactly once.",
+        description: "Commit the finalize_plan terminal. Requirements, verification targets, and evidence gaps (optional) were already committed incrementally through record_plan_requirement / record_plan_verification_target / record_plan_evidence_gap; finalize_plan assembles them from the ledger together with these optional remaining fields, publishes the canonical editable patch on a target-surface fact, and commits the terminal. A successful terminal commit occurs exactly once. If validation fails, correct only the reported facts and retry finalize.",
         promptSnippet: "Commit the finalize_plan terminal (ledger fields + optional residualRisks / realIntegrationGap).",
         parameters: Type.Object({
             residualRisks: optionalStringArray,
@@ -2197,6 +2255,9 @@ export async function createFrontendPlanLedgerTools(input) {
                 // when the plan did not re-declare them. The contract node is the
                 // sole synthesis point; the plan inherits by requirement id.
                 const contractInheritance = await loadContractRequirementInheritance(input.runDir);
+                const missingData = collectFrontendPlanPhaseMissingFacts({ phase: "global-mock-data", requirementIds: input.requirementIds ?? [...contractInheritance.keys()], committedFacts: committed }).filter(f => f.kind === "data-flow");
+                if (missingData.length)
+                    return planToolReceipt({ ok: false, kind: "finalize_plan", code: "PLAN_DATA_FLOW_INCOMPLETE", error: missingData.map(f => f.reason).join("; ") });
                 const fragment = assemblePlanPatchFromCommittedFacts(committed, contractInheritance) ?? {};
                 const patch = {
                     ...fragment,
@@ -2352,23 +2413,31 @@ export async function createFrontendPlanLedgerTools(input) {
             }
         },
     });
-    return {
-        customTools: [
+    const durable = await createDurableFrontendTools({
+        file: path.join(input.runDir, input.nodeId, "plan-typed-facts.jsonl"), attemptId, store: input.store,
+        setWorkingStore: next => { store = next; },
+        binding: { sourceBinding: input.sourceBinding, skeleton: input.skeleton, requirementIds: input.requirementIds, writeSet: input.writeSetPatterns, declaredUiStateIds: input.declaredUiStateIds, citations: input.componentNewSourceReferences, contractInheritance },
+        tools: [
             recordRouteSelectionTool,
             recordComponentChoiceTool,
             recordStateRegistryTool,
             recordStateFlowTool,
             recordDataFlowTool,
             recordMockApiTool,
+            recordMockEndpointTool,
             recordDesignDeviationTool,
             recordDependencyTool,
             recordPlanRequirementTool,
+            recordPlanGroupCoverageTool,
             recordPlanVerificationTargetTool,
             recordPlanEvidenceGapTool,
             adoptStagedFactTool,
             finalizePlanTool,
         ],
-        adoptCommittedFacts: async (records) => {
+    });
+    return {
+        customTools: durable.customTools,
+        adoptCommittedFacts: async (records) => durable.commitExternal(async () => {
             for (const record of records) {
                 if (record.phase !== "committed")
                     continue;
@@ -2427,16 +2496,13 @@ export async function createFrontendPlanLedgerTools(input) {
                     throw new Error(`frontend plan shard fact merge failed: ${result.error}`);
                 }
             }
-        },
+        }),
         setActiveRequirementScope: (requirementIds) => {
             activeRequirementScope = [
                 ...new Set(requirementIds.filter((id) => id.trim().length > 0)),
             ];
         },
-        flush: async () => {
-            const committed = readCommittedEvents(store, attemptId);
-            await writeTypedEventStoreJsonl(path.join(input.runDir, input.nodeId, "plan-typed-facts.jsonl"), committed);
-        },
+        flush: durable.flush,
         committedFactCount: () => readCommittedEvents(store, attemptId).length,
         committedRequirementIds: () => {
             const ids = new Set();
@@ -2538,8 +2604,11 @@ export async function createFrontendContractTools(input) {
     ]);
     const { readCommittedEvents, writeTypedEventStoreJsonl } = await import("../workflows/dag/frontend-typed-event-store.js");
     const { adoptTypedEventFact, stageTypedEventFact } = await import("../workflows/dag/frontend-typed-event-transaction.js");
-    const store = input.store;
+    let store = input.store;
     const attemptId = input.attemptId;
+    let activeScope = null;
+    const committedRequirementIds = () => new Set(readCommittedEvents(store, attemptId).filter(r => r.fact.kind === "requirement").map(r => String(r.fact.id)));
+    const completedScopeRequirementIds = () => new Set(readCommittedEvents(store, attemptId).filter(r => r.fact.kind === "contract-scope-completed").flatMap(r => Array.isArray(r.fact.requirementIds) ? r.fact.requirementIds.filter((id) => typeof id === "string") : []));
     const receipt = (details) => ({
         content: [{ type: "text", text: JSON.stringify(details) }],
         details,
@@ -2589,12 +2658,24 @@ export async function createFrontendContractTools(input) {
         label: name,
         description: `Commit an origin=contract ${kind} fact. IMPORTANT: submit incrementally — batch up to 5 record_* calls per message, starting from the FIRST message; never attempt to emit the whole contract in one response (a single large dump will be truncated and rejected). Every message must make progress by committing at least one record_* fact.`,
         promptSnippet: `Commit 1-5 origin=contract ${kind} facts (up to 5 per message).`,
-        parameters: Type.Object({}, { additionalProperties: true }),
+        parameters: Type.Object({
+            text: Type.String({ minLength: 1 }),
+            requirementIds: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+            sourceFragmentIds: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+            ...(kind === "constraint" ? { category: Type.Optional(Type.Enum({ constraint: "constraint", "non-goal": "non-goal", risk: "risk" })) } : {}),
+            ...(kind === "handoff-intent" ? { taskKind: Type.Literal("frontend-test"), blocking: Type.Optional(Type.Boolean()) } : {}),
+        }, { additionalProperties: false }),
         async execute(_toolCallId, params) {
+            const data = params;
+            if (!data.text?.trim())
+                return receipt({ ok: false, code: "TOOL_SCHEMA_INVALID", error: `${name}: text must be non-empty` });
+            const knownFragments = new Set([...(input.canonicalRequirements?.values() ?? [])].flatMap(r => r.sourceFragmentIds));
+            if (data.requirementIds?.some(id => !input.canonicalRequirements?.has(id)) || data.sourceFragmentIds?.some(id => !knownFragments.has(id)))
+                return receipt({ ok: false, code: "CONTRACT_REFERENCE_UNKNOWN", error: `${name}: reference is outside the frozen source inventory` });
             const result = await adoptContractFact(kind, {
+                ...(params ?? {}),
                 kind,
                 origin: "contract",
-                ...(params ?? {}),
             });
             return receipt(result);
         },
@@ -2608,9 +2689,9 @@ export async function createFrontendContractTools(input) {
     const recordRequirementTool = defineTool({
         name: "record_requirement",
         label: "record_requirement",
-        description: 'Confirm one canonical ledger requirement (origin=contract requirement fact). Pass ONLY the canonical id listed in the <frontend_contract_input> inventory, e.g. {"id": "AC-001"} — the runtime commits the authoritative text and sourceFragmentIds from the frozen ledger. Never pass text/statement/sourceFragmentIds yourself: free-form rewrites and JSON-stringified fragment arrays are rejected. IMPORTANT: batch up to 5 record_* calls per message, starting from the FIRST message.',
+        description: 'Confirm one canonical ledger requirement (origin=contract requirement fact). Pass the canonical id and optional execution:{groupId,kind,summary} only. Reuse a group only when its behavior and all permission/threshold/error conditions agree; retain separate groups for differences. Constraints/exclusions do not require invented UI. The canonical id is listed in the <frontend_contract_input> inventory, e.g. {"id": "AC-001"} — the runtime commits the authoritative text and sourceFragmentIds from the frozen ledger. Never pass text/statement/sourceFragmentIds yourself: free-form rewrites and JSON-stringified fragment arrays are rejected. IMPORTANT: batch up to 5 record_* calls per message, starting from the FIRST message.',
         promptSnippet: "Confirm 1-5 canonical requirements by id (up to 5 per message).",
-        parameters: Type.Object({ id: Type.String({ description: "Canonical ledger requirement id (e.g. AC-001)" }) }, { additionalProperties: false }),
+        parameters: Type.Object({ id: Type.String({ description: "Canonical ledger requirement id (e.g. AC-001)" }), execution: Type.Optional(Type.Object({ groupId: Type.String({ minLength: 1 }), kind: Type.Union([Type.Literal("behavior"), Type.Literal("constraint"), Type.Literal("exclusion")]), summary: Type.String({ minLength: 1 }) }, { additionalProperties: false })) }, { additionalProperties: false }),
         async execute(_toolCallId, params) {
             const id = typeof params?.id === "string" ? params.id.trim() : "";
             if (!id) {
@@ -2620,6 +2701,8 @@ export async function createFrontendContractTools(input) {
                     error: "record_requirement requires the canonical requirement id",
                 });
             }
+            if (activeScope && !activeScope.has(id))
+                return receipt({ ok: false, code: "FRONTEND_INPUT_SCOPE_VIOLATION", error: `requirement ${id} is outside the complete input scope of this session` });
             const canonical = input.canonicalRequirements?.get(id);
             if (!canonical) {
                 const known = [...(input.canonicalRequirements?.keys() ?? [])];
@@ -2629,6 +2712,14 @@ export async function createFrontendContractTools(input) {
                     error: `record_requirement id "${id}" is not a canonical ledger requirement; canonical ids are: ${known.join(", ") || "(none)"}`,
                 });
             }
+            if (params.execution) {
+                try {
+                    collectFrontendExecutionGroups([...readCommittedEvents(store, attemptId).filter(r => r.fact.kind === "requirement" && r.fact.id !== id).map(r => ({ id: String(r.fact.id), execution: r.fact.execution })), { id, execution: params.execution }]);
+                }
+                catch (error) {
+                    return receipt({ ok: false, code: "EXECUTION_GROUP_CONFLICT", error: String(error) });
+                }
+            }
             const result = await adoptContractFact("requirement", {
                 kind: "requirement",
                 origin: "contract",
@@ -2636,6 +2727,7 @@ export async function createFrontendContractTools(input) {
                 id,
                 text: canonical.text,
                 sourceFragmentIds: canonical.sourceFragmentIds,
+                ...(params.execution ? { execution: params.execution } : {}),
             });
             return receipt(result);
         },
@@ -2715,15 +2807,17 @@ export async function createFrontendContractTools(input) {
     const recordRequiredDeliverablesTool = defineTool({
         name: "record_required_deliverables",
         label: "record_required_deliverables",
-        description: 'Declare the complete source-required file deliverables as {items:[{path,requirementId,sourceFragmentId}]}. Interpret obligations from the original source, including lists/tables: permissions (allowedPaths/only allowed to modify), prohibitions, examples and read-only references are NOT delivery obligations. Each path must appear exactly in its frozen requirement-bound source fragment. Submit {items:[]} explicitly if no files are mandatory. A correction replaces the whole inventory. Required before finalize_contract ready.',
-        parameters: Type.Object({ items: Type.Array(Type.Object({
+        description: 'Declare the complete source-required file deliverables as {items:[{path,requirementId,sourceFragmentId}]}. Interpret obligations from the original source, including lists/tables: permissions (allowedPaths/only allowed to modify), prohibitions, examples and read-only references are NOT delivery obligations. Each path must appear exactly in its frozen requirement-bound source fragment. Submit {items:[]} explicitly if no files are mandatory. Each call appends complete source-bound items; replace:true explicitly replaces the inventory. Required before finalize_contract ready.',
+        parameters: Type.Object({ replace: Type.Optional(Type.Boolean()), items: Type.Array(Type.Object({
                 path: Type.String(), requirementId: Type.String(), sourceFragmentId: Type.String(),
             }, { additionalProperties: false })) }, { additionalProperties: false }),
         async execute(_toolCallId, params) {
             try {
-                const declaration = validateFrontendRequiredDeliverables(params, input.canonicalRequirements ?? new Map());
+                const declaration = validateFrontendRequiredDeliverables({ items: params.items }, input.canonicalRequirements ?? new Map());
+                const previous = params.replace ? [] : readCommittedEvents(store, attemptId).filter(r => r.fact.kind === "required-deliverables").at(-1)?.fact.items;
+                const items = [...new Map([...(Array.isArray(previous) ? previous : []), ...declaration.items].map(item => [JSON.stringify(item), item])).values()];
                 return receipt(await adoptContractFact("required-deliverables", {
-                    kind: "required-deliverables", origin: "contract", ...declaration,
+                    kind: "required-deliverables", origin: "contract", items,
                 }));
             }
             catch (error) {
@@ -2779,7 +2873,7 @@ export async function createFrontendContractTools(input) {
     const finalizeContractTool = defineTool({
         name: "finalize_contract",
         label: "finalize_contract",
-        description: "Commit the contract-finalized terminal fact with a disposition of ready | ready-with-assumptions | blocked (blocked requires blockingOwner). Call exactly once.",
+        description: "Commit the contract-finalized terminal fact with a disposition of ready | ready-with-assumptions | blocked (blocked requires blockingOwner). A successful terminal commit occurs exactly once. If validation fails, correct only the reported facts and retry finalize.",
         promptSnippet: "Commit the contract-finalized terminal (disposition + optional blockingOwner).",
         parameters: Type.Object({
             disposition: Type.Enum({
@@ -2811,6 +2905,9 @@ export async function createFrontendContractTools(input) {
                     error: "call record_required_deliverables with the complete source-bound inventory (or items:[] when none) before finalizing",
                 });
             }
+            const missing = [...(input.canonicalRequirements?.keys() ?? [])].filter(id => !committedRequirementIds().has(id) || (activeScope !== null && !completedScopeRequirementIds().has(id)));
+            if (disposition !== "blocked" && missing.length)
+                return receipt({ ok: false, code: "CONTRACT_REQUIREMENT_COVERAGE_MISSING", error: `Confirm all complete source obligations before finalizing: ${missing.join(", ")}` });
             const blockedOwner = mapContractBlockedOwner({
                 disposition: disposition ?? "",
                 blockingOwner,
@@ -2831,19 +2928,41 @@ export async function createFrontendContractTools(input) {
             return receipt(result);
         },
     });
-    return {
-        customTools: [
+    const completeScopeTool = defineTool({
+        name: "complete_contract_scope", label: "complete_contract_scope",
+        description: "After recording all requirements AND their evidence, constraints, questions and deliverables for this session, mark the scope complete. Confirming an ID alone does not complete its analysis. Do this before finalize_contract.",
+        parameters: Type.Object({ requirementIds: Type.Array(Type.String({ minLength: 1 }), { uniqueItems: true }) }, { additionalProperties: false }),
+        async execute(_id, params) {
+            const ids = params.requirementIds;
+            if (activeScope === null || ids.length !== activeScope.size || ids.some(id => !activeScope?.has(id) || !committedRequirementIds().has(id)))
+                return receipt({ ok: false, code: "CONTRACT_SCOPE_INCOMPLETE", error: "Complete exactly the active scope after confirming all its obligations" });
+            return receipt(await adoptContractFact("contract-scope-completed", { kind: "contract-scope-completed", origin: "contract", requirementIds: ids }));
+        },
+    });
+    const durable = await createDurableFrontendTools({
+        file: path.join(input.runDir, input.nodeId, "contract-typed-facts.jsonl"), attemptId, store: input.store,
+        setWorkingStore: next => { store = next; }, binding: { canonicalRequirements: input.canonicalRequirements, sourceDigest: input.sourceDigest },
+        tools: [
             ...recordTools,
             recordRequirementTool,
             recordEvidenceExpectationTool,
             recordUiStateTool,
             recordRequiredDeliverablesTool,
             recordOpenspecSelectionTool,
+            completeScopeTool,
             finalizeContractTool,
         ],
+    });
+    return {
+        customTools: durable.customTools,
+        inputRequirements: () => [...(input.canonicalRequirements ?? [])].map(([id, value]) => ({ id, text: value.text, sourceFragmentIds: [...value.sourceFragmentIds] })),
+        completedScopeRequirementIds,
+        setActiveRequirementScope: ids => { activeScope = ids === null ? null : new Set(ids); },
+        committedRequirementIds,
+        committedFacts: () => readCommittedEvents(input.store, attemptId),
         flush: async () => {
-            const committed = readCommittedEvents(store, attemptId);
-            await writeTypedEventStoreJsonl(path.join(input.runDir, input.nodeId, "contract-typed-facts.jsonl"), committed);
+            await durable.flush();
+            const committed = readCommittedEvents(input.store, attemptId);
             await writeJsonAtomic(path.join(input.runDir, input.nodeId, "frontend-task-contract-vNext.json"), buildFrontendTaskContractVNext(committed));
         },
     };
@@ -2895,7 +3014,7 @@ export async function createFrontendScoutEvidenceTools(input) {
     ]);
     const { readCommittedEvents, writeTypedEventStoreJsonl } = await import("../workflows/dag/frontend-typed-event-store.js");
     const { adoptTypedEventFact, stageTypedEventFact } = await import("../workflows/dag/frontend-typed-event-transaction.js");
-    const store = input.store;
+    let store = input.store;
     const attemptId = input.attemptId;
     const stringArray = Type.Array(Type.String({}));
     const optionalString = Type.Optional(Type.String({}));
@@ -2909,6 +3028,18 @@ export async function createFrontendScoutEvidenceTools(input) {
     });
     const sourceDeclaredPaths = (input.sourceDeclaredPaths ?? []).map((value) => value.replaceAll("\\", "/").replace(/^\.\//, "").replace(/\/$/, ""));
     const hasSourceDeclarations = input.sourceDeclaredPaths !== undefined;
+    let activeScope;
+    const scopeIdentity = (ids) => createHash("sha256").update(JSON.stringify([...ids].sort())).digest("hex");
+    const latestScopes = () => {
+        const byRequirement = new Map();
+        for (const record of readCommittedEvents(store, attemptId))
+            if (record.fact.kind === "scout-scope" && Array.isArray(record.fact.requirementIds)) {
+                for (const id of record.fact.requirementIds)
+                    if (typeof id === "string")
+                        byRequirement.set(id, record.fact);
+            }
+        return byRequirement;
+    };
     const isSourceDeclared = (candidate) => {
         const normalized = candidate.replaceAll("\\", "/").replace(/^\.\//, "").replace(/\/$/, "");
         return sourceDeclaredPaths.some((declared) => declared === normalized || declared.startsWith(`${normalized}/`));
@@ -3001,6 +3132,7 @@ export async function createFrontendScoutEvidenceTools(input) {
         description: "Commit an origin=scout target-surface fact with complete/blocked discovery status. A complete surface needs a proven target path and no unresolved paths; blocked surfaces name the unresolved paths instead of guessing. Example: {\"completeness\": \"complete\", \"entrypoint\": \"<file>\", \"implementationPaths\": [\"<dir or file>\"], \"testPaths\": [\"<file>\"], \"allowedPathConflicts\": [], \"unresolvedPaths\": []}",
         promptSnippet: "Commit an origin=scout target-surface fact.",
         parameters: Type.Object({
+            scopeId: Type.Optional(Type.String({ minLength: 1 })),
             completeness: scoutCompleteness,
             entrypoint: optionalString,
             routeOrMount: optionalString,
@@ -3011,6 +3143,8 @@ export async function createFrontendScoutEvidenceTools(input) {
             unresolvedPaths: stringArray,
         }, { additionalProperties: false }),
         async execute(_toolCallId, params) {
+            if (input.requirementIds && (!activeScope?.length || params.scopeId !== scopeIdentity(activeScope)))
+                return receipt({ ok: false, code: "FRONTEND_INPUT_SCOPE_VIOLATION", error: "Use exactly the runtime Scout scopeId; discovery may complete only the supplied obligations" });
             const implementationPaths = params?.implementationPaths ?? [];
             const testPaths = params?.testPaths ?? [];
             const pathEvidence = await enrichScoutPathEvidence([
@@ -3018,7 +3152,7 @@ export async function createFrontendScoutEvidenceTools(input) {
                 ...implementationPaths,
                 ...testPaths,
             ]);
-            const result = await adoptScoutFact("target-surface", {
+            const surface = {
                 kind: "target-surface",
                 origin: "scout",
                 completeness: params?.completeness ?? "blocked",
@@ -3031,7 +3165,27 @@ export async function createFrontendScoutEvidenceTools(input) {
                 unresolvedPaths: params?.unresolvedPaths ?? [],
                 ...(hasSourceDeclarations ? { sourceDeclaredPaths } : {}),
                 ...(pathEvidence.length > 0 ? { pathEvidence } : {}),
-            });
+            };
+            if (activeScope) {
+                const { readCompleteScoutTargetSurface } = await import("../workflows/dag/frontend-shadow-dual-write.js");
+                if (surface.completeness === "complete") {
+                    const check = readCompleteScoutTargetSurface([{ phase: "committed", fact: surface }]);
+                    if (!check.ok)
+                        return receipt({ ok: false, code: "SCOUT_SCOPE_INCOMPLETE", error: check.reason });
+                }
+                const saved = await adoptScoutFact("scout-scope", { kind: "scout-scope", origin: "scout", id: params.scopeId, requirementIds: activeScope, surface });
+                if (!saved.ok)
+                    return receipt(saved);
+                const current = latestScopes();
+                if (input.requirementIds?.every(id => current.get(id)?.surface?.completeness === "complete")) {
+                    const surfaces = [...new Set(input.requirementIds.map(id => current.get(id)))].map(f => f.surface);
+                    const union = (key) => [...new Set(surfaces.flatMap(s => Array.isArray(s[key]) ? s[key] : []))];
+                    const entries = [...new Set(surfaces.map(s => String(s.entrypoint ?? "")).filter(Boolean))];
+                    return receipt(await adoptScoutFact("target-surface", { kind: "target-surface", origin: "scout", completeness: "complete", entrypoint: entries[0] ?? "", implementationPaths: [...new Set([...entries, ...union("implementationPaths")])], testPaths: union("testPaths"), allowedPathConflicts: union("allowedPathConflicts"), unresolvedPaths: union("unresolvedPaths"), routeOrMount: [...new Set(surfaces.map(s => s.routeOrMount).filter(Boolean))].join("\n"), dataSource: [...new Set(surfaces.map(s => s.dataSource).filter(Boolean))].join("\n"), pathEvidence: surfaces.flatMap(s => s.pathEvidence ?? []), ...(hasSourceDeclarations ? { sourceDeclaredPaths } : {}) }));
+                }
+                return receipt(saved);
+            }
+            const result = await adoptScoutFact("target-surface", surface);
             return receipt(result);
         },
     });
@@ -3055,10 +3209,30 @@ export async function createFrontendScoutEvidenceTools(input) {
             return receipt(result);
         },
     });
+    const durable = await createDurableFrontendTools({
+        file: path.join(input.runDir, input.nodeId, "scout-typed-facts.jsonl"), attemptId, store: input.store,
+        setWorkingStore: next => { store = next; }, binding: { requirementIds: input.requirementIds, sourceDeclaredPaths: input.sourceDeclaredPaths, sourceDigest: input.sourceDigest, workspaceRoot: input.workspaceRoot },
+        tools: [recordTargetSurfaceTool, recordDesignEvidenceTool],
+        validateRestored: async (records) => {
+            if (!input.workspaceRoot)
+                return;
+            for (const record of records) {
+                const evidence = record.fact.kind === "scout-scope" ? record.fact.surface?.pathEvidence : record.fact.pathEvidence;
+                if (!Array.isArray(evidence))
+                    continue;
+                for (const previous of evidence) {
+                    if (!isRecordObject(previous) || typeof previous.path !== "string")
+                        throw Error("scout path evidence is malformed");
+                    const current = (await enrichScoutPathEvidence([previous.path]))[0];
+                    if (!current || current.sha256 !== previous.sha256 || current.fresh !== previous.fresh)
+                        throw Error(`scout evidence drift: ${previous.path}; refresh Scout before reusing facts`);
+                }
+            }
+        },
+    });
     return {
-        customTools: [recordTargetSurfaceTool, recordDesignEvidenceTool],
-        committedFacts: () => readCommittedEvents(store, attemptId),
-        adoptCommittedFacts: async (records) => {
+        ...durable,
+        adoptCommittedFacts: async (records) => durable.commitExternal(async () => {
             for (const record of records) {
                 if (record.phase !== "committed")
                     continue;
@@ -3072,11 +3246,16 @@ export async function createFrontendScoutEvidenceTools(input) {
                     throw new Error(`frontend scout shard fact merge failed: ${result.error}`);
                 }
             }
+        }),
+        setActiveScope: ids => {
+            if (!ids.length || ids.some(id => !input.requirementIds?.includes(id)))
+                throw Error("FRONTEND_INPUT_SCOPE_VIOLATION");
+            activeScope = [...new Set(ids)];
+            return scopeIdentity(activeScope);
         },
-        flush: async () => {
-            const committed = readCommittedEvents(store, attemptId);
-            await writeTypedEventStoreJsonl(path.join(input.runDir, input.nodeId, "scout-typed-facts.jsonl"), committed);
-        },
+        completedRequirementIds: () => new Set([...latestScopes()].filter(([, fact]) => fact.surface?.completeness === "complete").map(([id]) => id)),
+        completedScopeFacts: () => [...new Set(latestScopes().values())].filter(f => f.surface?.completeness === "complete"),
+        committedFacts: () => readCommittedEvents(store, attemptId),
     };
 }
 export function buildDagPiUserMessage(task, persona, step) {
@@ -3327,15 +3506,14 @@ async function runFrontendReviewTerminalShadow(input) {
         return input.mapped;
     const { compareTypedReviewToLegacyJsonVerdict } = await import("../workflows/dag/frontend-review-context.js");
     const { parseJsonReviewVerdict } = await import("../workflows/dag/output-protocol.js");
-    const sessionEventsPath = path.join(input.meta.runDir, input.task.id, "session-events.jsonl");
     let typedKinds = [];
     try {
-        const content = await readFile(sessionEventsPath, "utf8");
-        typedKinds = scanReviewTerminalKindsFromSessionEvents(content);
+        await input.tools?.flush();
+        input.tools?.scopeProtocol?.assertComplete();
+        typedKinds = input.tools?.scopeProtocol?.committedFacts().filter(r => ["approve_review", "request_review_changes"].includes(String(r.fact.kind))).map(r => String(r.fact.kind)) ?? [];
     }
-    catch {
-        // Missing/unreadable session log → fail-closed at zero terminal facts.
-        typedKinds = [];
+    catch (error) {
+        return { ...input.mapped, ok: false, failureCategory: "frontend-ledger-invalid", stderr: `FRONTEND_REVIEW_SCOPE_INCOMPLETE: ${error instanceof Error ? error.message : String(error)}` };
     }
     let legacyVerdict;
     try {
@@ -3361,13 +3539,7 @@ async function runFrontendReviewTerminalShadow(input) {
             reason: `typed review equivalence comparison crashed: ${error instanceof Error ? error.message : String(error)}`,
         };
     }
-    // Audit-only flush + artifact. Neither blocks the node.
-    try {
-        await input.tools?.flush?.();
-    }
-    catch {
-        // best-effort
-    }
+    // The durable ledger was validated above; this artifact is audit-only.
     try {
         await writeDagNodeJsonArtifact(input.meta.runDir, input.task.id, "fact-review-status.json", {
             schemaVersion: 1,
@@ -3409,23 +3581,16 @@ async function runFrontendDesignTerminalShadow(input) {
     // diagnosed as an omitted terminal tool call.
     if (!input.mapped.ok)
         return input.mapped;
-    const sessionEventsPath = path.join(input.meta.runDir, input.task.id, "session-events.jsonl");
     let typedKinds = [];
     try {
-        const content = await readFile(sessionEventsPath, "utf8");
-        typedKinds = scanDesignTerminalKindsFromSessionEvents(content);
+        await input.tools?.flush();
+        input.tools?.scopeProtocol?.assertComplete();
+        typedKinds = input.tools?.scopeProtocol?.committedFacts().filter(r => ["approve_design", "request_design_changes"].includes(String(r.fact.kind))).map(r => String(r.fact.kind)) ?? [];
     }
-    catch {
-        // Missing/unreadable session log → fail-closed at zero terminal facts.
-        typedKinds = [];
-    }
-    // Audit-only flush + artifact. Neither blocks the node.
-    try {
-        await input.tools?.flush?.();
-    }
-    catch {
-        // best-effort
+    catch (error) {
+        return { ...input.mapped, ok: false, failureCategory: "frontend-ledger-invalid", stderr: `FRONTEND_REVIEW_SCOPE_INCOMPLETE: ${error instanceof Error ? error.message : String(error)}` };
     }
+    // The durable ledger was validated above; this artifact is audit-only.
     try {
         await writeDagNodeJsonArtifact(input.meta.runDir, input.task.id, "fact-design-status.json", {
             schemaVersion: 1,
@@ -3458,6 +3623,7 @@ 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",
@@ -3474,13 +3640,14 @@ const FRONTEND_PLAN_SEGMENTS = [
         toolNames: new Set(["record_state_registry", "adopt_staged_fact"]),
         instruction: [
             "PLAN PHASE — global UX vocabulary.",
-            "Review ALL frozen requirements together and call record_state_registry exactly once with the complete UI-state and interaction vocabulary. 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.",
+            "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",
@@ -3488,7 +3655,7 @@ const FRONTEND_PLAN_SEGMENTS = [
         ]),
         instruction: [
             "PLAN PHASE — global UX decisions.",
-            "Requirements and verification targets are already committed in the ledger. Review the complete requirement set and the committed global UX registry together, then record each component choice, UI state and interaction. Bind each applicable state to its verificationTargetIds; the runtime derives the reverse VT.uiStates relation. If a VT requires correction, record_plan_verification_target with replace:true is available after declaring its states; preserve its requirement coverage. Multiple requirements describing one behavior share one registry name and state-flow entry. Cross-cutting data flow belongs to the global Mock/data phase. Do not record routes, Mock/API policy, dependencies, or design deviations here.",
+            "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(" "),
     },
@@ -3502,7 +3669,7 @@ const FRONTEND_PLAN_SEGMENTS = [
     },
     {
         id: "global-mock-data",
-        toolNames: new Set(["record_data_flow", "record_mock_api", "adopt_staged_fact"]),
+        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.",
@@ -3668,7 +3835,8 @@ export function collectFrontendPlanPhaseMissingFacts(input) {
         return missing;
     }
     const hasMockApi = facts.some((fact) => fact.kind === "mock-api");
-    const liveInteractions = collectCanonicalStateFlowNames(input.committedFacts).interactionNames;
+    const allInteractions = collectCanonicalStateFlowNames(input.committedFacts).interactionNames;
+    const liveInteractions = new Set([...collectCanonicalStateFlowNames(facts.filter(f => !planFactStringList(f.scopeRequirementIds).length || planFactScopeIntersects(f, new Set(input.requirementIds)))).interactionNames].filter(name => allInteractions.has(name)));
     const coveredInteractions = new Set(facts
         .filter((fact) => fact.kind === "data-flow")
         .flatMap((fact) => planFactStringList(fact.interactions)));
@@ -3754,21 +3922,15 @@ async function mapWithConcurrency(items, limit, worker) {
     }));
     return results;
 }
-function compactPromptString(value, maxChars) {
-    if (typeof value !== "string" || value.trim().length === 0)
-        return undefined;
-    const normalized = value.trim();
-    return normalized.length <= maxChars
-        ? normalized
-        : `${normalized.slice(0, maxChars - 1)}…`;
+function compactPromptString(value, _maxChars) {
+    return typeof value === "string" && value.trim().length ? value.trim() : undefined;
 }
-function compactPromptStringArray(value, maxEntries = 12, maxChars = 180) {
+function compactPromptStringArray(value, _maxEntries = 12, maxChars = 180) {
     if (!Array.isArray(value))
         return [];
     return value
         .map((item) => compactPromptString(item, maxChars))
-        .filter((item) => item !== undefined)
-        .slice(0, maxEntries);
+        .filter((item) => item !== undefined);
 }
 function countFrontendPlanTargetSurfaces(basePrompt) {
     const match = /<frontend_plan_input>[\s\S]*?<\/frontend_plan_input>/.exec(basePrompt);
@@ -3841,7 +4003,7 @@ export function compactFrontendPlanPromptForRequirementSlice(basePrompt, require
         }
     }
     if (!payload || !Array.isArray(payload.requirements))
-        return basePrompt;
+        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))
@@ -3853,7 +4015,7 @@ export function compactFrontendPlanPromptForRequirementSlice(basePrompt, require
     }
     const requirements = slice.map((id) => requirementsById.get(id));
     if (requirements.some((requirement) => requirement === undefined)) {
-        return basePrompt;
+        throw Error(`FRONTEND_INPUT_SCOPE_MISSING: ${slice.filter(id => !requirementsById.has(id)).join(", ")}`);
     }
     const compactRequirements = requirements.map((requirement) => ({
         id: compactPromptString(requirement.id, 80),
@@ -3961,6 +4123,9 @@ export function compactFrontendPlanPromptForRequirementSlice(basePrompt, require
         ? 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
@@ -4082,7 +4247,7 @@ function compactFrontendPlanLedgerContext(input) {
                             covers: compactPromptStringArray(item.covers, 40, 120),
                             evidencePath: compactPromptString(item.evidencePath, 180),
                         }];
-                }).slice(0, 24)
+                })
                 : [];
             if (choices.length > 0)
                 compactFacts.push({ kind: fact.kind, uiComponentChoices: choices });
@@ -4099,8 +4264,8 @@ function compactFrontendPlanLedgerContext(input) {
         if (fact.kind === "state-flow") {
             compactFacts.push({
                 kind: fact.kind,
-                uiStates: Array.isArray(fact.uiStates) ? fact.uiStates.slice(0, 24) : [],
-                interactions: Array.isArray(fact.interactions) ? fact.interactions.slice(0, 24) : [],
+                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),
             });
@@ -4123,7 +4288,7 @@ function compactFrontendPlanLedgerContext(input) {
                 mockApi: {
                     strategy: compactPromptString(mockApi.strategy, 40),
                     activation: compactPromptString(mockApi.activation, 180),
-                    endpoints: Array.isArray(mockApi.endpoints) ? mockApi.endpoints.slice(0, 24) : [],
+                    endpoints: Array.isArray(mockApi.endpoints) ? mockApi.endpoints : [],
                 },
             });
             continue;
@@ -4145,9 +4310,9 @@ function compactFrontendPlanLedgerContext(input) {
     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");
     const boundedFacts = [
-        ...priorityFacts.slice(0, 64),
-        ...otherFacts.slice(-32),
-    ].slice(0, 96);
+        ...priorityFacts,
+        ...otherFacts,
+    ];
     return [
         "<frontend_plan_ledger>",
         "Committed plan facts from earlier sessions. Treat these as authoritative; correct them only with the allowed replacement/removal fields.",
@@ -4155,6 +4320,208 @@ function compactFrontendPlanLedgerContext(input) {
         "</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_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;
+        }
+        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: input.sessionOptions.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, 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)
+            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-shadow-dual-write.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) {
+    // 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)"}. Each obligation is complete. Submit small records immediately, then 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" };
+                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;
+                }
+                if (!last.ok)
+                    return last;
+                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);
+    }
+}
 export async function runFrontendPlanSegmentedSessions(input) {
     const queue = [];
     const coverageSegment = FRONTEND_PLAN_SEGMENTS.find((segment) => segment.id === "coverage");
@@ -4163,10 +4530,10 @@ export async function runFrontendPlanSegmentedSessions(input) {
     const globalMockDataSegment = FRONTEND_PLAN_SEGMENTS.find((segment) => segment.id === "global-mock-data");
     const finalizeSegment = FRONTEND_PLAN_SEGMENTS.find((segment) => segment.id === "finalize");
     const allRequirementIds = input.requirementIds ?? [];
-    const buildPhasePrompt = (segment, missing = []) => {
+    const buildPhasePrompt = (segment, missing = [], scopeIds = allRequirementIds) => {
         const compact = allRequirementIds.length > 0
-            ? compactFrontendPlanPromptForRequirementSlice(input.basePrompt, allRequirementIds, {
-                includeRequirementText: segment.id === "global-mock-data" || segment.id === "global-dependency-deviation",
+            ? compactFrontendPlanPromptForRequirementSlice(input.basePrompt, scopeIds, {
+                includeRequirementText: segment.id === "global-mock-data",
                 includeVerificationTargets: false,
                 includeDesignEvidence: segment.id === "global-dependency-deviation" || segment.id === "finalize",
                 includeChecklist: false,
@@ -4182,8 +4549,9 @@ export async function runFrontendPlanSegmentedSessions(input) {
         const ledger = input.committedFacts
             ? compactFrontendPlanLedgerContext({
                 committedFacts: input.committedFacts(),
-                requirementIds: allRequirementIds,
+                requirementIds: scopeIds,
                 kinds,
+                ...(segment.id === "global-mock-data" ? { scopedKinds: ["state-flow"] } : {}),
             })
             : "";
         return [
@@ -4221,13 +4589,13 @@ export async function runFrontendPlanSegmentedSessions(input) {
                     "component-choice",
                     "state-flow",
                 ],
-                scopedKinds: ["component-choice", "state-flow"],
+                scopedKinds: ["state-flow"],
             })
             : "";
         return [
             compactFrontendPlanPromptForRequirementSlice(input.basePrompt, slice),
             uxSegment.instruction,
-            `GLOBAL UX SCOPE: process the complete requirement set together: ${slice.join(", ")}. Do not split or rename one behavior by requirement id.`,
+            `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
                 ? [
@@ -4251,6 +4619,7 @@ export async function runFrontendPlanSegmentedSessions(input) {
             : "";
         const compact = allRequirementIds.length > 0
             ? compactFrontendPlanPromptForRequirementSlice(input.basePrompt, allRequirementIds, {
+                includeRequirementText: false,
                 includeVerificationTargets: false,
                 includeDesignEvidence: false,
                 includeChecklist: false,
@@ -4296,7 +4665,7 @@ export async function runFrontendPlanSegmentedSessions(input) {
                 : []),
         ].filter(Boolean).join("\n\n");
     };
-    const compactFinalizeInstruction = "This is a small-request compact pass. Reconcile the committed local facts with route, data-flow, Mock/API, dependency and deviation policy, then call finalize_plan exactly once.";
+    const compactFinalizeInstruction = "This is a small-request compact pass. Reconcile the committed local facts with route, data-flow, Mock/API, dependency and deviation policy, then call finalize_plan; correct rejected facts and retry until exactly one successful terminal commit.";
     const buildCompactFinalizePrompt = (missing = []) => [buildPhasePrompt(finalizeSegment, missing), compactFinalizeInstruction].join("\n\n");
     const mapPlannerExhaustion = (r, committedAnyFacts) => isPlannerThinkingExhausted(r, committedAnyFacts)
         ? {
@@ -4340,7 +4709,24 @@ export async function runFrontendPlanSegmentedSessions(input) {
             tokensUsed: 0,
         };
     }
-    const estimatedCalls = (input.requirementIds ?? []).reduce((total, id) => total + Math.max(1, input.requirementCosts?.get(id) ?? 2), 0);
+    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.length ? 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) : allRequirementIds.map(id => ({ id, kind: "unclassified", requirementIds: [id] }));
+    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 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) }] : [];
+        });
+        const scaffoldBytes = Buffer.byteLength(input.basePrompt.replace(/<frontend_plan_input>[\s\S]*?<\/frontend_plan_input>/, JSON.stringify({ ...compiledInput, requirements: [] }))) + Buffer.byteLength(JSON.stringify(input.segmentCustomTools(coverageSegment.toolNames)));
+        return packFrontendInputUnits(work, { targetBytes: Math.max(1, (input.sessionOptions.frontendExecutionPolicy?.scopeTargetBytes ?? FRONTEND_SCOPE_TARGET_BYTES) - scaffoldBytes), maxUnits: input.sessionOptions.frontendExecutionPolicy?.maxScopeUnits ?? 4, maxCost: FRONTEND_PLAN_COVERAGE_MAX_RECORD_CALLS, cost: g => g.estimatedCalls }).map(batch => batch.flatMap(g => g.requirementIds));
+    };
+    const estimatedCalls = workGroups.reduce((total, group) => total + workCost(group.requirementIds), 0);
     const targetSurfaceCount = countFrontendPlanTargetSurfaces(input.basePrompt);
     // Small, single-surface requests do not benefit from six isolated Pi
     // sessions. Keep the typed ledger as the authority, but let one local
@@ -4350,13 +4736,14 @@ export async function runFrontendPlanSegmentedSessions(input) {
     const useCompactSmallPlan = requirementIdsProvided &&
         input.compactSmallPlan === true &&
         input.requirementCosts !== undefined &&
-        estimatedCalls > 12 &&
-        (input.requirementIds?.length ?? 0) <= FRONTEND_PLAN_SMALL_MAX_REQUIREMENTS &&
+        workGroups.length <= FRONTEND_PLAN_SMALL_MAX_REQUIREMENTS &&
+        Buffer.byteLength(input.basePrompt) + Buffer.byteLength(JSON.stringify(input.segmentCustomTools(null))) <= (input.sessionOptions.frontendExecutionPolicy?.scopeTargetBytes ?? FRONTEND_SCOPE_TARGET_BYTES) * 2 &&
         estimatedCalls <= FRONTEND_PLAN_SMALL_MAX_ESTIMATED_CALLS &&
         targetSurfaceCount === 1;
     if (useCompactSmallPlan) {
         const compactLocalTools = new Set([
             "record_plan_requirement",
+            "record_plan_group_coverage",
             "record_plan_verification_target",
             "record_plan_evidence_gap",
             "record_state_registry",
@@ -4384,13 +4771,8 @@ export async function runFrontendPlanSegmentedSessions(input) {
         });
     }
     else if (coverageWorkIds.length > 0) {
-        const coverageBatches = batchFrontendPlanRequirements({
-            requirementIds: coverageWorkIds,
-            maxEstimatedRecordCalls: FRONTEND_PLAN_COVERAGE_MAX_RECORD_CALLS,
-            maxRequirements: 4,
-            requirementCosts: input.requirementCosts,
-        });
-        coverageBatches.forEach((slice, batchIndex) => queue.push({
+        const completeBatches = buildWorkBatches(coverageWorkIds);
+        completeBatches.forEach((slice, batchIndex) => queue.push({
             id: `coverage-batch-${batchIndex + 1}`,
             toolNames: coverageSegment.toolNames,
             coverageSlice: slice,
@@ -4409,28 +4791,27 @@ export async function runFrontendPlanSegmentedSessions(input) {
                 prompt: buildUxRegistryPrompt(),
             });
         }
-        const uxSlice = requirementIdsProvided ? [...allRequirementIds] : [];
-        queue.push({
-            id: "ux-local-1",
-            // Compatibility path for an unreadable requirement inventory: there is
-            // no safe all-requirements registry phase, so the unscoped UX session
-            // must establish its registry before recording state flow.
-            toolNames: requirementIdsProvided
-                ? uxSegment.toolNames
-                : new Set([...(uxSegment.toolNames ?? []), "record_state_registry"]),
-            ...(uxSlice.length > 0 ? { requirementSlice: uxSlice } : {}),
-            prompt: uxSlice.length > 0
-                ? buildUxPrompt(uxSlice)
-                : buildPhasePrompt(uxSegment),
-        });
+        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", "finalize"].includes(segment.id))
                 continue;
-            queue.push({
-                id: segment.id,
-                toolNames: segment.toolNames,
-                prompt: buildPhasePrompt(segment),
-            });
+            if (segment.id === "global-mock-data" && requirementIdsProvided) {
+                buildWorkBatches(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),
+                });
+            }
         }
         queue.push({
             id: finalizeSegment.id,
@@ -4441,6 +4822,7 @@ export async function runFrontendPlanSegmentedSessions(input) {
     let accumulated;
     let index = 0;
     let invocationCount = 0;
+    let lastDurableCount = input.committedFactCount();
     while (index < queue.length) {
         const session = queue[index];
         const remaining = (session.coverageOnly ? session.coverageSlice ?? [] : []).filter((id) => !input.committedRequirementIds?.().has(id));
@@ -4460,7 +4842,7 @@ export async function runFrontendPlanSegmentedSessions(input) {
         }
         let prompt = session.prompt;
         if (session.coverageOnly && session.coverageSlice) {
-            const promptSlice = remaining.length > 0 ? remaining : session.coverageSlice;
+            const promptSlice = [...new Set([...remaining, ...preexistingMissing.flatMap(item => item.requirementIds)])];
             prompt = buildCoveragePrompt(promptSlice, session.missingFacts ?? preexistingMissing);
         }
         else if (session.id === "compact-local") {
@@ -4480,45 +4862,61 @@ export async function runFrontendPlanSegmentedSessions(input) {
             // Global phases and finalize also 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);
+            const segment = FRONTEND_PLAN_SEGMENTS.find((candidate) => candidate.id === session.id || (candidate.id === "global-mock-data" && session.id.startsWith("global-mock-data-")));
             if (segment) {
                 prompt =
                     session.id === "finalize" && useCompactSmallPlan
                         ? buildCompactFinalizePrompt(session.missingFacts)
-                        : buildPhasePrompt(segment, session.missingFacts);
+                        : buildPhasePrompt(segment, session.missingFacts, session.requirementSlice ?? allRequirementIds);
             }
         }
         const committedBefore = input.committedFactCount();
-        input.setActiveRequirementScope?.(session.coverageOnly ||
-            session.id === "compact-local" ||
-            session.id.startsWith("ux-local-")
-            ? session.coverageSlice ?? session.requirementSlice ?? []
-            : []);
+        input.setActiveRequirementScope?.(session.coverageOnly ? session.coverageSlice ?? [] : session.requirementSlice ?? []);
         if (invocationCount >= FRONTEND_PLAN_BATCH_MAX_SESSIONS)
             break;
         invocationCount += 1;
         const customTools = input.segmentCustomTools(session.toolNames);
-        const result = await input.piStepFn({
-            ...input.sessionOptions,
-            prompt,
-            ...(customTools.length > 0
-                ? {
-                    writerToolPolicy: {
-                        requireSdk: true,
-                        customTools,
-                    },
-                }
-                : {}),
+        const scopeForPacking = session.coverageSlice ?? session.requirementSlice;
+        const envelopeBytes = Buffer.byteLength(prompt) + Buffer.byteLength(input.sessionOptions.userMessage ?? "") + Buffer.byteLength(JSON.stringify(customTools));
+        if (envelopeBytes > (input.sessionOptions.frontendExecutionPolicy?.scopeTargetBytes ?? FRONTEND_SCOPE_TARGET_BYTES) && scopeForPacking && session.id !== "compact-local") {
+            const groups = workGroups.map(g => g.requirementIds.filter(id => scopeForPacking.includes(id))).filter(g => g.length);
+            if (groups.length > 1) {
+                const half = Math.ceil(groups.length / 2);
+                queue.splice(index, 1, ...[groups.slice(0, half).flat(), groups.slice(half).flat()].map(slice => ({ ...session, ...(session.coverageOnly ? { coverageSlice: slice } : { requirementSlice: slice }) })));
+                invocationCount -= 1;
+                continue;
+            }
+        }
+        const result = await observeFrontendSession({
+            ...input.observation, phase: `plan/${session.id}`, 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;
-        try {
-            await input.flushLedger();
-        }
-        catch {
-            // best-effort: the node-level flush runs again after the attempt
-        }
         const committedAfter = input.committedFactCount();
         const committedFactsOnlySuccess = session.id !== "finalize" &&
             !(result.assistantText ?? "").trim() &&
@@ -4565,10 +4963,10 @@ export async function runFrontendPlanSegmentedSessions(input) {
                         committedFacts: input.committedFacts(),
                         behaviorRequiredRequirementIds: input.behaviorRequiredRequirementIds,
                     })
-                    : session.id === "global-mock-data" && allRequirementIds.length > 0 && input.committedFacts
+                    : session.id.startsWith("global-mock-data") && allRequirementIds.length > 0 && input.committedFacts
                         ? collectFrontendPlanPhaseMissingFacts({
                             phase: "global-mock-data",
-                            requirementIds: allRequirementIds,
+                            requirementIds: session.requirementSlice ?? allRequirementIds,
                             committedFacts: input.committedFacts(),
                         })
                         : [];
@@ -4605,7 +5003,58 @@ export async function runFrontendPlanSegmentedSessions(input) {
                         ? buildCompactFinalizePrompt(missing)
                         : isUxLocalSession
                             ? buildUxPrompt(session.requirementSlice ?? [], missing)
-                            : buildPhasePrompt(globalMockDataSegment, missing);
+                            : buildPhasePrompt(globalMockDataSegment, missing, session.requirementSlice ?? allRequirementIds);
+        if (result.timedOut || /interrupt|termination-unconfirmed|budget_breach/.test(result.failureCategory))
+            return { ...result, ok: false };
+        const capacityExhausted = readWriterThinkingExhaustionEvidence(result).stopReason === "length" || ["context-overflow", "context-budget-exhausted"].includes(result.failureCategory);
+        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;
@@ -4649,24 +5098,6 @@ export async function runFrontendPlanSegmentedSessions(input) {
             index += 1;
             continue;
         }
-        // A length-stopped, fact-less compact session is the planner variant of
-        // writer-thinking-exhausted. Give the same scope exactly one tool-first
-        // retry before the split below re-batches the requirements, because one
-        // reinforced full-scope pass is cheaper than re-planning split halves.
-        const plannerThinkingBurn = isCompactLocalSession &&
-            committedAfter === committedBefore &&
-            !(result.assistantText ?? "").trim() &&
-            !result.stderr.trim() &&
-            !result.timedOut &&
-            readWriterThinkingExhaustionEvidence(result).stopReason === "length";
-        if (plannerThinkingBurn && (session.retryCount ?? 0) < 1) {
-            queue[index] = {
-                ...session,
-                retryCount: (session.retryCount ?? 0) + 1,
-                prompt: buildCompactLocalPrompt(),
-            };
-            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
@@ -4681,20 +5112,24 @@ export async function runFrontendPlanSegmentedSessions(input) {
                 : undefined;
         const zeroProgressBurn = coverageSlice !== undefined &&
             coverageSlice.length > 1 &&
-            committedAfter === committedBefore &&
-            !(result.assistantText ?? "").trim() &&
-            !result.stderr.trim() &&
+            (readWriterThinkingExhaustionEvidence(result).stopReason === "length" || ["context-overflow", "context-budget-exhausted"].includes(result.failureCategory) || (committedAfter === committedBefore && !(result.assistantText ?? "").trim() && !result.stderr.trim())) &&
             !result.timedOut;
         if (zeroProgressBurn && coverageSlice) {
-            const half = Math.ceil(coverageSlice.length / 2);
-            const firstSlice = coverageSlice.slice(0, half);
-            const secondSlice = coverageSlice.slice(half);
+            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,
@@ -4702,6 +5137,7 @@ export async function runFrontendPlanSegmentedSessions(input) {
                 }, {
                     ...session,
                     id: `coverage-compact-split-2`,
+                    toolNames: coverageSegment.toolNames, retryCount: 0,
                     coverageOnly: true,
                     coverageSlice: secondSlice,
                     requirementSlice: secondSlice,
@@ -4720,7 +5156,9 @@ export async function runFrontendPlanSegmentedSessions(input) {
             });
             continue;
         }
-        if ((session.coverageOnly || isUxRegistrySession || isUxLocalSession || session.id === "global-mock-data") &&
+        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 &&
@@ -4852,14 +5290,27 @@ async function runFrontendScoutParallelSessions(input) {
                 ...input.sessionOptions,
                 sessionEventsPath: path.join(input.runDir, shardNodeId, "session-events.jsonl"),
             };
-            shardResult = await input.piStepFn({
+            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,
-                prompt: `${input.basePrompt}\n\n${shard.instruction}`,
+                onAttemptObservation: observer,
+                prompt,
                 writerToolPolicy: {
                     requireSdk: true,
-                    customTools: [...customTools, ...(input.readBudgetTools ?? [])],
+                    customTools: tools,
                 },
-            });
+            }));
             await shardTools.flush();
             return { shard, result: shardResult, tools: shardTools };
         }
@@ -5035,6 +5486,8 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
     let writerToolPolicy;
     let reviewTerminalTools;
     let designTerminalTools;
+    let reviewInventory;
+    let designInventory;
     let planLedgerTools;
     let contractTools;
     let scoutEvidenceTools;
@@ -5128,6 +5581,8 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
             const { createTypedEventStore } = await import("../workflows/dag/frontend-typed-event-store.js");
             const store = createTypedEventStore();
             reviewTerminalTools = await createFrontendReviewTerminalTools({
+                inventory: reviewInventory = await loadFrontendReviewScopes(meta.runDir, "review", meta.spec?.frontendExecutionPolicy?.scopeTargetBytes ?? FRONTEND_SCOPE_TARGET_BYTES),
+                inputDigest: reviewInventory?.digest ?? createHash("sha256").update(input.prompt).digest("hex"),
                 attemptId: `${meta.runId}:${input.task.id}`,
                 store,
                 runDir: meta.runDir,
@@ -5153,6 +5608,8 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
             const { createTypedEventStore } = await import("../workflows/dag/frontend-typed-event-store.js");
             const store = createTypedEventStore();
             designTerminalTools = await createFrontendDesignTerminalTools({
+                inventory: designInventory = await loadFrontendReviewScopes(meta.runDir, "design", meta.spec?.frontendExecutionPolicy?.scopeTargetBytes ?? FRONTEND_SCOPE_TARGET_BYTES),
+                inputDigest: designInventory?.digest ?? createHash("sha256").update(input.prompt).digest("hex"),
                 attemptId: `${meta.runId}:${input.task.id}`,
                 store,
                 runDir: meta.runDir,
@@ -5178,6 +5635,7 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
             const { createTypedEventStore } = await import("../workflows/dag/frontend-typed-event-store.js");
             const store = createTypedEventStore();
             contractTools = await createFrontendContractTools({
+                sourceDigest: (meta.spec?.sourceBinding?.schemaVersion === 2 ? meta.spec.sourceBinding.inputDigest : undefined),
                 attemptId: `${meta.runId}:${input.task.id}`,
                 store,
                 runDir: meta.runDir,
@@ -5211,6 +5669,8 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
                 spec: meta.spec,
             });
             scoutEvidenceTools = await createFrontendScoutEvidenceTools({
+                requirementIds: parseFrontendInputBlock(input.prompt, "scout")?.payload.requirements.map(r => r.id),
+                sourceDigest: (meta.spec?.sourceBinding?.schemaVersion === 2 ? meta.spec.sourceBinding.inputDigest : undefined),
                 attemptId: `${meta.runId}:${input.task.id}`,
                 store,
                 runDir: meta.runDir,
@@ -5368,6 +5828,8 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
             activeTools: toolNames,
         });
         const piSessionOptions = {
+            reserveProviderRequest: input.reserveProviderRequest,
+            frontendExecutionPolicy: meta.spec?.frontendExecutionPolicy,
             attachedFiles: [],
             modelConfig,
             repoRoot: input.cwd,
@@ -5409,6 +5871,15 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
                 workspaceRoot: input.cwd,
                 sourceDeclaredPaths: scoutSourceDeclaredPaths,
                 readBudgetTools: readBudgetTools?.customTools,
+                observation: {
+                    artifactPath: path.join(meta.runDir, input.task.id, "session-budget", `attempt-${input.attempt ?? 1}`),
+                    runId: meta.runId,
+                    nodeId: input.task.id,
+                    taskId: meta.spec?.sourceBinding?.taskId,
+                    attempt: input.attempt ?? 1,
+                    model: input.model,
+                    sourceDigest: meta.spec?.sourceBinding?.schemaVersion === 2 ? meta.spec.sourceBinding.inputDigest : undefined,
+                },
             });
         }
         else if (isFrontendPlanLedgerNode(input.task) && planLedgerTools) {
@@ -5448,6 +5919,16 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
             // finalize reducer. This avoids revision races while shortening the
             // longest coverage phase for large plans.
             const runPlanSessions = (options) => runFrontendPlanSegmentedSessions({
+                observation: options.observation ?? {
+                    artifactPath: path.join(meta.runDir, input.task.id, "session-budget", `attempt-${input.attempt ?? 1}`),
+                    runId: meta.runId,
+                    nodeId: input.task.id,
+                    taskId: meta.spec?.sourceBinding?.taskId,
+                    attempt: input.attempt ?? 1,
+                    model: input.model,
+                    sourceDigest: meta.spec?.sourceBinding?.schemaVersion === 2 ? meta.spec.sourceBinding.inputDigest : undefined,
+                    contractDigest: meta.spec?.taskContractBinding?.canonicalHash,
+                },
                 piStepFn,
                 sessionOptions: options.sessionOptions,
                 basePrompt: options.basePrompt ?? input.prompt,
@@ -5527,6 +6008,16 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
                                     requirementIds: slice,
                                     basePrompt: `${input.prompt}\n\nPARALLEL COVERAGE SHARD ${index + 1}: use the frozen canonical behavior verification-target ids listed in the record_plan_verification_target tool description — do not prefix ids with a shard namespace or invent variant ids; identical cross-shard targets are deduped, divergent ones fail the merge.`,
                                     parallelCoverageOnly: true,
+                                    observation: {
+                                        artifactPath: path.join(meta.runDir, input.task.id, "parallel", `coverage-${index + 1}`, "session-budget", `attempt-${input.attempt ?? 1}`),
+                                        runId: meta.runId,
+                                        nodeId: `${input.task.id}/parallel/coverage-${index + 1}`,
+                                        taskId: meta.spec?.sourceBinding?.taskId,
+                                        attempt: input.attempt ?? 1,
+                                        model: input.model,
+                                        sourceDigest: meta.spec?.sourceBinding?.schemaVersion === 2 ? meta.spec.sourceBinding.inputDigest : undefined,
+                                        contractDigest: meta.spec?.taskContractBinding?.canonicalHash,
+                                    },
                                 });
                                 await shardTools.flush();
                                 return { index, result: shardResult, tools: shardTools };
@@ -5626,12 +6117,31 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
                 });
             }
         }
+        else if (contractTools) {
+            result = await runFrontendContractSegmentedSessions({
+                piStepFn, sessionOptions: piSessionOptions, basePrompt: input.prompt, tools: contractTools,
+                observation: { artifactPath: path.join(meta.runDir, input.task.id, "session-budget", `attempt-${input.attempt ?? 1}`), runId: meta.runId, nodeId: input.task.id, taskId: meta.spec?.sourceBinding?.taskId, attempt: input.attempt ?? 1, model: input.model, sourceDigest: meta.spec?.sourceBinding?.schemaVersion === 2 ? meta.spec.sourceBinding.inputDigest : undefined },
+            });
+        }
+        else if ((reviewInventory && reviewTerminalTools) || (designInventory && designTerminalTools)) {
+            result = await runFrontendReviewSegmentedSessions({ piStepFn, sessionOptions: piSessionOptions, basePrompt: input.prompt, inventory: (reviewInventory ?? designInventory), tools: (reviewTerminalTools ?? designTerminalTools), customTools: writerToolPolicy.customTools, phase: reviewInventory ? "review" : "design",
+                observation: { artifactPath: path.join(meta.runDir, input.task.id, "session-budget", `attempt-${input.attempt ?? 1}`), runId: meta.runId, nodeId: input.task.id, taskId: meta.spec?.sourceBinding?.taskId, attempt: input.attempt ?? 1, model: input.model, contractDigest: (reviewInventory ?? designInventory).digest } });
+        }
+        else if (scoutEvidenceTools && parseFrontendInputBlock(input.prompt, "scout")) {
+            result = await runFrontendScoutSegmentedSessions({ piStepFn, sessionOptions: piSessionOptions, basePrompt: input.prompt, tools: scoutEvidenceTools, customTools: writerToolPolicy.customTools,
+                observation: { artifactPath: path.join(meta.runDir, input.task.id, "session-budget", `attempt-${input.attempt ?? 1}`), runId: meta.runId, nodeId: input.task.id, taskId: meta.spec?.sourceBinding?.taskId, attempt: input.attempt ?? 1, model: input.model, sourceDigest: meta.spec?.sourceBinding?.schemaVersion === 2 ? meta.spec.sourceBinding.inputDigest : undefined } });
+        }
         else {
-            result = await piStepFn({
+            result = await observeFrontendSession({
+                artifactPath: input.task.id.startsWith("frontend-") ? path.join(meta.runDir, input.task.id, "session-budget", `attempt-${input.attempt ?? 1}.json`) : undefined,
+                phase: input.task.id, prompt: input.prompt, userMessage: piSessionOptions.userMessage, customTools: writerToolPolicy?.customTools,
+                runId: meta.runId, nodeId: input.task.id, taskId: meta.spec?.sourceBinding?.taskId, attempt: input.attempt ?? 1, model: input.model, sourceDigest: (meta.spec?.sourceBinding?.schemaVersion === 2 ? meta.spec.sourceBinding.inputDigest : undefined), contractDigest: meta.spec?.taskContractBinding?.canonicalHash,
+            }, observer => piStepFn({
                 ...piSessionOptions,
+                onAttemptObservation: observer,
                 prompt: input.prompt,
                 ...(writerToolPolicy ? { writerToolPolicy } : {}),
-            });
+            }));
         }
         try {
             const verificationCommandFiles = collectFrontendVerificationCommandFiles(input.prompt);
@@ -5796,8 +6306,8 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
         try {
             await scoutEvidenceTools?.flush?.();
         }
-        catch {
-            // best-effort flush
+        catch (error) {
+            return { ...mapped, ok: false, failureCategory: mapped.ok ? "frontend-ledger-invalid" : mapped.failureCategory, stderr: `${mapped.stderr}\nFRONTEND_LEDGER_INTEGRITY_INVALID: ${error instanceof Error ? error.message : String(error)}` };
         }
         if (mapped.ok) {
             const { checkCommittedOriginFacts, readCommittedOriginFacts } = await import("../workflows/dag/frontend-shadow-dual-write.js");