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

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.44.0-next.10",
-  "gitSha": "9ab06d59ee69d2e55b671bba52ee83e0362ec56f",
-  "builtAt": "2026-09-17T03:17:20.149Z"
+  "version": "0.44.0-next.11",
+  "gitSha": "332db6a894b640eef5c495e3a3ba92b383fcf259",
+  "builtAt": "2026-09-17T05:51:06.283Z"
 }

package/dist/executors/dag-pi/sessions/index.js

@@ -0,0 +1,6 @@
+/** DAG Pi 会话族兼容转发：既有测试从 entry 导入的符号统一经此转发，逐步迁移后移除。 */
+export { estimateFrontendPlanRequirementRecordCalls, batchFrontendPlanRequirements, FRONTEND_PLAN_COVERAGE_MAX_CONCURRENCY, FRONTEND_PLAN_BATCH_MAX_SESSIONS, mapWithConcurrency, buildFrontendPlanWorkload, collectFrontendPlanRequirementIds, loadOrCreateFrontendPlanCoverageLayout, collectFrontendVerificationCommandFiles } from "./plan-batches.js";
+export { compactFrontendPlanLedgerContext, compactFrontendPlanPromptForRequirementSlice } from "./plan-prompts.js";
+export { isPlannerThinkingExhausted, isWriterThinkingExhausted, readWriterThinkingExhaustionEvidence, WRITER_BUDGET_EXHAUSTED_CATEGORY, WRITER_TOKEN_BUDGET, WRITER_THINKING_EXHAUSTED_CATEGORY, PLANNER_THINKING_EXHAUSTED_CATEGORY } from "./writer-evidence.js";
+export { aggregateParallelPiResults, combineSequentialPiResults, runFrontendScoutParallelSessions } from "./scout-parallel.js";
+export { runFrontendContractSegmentedSessions, runFrontendPlanSegmentedSessions, runFrontendReviewSegmentedSessions, runFrontendScoutSegmentedSessions } from "./segmented-plan.js";

package/dist/executors/dag-pi/sessions/plan-batches.js

@@ -0,0 +1,280 @@
+/** DAG Pi 分段会话的批次规划：work 装配、批次上限、覆盖布局与并发映射。覆盖布局会读写 coverage-layout.json；禁止反向依赖执行器入口。 */
+import path from "node:path";
+import { readFile, stat } from "node:fs/promises";
+import { z } from "zod";
+import { FRONTEND_SCOPE_TARGET_BYTES, packFrontendInputUnits, parseFrontendInputBlock } from "../../../workflows/dag/frontend-input-projection.js";
+import { sha256OfCanonicalJson } from "../../../task/contract/hash.js";
+import { writeDagNodeJsonArtifact } from "../../../infrastructure/harness/artifact-store.js";
+import { isRecordObject } from "../guards.js";
+export const FRONTEND_PLAN_SEGMENTS = [
+    {
+        id: "coverage",
+        toolNames: new Set([
+            "record_plan_requirement",
+            "record_plan_group_coverage",
+            "record_plan_verification_target",
+            "record_plan_evidence_gap",
+            "adopt_staged_fact",
+        ]),
+        instruction: [
+            "PLAN PHASE — requirement coverage only.",
+            "Your ONLY job: for every frozen requirement, emit record_plan_requirement (requirement → implementation files) and record_plan_verification_target facts (verification target bound to requirement ids and files). Group related requirements under one non-static behavior target when one observable test behavior proves them together; do not mechanically create one target per requirement. Target ids identify contract entries, not test-title markers. Reuse affected existing test files and their names; do not add tests or rename titles just to carry generated ids. Never submit prose as a symbol. Do NOT record components, UI states, mock, dependency, or routes — a follow-up session owns those.",
+            "A coverage session is complete only when EVERY requirement assigned to this session (the full inventory, or the exact COVERAGE BATCH / shard list when present) has committed coverage facts: a record_plan_requirement entry plus verification targets, or a committed evidence gap. Keep committing in batches of up to 4 record_* calls per assistant message until then; do not write a concluding summary while any assigned requirement is still uncommitted — an early stop strands the remainder into a MISSING-FACT repair session and doubles the sessions needed.",
+            "If a requirement genuinely cannot have a verification target, record a non-empty record_plan_evidence_gap. Do not call finalize_plan; it is not available in this phase.",
+        ].join(" "),
+    },
+    {
+        id: "ux-registry",
+        toolNames: new Set(["record_state_registry", "adopt_staged_fact"]),
+        instruction: [
+            "PLAN PHASE — global UX vocabulary.",
+            "Bootstrap the global UX vocabulary from the execution-group index and authoritative declared states. This is navigation, not permission to decide unseen behavior. Detailed complete scopes may extend the registry with replace:true while preserving live names. UI states use declaredUiStates ids when present. Interaction names are stable kebab-case behavior domains; merge requirements that describe the same behavior instead of renaming it per AC slice. Empty arrays explicitly declare that no UX vocabulary applies. Do not record component choices or state-flow details in this phase.",
+            "Do not call finalize_plan; it is not available in this phase.",
+        ].join(" "),
+    },
+    {
+        id: "ux-local",
+        toolNames: new Set([
+            "record_state_registry",
+            "record_component_choice",
+            "record_state_flow",
+            "record_plan_verification_target",
+            "adopt_staged_fact",
+        ]),
+        instruction: [
+            "PLAN PHASE — global UX decisions.",
+            "Requirements and verification targets are already committed in the ledger; do not re-record unchanged facts. Review the current complete execution-group scope and the committed global UX registry together, then record each component choice, UI state and interaction exactly once. Bind each applicable state to its verificationTargetIds; the runtime derives the reverse VT.uiStates relation. If a VT requires correction, record_plan_verification_target with replace:true is available after declaring its states; preserve its requirement coverage. Multiple requirements describing one behavior share one registry name and state-flow entry; never repeat or rename it per AC. Cross-cutting data flow belongs to the global Mock/data phase. Do not record routes, Mock/API policy, dependencies, or design deviations here.",
+            "Do not call finalize_plan; it is not available in this phase.",
+        ].join(" "),
+    },
+    {
+        id: "global-route",
+        toolNames: new Set(["record_route_selection", "adopt_staged_fact"]),
+        instruction: [
+            "PLAN PHASE — global route decision.",
+            "Use the Scout target surface and record only the selected route(s). Do not record requirement-local UX, Mock/data, dependency, or deviation facts. Do not call finalize_plan.",
+        ].join(" "),
+    },
+    {
+        id: "global-mock-data",
+        toolNames: new Set(["record_data_flow", "record_mock_api", "record_mock_endpoint", "adopt_staged_fact"]),
+        instruction: [
+            "PLAN PHASE — global Mock/API and data policy.",
+            "Record the cross-cutting interaction-to-endpoint data flow and Mock/API strategy only. Keep this decision set separate from route, component, state, dependency, and deviation facts. Do not call finalize_plan.",
+        ].join(" "),
+    },
+    {
+        id: "global-dependency-deviation",
+        toolNames: new Set(["record_dependency", "record_design_deviation", "adopt_staged_fact"]),
+        instruction: [
+            "PLAN PHASE — global dependency and design-deviation policy.",
+            "Record only dependency policy and design-evidence conflicts. Do not record route, Mock/data, or requirement-local UX facts. Do not call finalize_plan.",
+        ].join(" "),
+    },
+];
+export function estimateFrontendPlanRequirementRecordCalls(fact) {
+    const record = fact && typeof fact === "object" && !Array.isArray(fact)
+        ? fact
+        : {};
+    const declaredTargetCount = Array.isArray(record.verificationTargetIds)
+        ? record.verificationTargetIds.filter((value) => typeof value === "string" && value.trim()).length
+        : Array.isArray(record.verificationTargets)
+            ? record.verificationTargets.length
+            : 0;
+    const evidence = record.evidence && typeof record.evidence === "object"
+        ? record.evidence
+        : undefined;
+    const targetCount = Math.max(declaredTargetCount, evidence?.behavior === "required" ? 2 : 1);
+    return 1 + targetCount;
+}
+export function batchFrontendPlanRequirements(input) {
+    const batches = [];
+    let current = [];
+    let currentCost = 0;
+    for (const id of input.requirementIds) {
+        const cost = Math.max(1, input.requirementCosts?.get(id) ?? 2);
+        if (current.length > 0 &&
+            (currentCost + cost > input.maxEstimatedRecordCalls ||
+                (input.maxRequirements !== undefined &&
+                    current.length >= input.maxRequirements))) {
+            batches.push(current);
+            current = [];
+            currentCost = 0;
+        }
+        current.push(id);
+        currentCost += cost;
+    }
+    if (current.length > 0)
+        batches.push(current);
+    return batches;
+}
+export const FRONTEND_PLAN_COVERAGE_MAX_RECORD_CALLS = 10;
+export const FRONTEND_PLAN_COVERAGE_MAX_CONCURRENCY = 4;
+export const FRONTEND_PLAN_BATCH_MAX_SESSIONS = 128;
+export const FRONTEND_PLAN_SMALL_MAX_REQUIREMENTS = 8;
+export const FRONTEND_PLAN_SMALL_MAX_ESTIMATED_CALLS = 24;
+export async function mapWithConcurrency(items, limit, worker, shouldReduceConcurrency) {
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    let concurrency = Math.max(1, limit);
+    const running = new Map();
+    try {
+        while (nextIndex < items.length || running.size > 0) {
+            while (nextIndex < items.length && running.size < concurrency) {
+                const index = nextIndex++;
+                running.set(index, worker(items[index], index).then(result => ({ index, result })));
+            }
+            const { index, result } = await Promise.race(running.values());
+            running.delete(index);
+            results[index] = result;
+            // Drain existing work; only pending shards use the reduced cap.
+            // Failed shards remain failed and receive no extra retry allowance.
+            if (shouldReduceConcurrency(result))
+                concurrency = Math.max(1, Math.floor(concurrency / 2));
+        }
+    }
+    catch (error) {
+        await Promise.allSettled(running.values());
+        throw error;
+    }
+    return results;
+}
+export function collectFrontendVerificationCommandFiles(basePrompt) {
+    const files = new Set();
+    const configRe = /--config\s+([\w@./-]+\.(?:js|mjs|cjs|ts|json))/g;
+    const checkRe = /node\s+--check\s+([\w@./-]+\.(?:js|mjs|cjs))/g;
+    for (const re of [configRe, checkRe]) {
+        for (const match of basePrompt.matchAll(re)) {
+            const file = match[1];
+            if (file && file.includes("/"))
+                files.add(file);
+        }
+    }
+    return [...files].sort();
+}
+export function countFrontendPlanTargetSurfaces(basePrompt) {
+    const match = /<frontend_plan_input>[\s\S]*?<\/frontend_plan_input>/.exec(basePrompt);
+    if (!match)
+        return undefined;
+    for (const line of match[0].split(/\r?\n/)) {
+        try {
+            const payload = JSON.parse(line);
+            if (Array.isArray(payload.targetSurface))
+                return payload.targetSurface.length;
+        }
+        catch {
+            // surrounding lines are prose
+        }
+    }
+    return undefined;
+}
+export function buildFrontendPlanWorkload(input) {
+    const allRequirementIds = input.requirementIds;
+    const compiledInput = parseFrontendInputBlock(input.basePrompt, "plan")?.payload;
+    const fullUnits = new Map(compiledInput?.requirements.map(r => [r.id, r]) ?? []);
+    const declaredGroups = Array.isArray(compiledInput?.executionGroups)
+        ? compiledInput.executionGroups.filter(isRecordObject) : [];
+    const workGroups = declaredGroups.map(g => ({
+        id: String(g.id), kind: String(g.kind),
+        requirementIds: Array.isArray(g.requirementIds)
+            ? g.requirementIds.filter((id) => typeof id === "string" && allRequirementIds.includes(id)) : [],
+    })).filter(g => g.requirementIds.length);
+    const groupedIds = new Set(workGroups.flatMap(g => g.requirementIds));
+    for (const id of allRequirementIds) {
+        if (!groupedIds.has(id))
+            workGroups.push({ id, kind: "unclassified", requirementIds: [id] });
+    }
+    const workCost = (ids) => 1 + ids.reduce((total, id) => total + Math.max(1, (input.requirementCosts?.get(id) ?? 2) - 1), 0);
+    const policy = input.sessionOptions.frontendExecutionPolicy;
+    const targetBytes = policy?.scopeTargetBytes ?? FRONTEND_SCOPE_TARGET_BYTES;
+    const buildWorkBatches = (ids) => {
+        const work = workGroups.flatMap((g, index) => {
+            const members = g.requirementIds.filter(id => ids.includes(id));
+            return members.length ? [{ id: `${index}:${g.id}`, requirementIds: members,
+                    requirements: members.map(id => fullUnits.get(id) ?? { id }), estimatedCalls: workCost(members) }] : [];
+        });
+        // Pack complete work units, not the repeated request scaffold. Deducting
+        // fixed context/tools can leave a one-byte budget and force one AC per
+        // session without reducing that overhead. The SDK checks the actual
+        // request against model capacity; capacity recovery splits unfinished work.
+        return packFrontendInputUnits(work, {
+            targetBytes,
+            maxUnits: policy?.maxScopeUnits ?? 4,
+            maxCost: FRONTEND_PLAN_COVERAGE_MAX_RECORD_CALLS, cost: g => g.estimatedCalls,
+        }).map(batch => batch.flatMap(g => g.requirementIds));
+    };
+    // This renderer also carries the Plan's evolving UX checkpoint on resume.
+    // Only the Contract/Scout-derived input participates in ownership binding.
+    const { committedUx: _committedUx, ...frozenInput } = compiledInput ?? {};
+    return {
+        frozenInput, workGroups, buildWorkBatches,
+        compactEligible: input.requirementCosts !== undefined &&
+            workGroups.length <= FRONTEND_PLAN_SMALL_MAX_REQUIREMENTS &&
+            workGroups.reduce((total, group) => total + workCost(group.requirementIds), 0) <= FRONTEND_PLAN_SMALL_MAX_ESTIMATED_CALLS &&
+            countFrontendPlanTargetSurfaces(input.basePrompt) === 1,
+    };
+}
+export function collectFrontendPlanRequirementIds(contractFacts) {
+    return [
+        ...new Set(contractFacts
+            .filter((record) => record.fact?.kind ===
+            "requirement")
+            .map((record) => record.fact?.id)
+            .filter((id) => typeof id === "string")),
+    ];
+}
+export const frontendPlanCoverageLayoutSchema = z.object({
+    schemaVersion: z.literal(1),
+    bindingSha256: z.string(),
+    coverageBatches: z.array(z.array(z.string().min(1)).min(1)).min(1),
+    layoutSha256: z.string(),
+}).strict();
+export async function loadOrCreateFrontendPlanCoverageLayout(input) {
+    const fileName = "coverage-layout.json";
+    const file = path.join(input.runDir, input.nodeId, fileName);
+    const bindingSha256 = sha256OfCanonicalJson(input.binding);
+    let raw;
+    try {
+        raw = await readFile(file, "utf8");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    let layout;
+    if (raw !== undefined) {
+        layout = frontendPlanCoverageLayoutSchema.parse(JSON.parse(raw));
+    }
+    else {
+        // Losing the ownership receipt must never repartition acknowledged facts.
+        for (const relative of ["plan-typed-facts.jsonl", "parallel"]) {
+            const existing = await stat(path.join(input.runDir, input.nodeId, relative)).catch(error => {
+                if (error.code !== "ENOENT")
+                    throw error;
+                return undefined;
+            });
+            if (existing && (existing.isDirectory() || existing.size > 0)) {
+                throw Error("FRONTEND_PLAN_LAYOUT_MISSING: preserve the existing ledger and restart its owning phase");
+            }
+        }
+        const descriptor = {
+            schemaVersion: 1, bindingSha256,
+            coverageBatches: input.workload.compactEligible ? [input.requirementIds] : input.workload.buildWorkBatches(input.requirementIds),
+        };
+        layout = { ...descriptor, layoutSha256: sha256OfCanonicalJson(descriptor) };
+    }
+    const { layoutSha256, ...descriptor } = layout;
+    if (layout.bindingSha256 !== bindingSha256 || layoutSha256 !== sha256OfCanonicalJson(descriptor)) {
+        throw Error("FRONTEND_PLAN_LAYOUT_MISMATCH: frozen coverage ownership or input binding changed");
+    }
+    const members = layout.coverageBatches.flat();
+    const owners = new Map(layout.coverageBatches.flatMap((batch, index) => batch.map(id => [id, index])));
+    if (members.length !== owners.size || members.length !== input.requirementIds.length ||
+        input.requirementIds.some(id => !owners.has(id)) ||
+        input.workload.workGroups.some(group => new Set(group.requirementIds.map(id => owners.get(id))).size !== 1)) {
+        throw Error("FRONTEND_PLAN_LAYOUT_INVALID: coverage must partition complete execution groups exactly once");
+    }
+    if (raw === undefined)
+        await writeDagNodeJsonArtifact(input.runDir, input.nodeId, fileName, layout);
+    return layout.coverageBatches;
+}

package/dist/executors/dag-pi/sessions/plan-prompts.js

@@ -0,0 +1,367 @@
+/** DAG Pi 分段会话的提示词投影：覆盖/UX/全局阶段 prompt 与账本上下文压缩，禁止反向依赖执行器入口。 */
+import { projectFrontendInputScope } from "../../../workflows/dag/frontend-input-projection.js";
+import { isRecordObject } from "../guards.js";
+import { committedFactFromPlanRecord, planFactScopeIntersects, planFactStringList } from "../plan/facts.js";
+export function compactPromptString(value, _maxChars) {
+    return typeof value === "string" && value.trim().length ? value.trim() : undefined;
+}
+export function compactPromptStringArray(value, _maxEntries = 12, maxChars = 180) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((item) => compactPromptString(item, maxChars))
+        .filter((item) => item !== undefined);
+}
+export function compactFrontendPlanPromptForRequirementSlice(basePrompt, requirementIds, options = {}) {
+    const slice = [...new Set(requirementIds.filter((id) => id.trim().length > 0))];
+    if (slice.length === 0)
+        return basePrompt;
+    const planInputPattern = /<frontend_plan_input>[\s\S]*?<\/frontend_plan_input>/;
+    const planInputMatch = planInputPattern.exec(basePrompt);
+    if (!planInputMatch)
+        return basePrompt;
+    const blockLines = planInputMatch[0].split(/\r?\n/);
+    let payload;
+    for (const line of blockLines) {
+        try {
+            const parsed = JSON.parse(line);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                payload = parsed;
+                break;
+            }
+        }
+        catch {
+            // The surrounding block contains prose; only its JSON line is data.
+        }
+    }
+    if (!payload || !Array.isArray(payload.requirements))
+        throw Error("FRONTEND_INPUT_INVALID: plan inventory is not parseable");
+    const requirementsById = new Map();
+    for (const value of payload.requirements) {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            continue;
+        const requirement = value;
+        if (typeof requirement.id === "string") {
+            requirementsById.set(requirement.id, requirement);
+        }
+    }
+    const requirements = slice.map((id) => requirementsById.get(id));
+    if (requirements.some((requirement) => requirement === undefined)) {
+        throw Error(`FRONTEND_INPUT_SCOPE_MISSING: ${slice.filter(id => !requirementsById.has(id)).join(", ")}`);
+    }
+    const compactRequirements = requirements.map((requirement) => ({
+        id: compactPromptString(requirement.id, 80),
+        ...(options.includeRequirementText !== false && compactPromptString(requirement.text, 240)
+            ? { text: compactPromptString(requirement.text, 240) }
+            : {}),
+        sourceFragmentIds: compactPromptStringArray(requirement.sourceFragmentIds, 20, 80),
+    }));
+    const sliceSet = new Set(slice);
+    const compactVerificationTargets = options.includeVerificationTargets === false
+        ? []
+        : Array.isArray(payload.verificationTargets)
+            ? payload.verificationTargets.flatMap((value) => {
+                if (!value || typeof value !== "object" || Array.isArray(value))
+                    return [];
+                const target = value;
+                if (options.verificationTargetIds && !options.verificationTargetIds.includes(String(target.id)))
+                    return [];
+                const targetRequirementIds = planFactStringList(target.requirementIds);
+                const relatedRequirementIds = targetRequirementIds.filter((id) => sliceSet.has(id));
+                if (relatedRequirementIds.length === 0)
+                    return [];
+                return [
+                    {
+                        ...(typeof target.id === "string"
+                            ? { id: target.id }
+                            : {}),
+                        ...(typeof target.commandId === "string"
+                            ? { commandId: target.commandId }
+                            : {}),
+                        ...(compactPromptString(target.commandLabel, 180)
+                            ? { commandLabel: compactPromptString(target.commandLabel, 180) }
+                            : {}),
+                        ...(typeof target.file === "string"
+                            ? { file: target.file }
+                            : {}),
+                        requirementIds: relatedRequirementIds,
+                        uiStates: planFactStringList(target.uiStates),
+                    },
+                ];
+            })
+            : [];
+    const compactTargetSurface = Array.isArray(payload.targetSurface)
+        ? payload.targetSurface.flatMap((value) => {
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                return [];
+            const surface = value;
+            return [
+                {
+                    ...(compactPromptString(surface.completeness, 32)
+                        ? { completeness: compactPromptString(surface.completeness, 32) }
+                        : {}),
+                    ...(compactPromptString(surface.entrypoint, 180)
+                        ? { entrypoint: compactPromptString(surface.entrypoint, 180) }
+                        : {}),
+                    ...(compactPromptString(surface.routeOrMount, 180)
+                        ? { routeOrMount: compactPromptString(surface.routeOrMount, 180) }
+                        : {}),
+                    implementationPaths: compactPromptStringArray(surface.implementationPaths),
+                    proposedPaths: compactPromptStringArray(surface.proposedPaths),
+                    testPaths: compactPromptStringArray(surface.testPaths),
+                    ...(compactPromptString(surface.dataSource, 180)
+                        ? { dataSource: compactPromptString(surface.dataSource, 180) }
+                        : {}),
+                    allowedPathConflicts: compactPromptStringArray(surface.allowedPathConflicts),
+                    unresolvedPaths: compactPromptStringArray(surface.unresolvedPaths),
+                },
+            ];
+        })
+        : [];
+    const compactDesignEvidence = options.includeDesignEvidence === true &&
+        Array.isArray(payload.designEvidence)
+        ? payload.designEvidence.flatMap((value) => {
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                return [];
+            const evidence = value;
+            return [{
+                    ...(compactPromptString(evidence.source, 180)
+                        ? { source: compactPromptString(evidence.source, 180) }
+                        : {}),
+                    paths: compactPromptStringArray(evidence.paths, 12, 180),
+                    conflicts: compactPromptStringArray(evidence.conflicts, 24, 180),
+                }];
+        })
+        : [];
+    const compactDeclaredUiStates = Array.isArray(payload.declaredUiStates)
+        ? payload.declaredUiStates.flatMap((value) => {
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                return [];
+            const state = value;
+            const id = typeof state.id === "string" ? state.id : undefined;
+            if (!id)
+                return [];
+            return [{
+                    id,
+                    ...(compactPromptString(state.trigger, 180)
+                        ? { trigger: compactPromptString(state.trigger, 180) }
+                        : {}),
+                    ...(compactPromptString(state.observableOutcome, 240)
+                        ? { observableOutcome: compactPromptString(state.observableOutcome, 240) }
+                        : {}),
+                }];
+        })
+        : [];
+    const committedUx = payload.committedUx &&
+        typeof payload.committedUx === "object" &&
+        !Array.isArray(payload.committedUx)
+        ? payload.committedUx
+        : undefined;
+    const compactPayload = {
+        inputManifest: { ...projectFrontendInputScope({ ...payload, requirements: [...requirementsById.values()] }, slice).inputManifest, semantics: options.includeRequirementText === false ? "navigation-only" : "full" },
+        constraints: payload.constraints,
+        executionGroups: Array.isArray(payload.executionGroups) ? payload.executionGroups.filter(g => isRecordObject(g) && Array.isArray(g.requirementIds) && g.requirementIds.some(id => slice.includes(String(id)))) : [],
+        requirements: compactRequirements,
+        requiredDeliverables: Array.isArray(payload.requiredDeliverables) ? payload.requiredDeliverables : [],
+        ...(compactTargetSurface.length > 0
+            ? { targetSurface: compactTargetSurface }
+            : {}),
+        ...(compactVerificationTargets.length > 0
+            ? { verificationTargets: compactVerificationTargets }
+            : {}),
+        ...(compactDesignEvidence.length > 0
+            ? { designEvidence: compactDesignEvidence }
+            : {}),
+        ...(compactDeclaredUiStates.length > 0
+            ? { declaredUiStates: compactDeclaredUiStates }
+            : {}),
+        ...(committedUx
+            ? {
+                committedUx: {
+                    uiStateNames: compactPromptStringArray(committedUx.uiStateNames, 40, 100),
+                    interactionNames: compactPromptStringArray(committedUx.interactionNames, 60, 120),
+                },
+            }
+            : {}),
+    };
+    const compactBlock = [
+        "<frontend_plan_input>",
+        `Committed Contract/Scout facts for ONLY the current requirement slice (${slice.join(", ")}); do not infer or record requirements outside this slice.`,
+        JSON.stringify(compactPayload),
+        "Do not read upstream artifacts, task sources, or repository files. If this slice cannot support a decision, record a genuine evidence gap.",
+        "</frontend_plan_input>",
+    ].join("\n");
+    let compactPrompt = basePrompt.replace(planInputPattern, compactBlock);
+    compactPrompt = compactPrompt.replace(/<upstream_context>[\s\S]*?<\/upstream_context>/, "<upstream_context>\n(full upstream prose omitted; use only the slice-specific typed facts above)\n</upstream_context>");
+    compactPrompt = compactPrompt.replace(/Cover each frozen requirement ID exactly once:[^\n]*/, `Cover ONLY the current requirement slice: ${slice.join(", ")}. Record each slice requirement exactly once.`);
+    const checklistPattern = /<plan_review_checklist>([\s\S]*?)<\/plan_review_checklist>/;
+    const checklistMatch = checklistPattern.exec(compactPrompt);
+    if (checklistMatch) {
+        if (options.includeChecklist === false) {
+            compactPrompt = compactPrompt.replace(checklistPattern, "");
+            return compactPrompt;
+        }
+        const checklist = checklistMatch[1]
+            .split(/\r?\n/)
+            .filter((line) => {
+            const requirementLine = /^Requirements requiring behavioural coverage:\s*(.*)$/.exec(line.trim());
+            if (requirementLine) {
+                return false;
+            }
+            const citationId = /^([^\s]+)\s+\+/.exec(line.trim())?.[1];
+            return citationId === undefined || sliceSet.has(citationId);
+        })
+            .concat([`Requirements requiring behavioural coverage: ${slice.join(", ") || "(none)"}`])
+            .join("\n");
+        compactPrompt = compactPrompt.replace(checklistPattern, `<plan_review_checklist>${checklist}</plan_review_checklist>`);
+    }
+    return compactPrompt;
+}
+export function compactFrontendPlanLedgerContext(input) {
+    const slice = new Set(input.requirementIds);
+    const allowed = new Set(input.kinds);
+    const scopedKinds = new Set(input.scopedKinds ?? []);
+    const compactFacts = [];
+    for (const value of input.committedFacts) {
+        const fact = committedFactFromPlanRecord(value);
+        if (!fact || fact.origin !== "plan" || typeof fact.kind !== "string" || !allowed.has(fact.kind))
+            continue;
+        if (scopedKinds.has(fact.kind) && !planFactScopeIntersects(fact, slice)) {
+            continue;
+        }
+        const entry = fact.entry && typeof fact.entry === "object" && !Array.isArray(fact.entry)
+            ? fact.entry
+            : undefined;
+        if (fact.kind === "plan-requirement") {
+            if (!entry || typeof entry.id !== "string" || !slice.has(entry.id))
+                continue;
+            compactFacts.push({
+                kind: fact.kind,
+                entry: {
+                    id: entry.id,
+                    implementationTargets: planFactStringList(entry.implementationTargets).slice(0, 12),
+                    verificationTargetIds: planFactStringList(entry.verificationTargetIds).slice(0, 12),
+                    ...(compactPromptString(entry.expectedOutcome, 240)
+                        ? { expectedOutcome: compactPromptString(entry.expectedOutcome, 240) }
+                        : {}),
+                    ...(entry.evidenceGap && typeof entry.evidenceGap === "object"
+                        ? { evidenceGap: entry.evidenceGap }
+                        : {}),
+                },
+            });
+            continue;
+        }
+        if (fact.kind === "plan-verification-target") {
+            if (!entry)
+                continue;
+            // Scope against the complete canonical binding before compacting.
+            // A shared target may bind a late requirement beyond the preview cap.
+            const requirementIds = planFactStringList(entry.requirementIds).filter((id) => slice.has(id));
+            if (requirementIds.length === 0)
+                continue;
+            compactFacts.push({
+                kind: fact.kind,
+                entry: {
+                    id: entry.id,
+                    commandId: entry.commandId,
+                    file: entry.file,
+                    requirementIds,
+                    uiStates: planFactStringList(entry.uiStates).slice(0, 12),
+                },
+            });
+            continue;
+        }
+        if (fact.kind === "component-choice") {
+            const choices = Array.isArray(fact.uiComponentChoices)
+                ? fact.uiComponentChoices.flatMap((choice) => {
+                    if (!choice || typeof choice !== "object" || Array.isArray(choice))
+                        return [];
+                    const item = choice;
+                    return [{
+                            purpose: compactPromptString(item.purpose, 120),
+                            component: compactPromptString(item.component, 120),
+                            decision: compactPromptString(item.decision, 40),
+                            covers: compactPromptStringArray(item.covers, 40, 120),
+                            evidencePath: compactPromptString(item.evidencePath, 180),
+                        }];
+                })
+                : [];
+            if (choices.length > 0)
+                compactFacts.push({ kind: fact.kind, uiComponentChoices: choices });
+            continue;
+        }
+        if (fact.kind === "state-registry") {
+            compactFacts.push({
+                kind: fact.kind,
+                uiStateNames: planFactStringList(fact.uiStateNames).slice(0, 40),
+                interactionNames: planFactStringList(fact.interactionNames).slice(0, 60),
+            });
+            continue;
+        }
+        if (fact.kind === "state-flow") {
+            compactFacts.push({
+                kind: fact.kind,
+                uiStates: Array.isArray(fact.uiStates) ? fact.uiStates : [],
+                interactions: Array.isArray(fact.interactions) ? fact.interactions : [],
+                removeUiStateNames: compactPromptStringArray(fact.removeUiStateNames, 24, 100),
+                removeInteractionNames: compactPromptStringArray(fact.removeInteractionNames, 24, 100),
+            });
+            continue;
+        }
+        if (fact.kind === "data-flow") {
+            compactFacts.push({
+                kind: fact.kind,
+                interactions: compactPromptStringArray(fact.interactions, 32, 120),
+                endpoints: compactPromptStringArray(fact.endpoints, 32, 180),
+            });
+            continue;
+        }
+        if (fact.kind === "mock-api") {
+            const mockApi = fact.mockApi && typeof fact.mockApi === "object" && !Array.isArray(fact.mockApi)
+                ? fact.mockApi
+                : {};
+            compactFacts.push({
+                kind: fact.kind,
+                mockApi: {
+                    strategy: compactPromptString(mockApi.strategy, 40),
+                    activation: compactPromptString(mockApi.activation, 180),
+                    endpoints: Array.isArray(mockApi.endpoints) ? mockApi.endpoints : [],
+                },
+            });
+            continue;
+        }
+        if (fact.kind === "design-deviation") {
+            compactFacts.push({ kind: fact.kind, conflicts: compactPromptStringArray(fact.conflicts, 32, 180) });
+            continue;
+        }
+        if (fact.kind === "dependency") {
+            compactFacts.push({ kind: fact.kind, policy: compactPromptString(fact.policy, 300) });
+            continue;
+        }
+        if (fact.kind === "target-surface") {
+            compactFacts.push({ kind: fact.kind, routes: compactPromptStringArray(fact.routes, 24, 180), implementationPaths: compactPromptStringArray(fact.implementationPaths, 24, 180), proposedPaths: compactPromptStringArray(fact.proposedPaths, 24, 180), testPaths: compactPromptStringArray(fact.testPaths, 24, 180) });
+        }
+    }
+    if (compactFacts.length === 0)
+        return "";
+    const priorityFacts = compactFacts.filter((fact) => fact.kind === "plan-requirement" || fact.kind === "plan-verification-target");
+    const otherFacts = compactFacts.filter((fact) => fact.kind !== "plan-requirement" && fact.kind !== "plan-verification-target");
+    let previewBytes = 0;
+    const boundedFacts = [
+        ...priorityFacts.slice(0, 64),
+        ...otherFacts.slice(-32),
+    ].slice(0, 96).filter(fact => {
+        const bytes = Buffer.byteLength(JSON.stringify(fact));
+        if (previewBytes + bytes > 24_000)
+            return false;
+        previewBytes += bytes;
+        return true;
+    });
+    return [
+        "<frontend_plan_ledger>",
+        "Preview of committed plan facts; not a replacement payload. Fields and lists may be omitted or shortened. Use read_plan_facts with kind, entryId/eventId and optional field to retrieve complete values in bounded pages before corrections; preserve all other bindings. Absence from this preview is not absence from the ledger.",
+        JSON.stringify({ complete: false, matchingFacts: compactFacts.length, omittedFacts: compactFacts.length - boundedFacts.length }),
+        JSON.stringify(boundedFacts),
+        "</frontend_plan_ledger>",
+    ].join("\n");
+}