@opengsd/gsd-core 1.9.1 → 1.10.0

package/gsd-core/bin/lib/plan-dependency-graph.cjs

@@ -0,0 +1,232 @@
+"use strict";
+/**
+ * Plan Dependency Graph — shared halt-propagation over a plan's depends_on DAG (#2830).
+ *
+ * Two independent "which plans are incomplete" readers exist in this codebase:
+ * phase.cts's wave-grouping (`cmdPhasePlanIndex`) and phase-locator.cts's
+ * phase-location primitive (`searchPhaseInDir`, consumed by ~50 symbols across
+ * five command routers). Before #2830, only the former parsed `depends_on` —
+ * and even it used the DAG only for topological wave assignment, never to
+ * propagate a halted plan's block onto its dependents. The latter never parsed
+ * `depends_on` at all; it derived completion from summary-file presence only.
+ * A plan that reaches a designed stop still writes a SUMMARY (recording the
+ * halt in prose only — no prior structured status existed for it), so both
+ * readers saw it as ordinary "complete" and reported its dependents as
+ * ordinary incomplete work, available to spawn against.
+ *
+ * This module is the SINGLE topological-order + halt-propagation engine both
+ * readers call, so the two can never re-diverge on this rule again. Each
+ * caller resolves its own raw `depends_on` tokens to canonical plan ids
+ * (case-fold + `extractCanonicalPlanId` fallback — the same resolution
+ * already performed by phase.cts's `computeDependencyLevels`) before
+ * building `PlanHaltNode[]`; this module owns the graph traversal (exactly
+ * one pass — Kahn's algorithm, or none at all when the caller already has a
+ * valid topological order, see `computeHaltPropagation`'s `precomputedOrder`
+ * parameter) plus the two small pure helpers below (`isHaltedStatus`,
+ * `buildSummaryFileIndex`) that both callers would otherwise duplicate
+ * identically — the exact "two implementations, one drifts" failure mode
+ * this fix exists to close. Each caller still owns its own file I/O (the
+ * actual `fs.readFileSync` + `extractFrontmatter` calls); only the
+ * interpretive logic is centralized here — except the SUMMARY-file
+ * read+extract wrapper itself (`isSummaryFileHalted`), which both callers
+ * previously duplicated near-identically and which is now centralized here
+ * too, for the same reason.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const node_fs_1 = __importDefault(require("node:fs"));
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- frontmatter.cjs is an export= CommonJS module
+const frontmatterMod = require("./frontmatter.cjs");
+const { extractFrontmatter } = frontmatterMod;
+/**
+ * The one place "does this SUMMARY status value mean halted" is decided.
+ * Case-insensitive, trims whitespace. Both `phase.cts`'s `cmdPhasePlanIndex`
+ * and `phase-locator.cts`'s `searchPhaseInDir` call this after reading a
+ * completed plan's SUMMARY frontmatter `status` field, so the definition of
+ * "halted" cannot drift between the two readers.
+ */
+function isHaltedStatus(status) {
+    if (typeof status !== 'string')
+        return false;
+    // #2830 review (defect 2): strip an unquoted trailing YAML comment (a run
+    // of whitespace followed by `#` and the rest of the line) before
+    // trimming/lowercasing. YAML scalars don't need quoting to carry an inline
+    // comment (`status: halted # designed stop`), but `extractFrontmatter`
+    // does not strip one — and all four summary templates literally show that
+    // spelling as guidance on the value line. Without this, an executor that
+    // mimics the template's own presentation would write a halt that silently
+    // reads back as not-halted. A `#` with no preceding whitespace is NOT a
+    // YAML comment start, so `halted#nospace` intentionally still fails to match.
+    const withoutTrailingComment = status.replace(/\s+#.*$/, '');
+    return withoutTrailingComment.trim().toLowerCase() === 'halted';
+}
+/**
+ * Read a plan's SUMMARY file and report whether it declares `status: halted`
+ * (a designed stop, not an ordinary completion). Returns false — never
+ * throws — on a missing/unreadable/malformed SUMMARY, so an unreadable file
+ * degrades to the pre-#2830 behavior ("has a SUMMARY = complete") rather
+ * than breaking either caller.
+ *
+ * Two callers share this wrapper: `phase.cts`'s `cmdPhasePlanIndex` and
+ * `phase-locator.cts`'s `searchPhaseInDir` (the phase-location primitive
+ * consumed by ~50 symbols across five command routers). Both previously
+ * carried a near-identical local copy (read file -> `extractFrontmatter` ->
+ * `isHaltedStatus` -> swallow errors) that this module's own header comment
+ * calls out as the exact "two implementations, one drifts" failure mode it
+ * exists to prevent — centralizing the read+extract wrapper here, not just
+ * the `isHaltedStatus` predicate, closes that gap.
+ *
+ * Takes a single resolved `summaryPath` (not a `dir` + `filename` pair) —
+ * `phase-locator.cts`'s prior local copy took the two parts separately and
+ * `path.join`'d them internally; that caller now does the join itself
+ * before calling in, so both callers share one signature.
+ *
+ * @param summaryPath - absolute or relative path to a `*-SUMMARY.md` file.
+ */
+function isSummaryFileHalted(summaryPath) {
+    try {
+        const content = node_fs_1.default.readFileSync(summaryPath, 'utf-8');
+        const fm = extractFrontmatter(content, summaryPath);
+        return isHaltedStatus(fm['status']);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Build a planId -> summary-filename lookup from a phase's summary file
+ * list, keyed by both the exact SUMMARY-file-derived id and its canonical
+ * form (mirrors the `completedPlanIds` construction each caller already
+ * performs for its own SUMMARY-presence check — same `summaryFiles` list,
+ * same exact/canonical key pair — so the two can never disagree about which
+ * summary file belongs to which plan id). `extractCanonicalPlanId` is
+ * supplied by the caller (each module owns its own resolution helper).
+ */
+function buildSummaryFileIndex(summaryFiles, extractCanonicalPlanId) {
+    const index = new Map();
+    for (const s of summaryFiles) {
+        const exact = s.replace('-SUMMARY.md', '').replace('SUMMARY.md', '');
+        const canonical = extractCanonicalPlanId(s);
+        index.set(exact, s);
+        if (canonical !== exact)
+            index.set(canonical, s);
+    }
+    return index;
+}
+/**
+ * Computes halt-propagation over a plan dependency DAG.
+ *
+ * `precomputedOrder`: when the caller ALREADY has a valid topological order
+ * for these exact node ids (e.g. phase.cts's `cmdPhasePlanIndex`, which runs
+ * `computeDependencyLevels`'s Kahn's-algorithm pass for wave assignment
+ * before ever calling this function), pass it here and this function skips
+ * running Kahn's algorithm a second time — the halt-propagation forward pass
+ * below only needs A valid topological order, not to derive one itself.
+ * Omit it (as phase-locator.cts's `searchPhaseInDir` does — it has no prior
+ * traversal of this DAG) and this function derives the order itself; either
+ * way, exactly one Kahn's-algorithm pass runs per caller, never two.
+ *
+ * Diamond-safe (a plan blocked via two different halted ancestors gets both
+ * in its `blockedBy` list, deduplicated) and transitive-safe (a dependent of
+ * a dependent of a halted plan is blocked, at any depth).
+ */
+function computeHaltPropagation(nodes, precomputedOrder) {
+    const byId = new Map(nodes.map((n) => [n.id, n]));
+    let order;
+    let visited;
+    if (precomputedOrder) {
+        // Caller already ran Kahn's algorithm over this exact node set (same ids)
+        // — trust its order and skip re-deriving one. `visited` mirrors the same
+        // "count of nodes reachable in valid topological order" contract a fresh
+        // derivation would produce.
+        order = precomputedOrder;
+        visited = precomputedOrder.length;
+    }
+    else {
+        const inDeg = new Map();
+        const adj = new Map(); // dependency id -> dependent ids
+        for (const n of nodes) {
+            if (!inDeg.has(n.id))
+                inDeg.set(n.id, 0);
+            if (!adj.has(n.id))
+                adj.set(n.id, []);
+            for (const depId of n.resolvedDependsOn) {
+                if (!byId.has(depId))
+                    continue; // fail-safe: caller should have filtered these already
+                if (!adj.has(depId))
+                    adj.set(depId, []);
+                adj.get(depId).push(n.id);
+                inDeg.set(n.id, (inDeg.get(n.id) ?? 0) + 1);
+            }
+        }
+        const queue = [];
+        for (const n of nodes) {
+            if ((inDeg.get(n.id) ?? 0) === 0)
+                queue.push(n.id);
+        }
+        // Dequeue by head index, not Array.shift() — O(1) amortized, same
+        // rationale as computeDependencyLevels (#307).
+        let head = 0;
+        let v = 0;
+        while (head < queue.length) {
+            const cur = queue[head++];
+            v++;
+            for (const dep of adj.get(cur) ?? []) {
+                inDeg.set(dep, inDeg.get(dep) - 1);
+                if (inDeg.get(dep) === 0)
+                    queue.push(dep);
+            }
+        }
+        order = queue;
+        visited = v;
+    }
+    // `order` is a valid topological order for every visited node: for edge
+    // dep -> dependent, dep appears before dependent. A single forward pass
+    // over it — using each node's own already-resolved dependsOn ids —
+    // computes blockedBy without any further graph traversal.
+    const blockedBy = new Map();
+    for (const id of order) {
+        const node = byId.get(id);
+        if (!node)
+            continue;
+        const causes = new Set();
+        for (const depId of node.resolvedDependsOn) {
+            const depNode = byId.get(depId);
+            if (!depNode)
+                continue;
+            if (depNode.halted)
+                causes.add(depId);
+            const depCauses = blockedBy.get(depId);
+            if (depCauses) {
+                for (const c of depCauses)
+                    causes.add(c);
+            }
+        }
+        if (causes.size > 0)
+            blockedBy.set(id, Array.from(causes));
+    }
+    // #2830 review (defect 1): a node involved in a depends_on cycle (or
+    // downstream of one) never reaches indegree 0, so it never appears in
+    // `order` and the forward pass above never visits it — it would otherwise
+    // end up absent from BOTH `blockedBy` and any cycle diagnostic, i.e.
+    // reported as ordinary runnable. A node whose position in the topological
+    // order is undecidable cannot be shown to be safe to run: silently
+    // dropping it is the exact silent-disappearance failure #2830 exists to
+    // prevent. Fail closed — give every such non-halted node an explicit,
+    // non-empty `blockedBy` entry so no consumer (present or future) can
+    // re-admit it as runnable merely by checking "absent from blockedBy".
+    // (A node that is itself halted is not "blocked" — it IS the blocker —
+    // so it is left out here exactly as the normal forward pass leaves it out.)
+    if (order.length < nodes.length) {
+        const orderSet = new Set(order);
+        for (const n of nodes) {
+            if (orderSet.has(n.id) || n.halted)
+                continue;
+            const causes = Array.from(new Set(n.resolvedDependsOn.filter((depId) => byId.has(depId)))).sort();
+            blockedBy.set(n.id, causes.length > 0 ? causes : [n.id]);
+        }
+    }
+    return { order, visited, blockedBy };
+}
+module.exports = { computeHaltPropagation, isHaltedStatus, buildSummaryFileIndex, isSummaryFileHalted };

package/gsd-core/bin/lib/planning-workspace.cjs

@@ -146,6 +146,10 @@ function planningPaths(cwd, ws) {
         config: node_path_1.default.join(base, 'config.json'),
         phases: node_path_1.default.join(base, 'phases'),
         requirements: node_path_1.default.join(base, 'REQUIREMENTS.md'),
+        // #3149: the debug-session directory. Single source for both `state.load`'s
+        // `debug_dir` field and `init.debug`'s — previously each composed its own
+        // `path.join(planning, 'debug')` (DEFECT.GENERATIVE-FIX).
+        debug: node_path_1.default.join(base, 'debug'),
     };
 }
 /**

package/gsd-core/bin/lib/prompt-budget.cjs

@@ -10,7 +10,12 @@
  *
  * Used by the review pipeline to support small-context models.
  *
- * Trim priority (in order — never violate):
+ * Trim priority (in order — never violate). As of #2929 (epic #1671 Phase 2)
+ * the ladder itself is executed by the shared `context-composer` seam
+ * (`composeWithinBudget`); this module builds the fragment list in this
+ * exact order, delegates the decision of what survives/shrinks/truncates,
+ * and keeps only the prompt-specific rendering (`renderNote`,
+ * `assemblePrompt`) and the hard-fail response shapes here:
  *   1. Instructions:   ALWAYS kept verbatim
  *   2. Reserve note tokens FIRST when any trim is anticipated
  *   3. Roadmap:        ALWAYS kept verbatim
@@ -22,9 +27,20 @@
  *   9. Hard-fail:      if minimum-set exceeds effectiveBudget
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLAN_FLOOR_CHARS = void 0;
 exports.estimateTokens = estimateTokens;
+exports.buildBudgetFragments = buildBudgetFragments;
 exports.applyBudget = applyBudget;
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- context-composer.cjs is an export= CommonJS module
+const contextComposer = require("./context-composer.cjs");
 const NOTE_RESERVE_TOKENS = 80;
+/**
+ * Floor per plan when proportionally truncating and for the minimum-set
+ * check. Exported so consumers (notably the load-bearing contract gate,
+ * issue #3065) never need to re-declare this value locally.
+ */
+exports.PLAN_FLOOR_CHARS = 1024;
+const MIN_PLAN_BYTES = exports.PLAN_FLOOR_CHARS;
 const DEFAULT_NOTE_TEMPLATE = [
     '<note>',
     'Prompt automatically trimmed to fit a {budget}-token budget.',
@@ -51,30 +67,6 @@ function renderNote(template, budget, omitted, planTruncationPct) {
         .replace('{omittedList}', omittedList)
         .replace('{planTruncationPct}', String(Math.round(planTruncationPct)));
 }
-/**
- * Head-shrink a string to at most `maxLines` lines.
- */
-function headShrink(text, maxLines) {
-    if (maxLines <= 0)
-        return '';
-    let idx = -1;
-    let seen = 0;
-    while (seen < maxLines) {
-        idx = text.indexOf('\n', idx + 1);
-        if (idx === -1)
-            return text;
-        seen += 1;
-    }
-    return text.slice(0, idx);
-}
-/**
- * Tail-truncate a string to at most `maxChars` characters.
- */
-function tailTruncate(text, maxChars) {
-    if (text.length <= maxChars)
-        return text;
-    return text.slice(0, maxChars);
-}
 /**
  * Assemble the final prompt string from its sections.
  */
@@ -99,38 +91,92 @@ function assemblePrompt(parts) {
         blocks.push('## Requirements\n\n' + requirements);
     return blocks.join('\n\n');
 }
+/**
+ * Build the `composeWithinBudget` fragment array for a set of review prompt
+ * sections, with each fragment's declared trim strategy attached.
+ *
+ * Extracted (issue #3065) so the load-bearing contract gate
+ * (tests/load-bearing-contract-gate.test.cjs) can assert directly over the
+ * REAL declared strategies used by `applyBudget`, rather than a hand-copied
+ * duplicate array. A duplicate would let production silently diverge from
+ * the gate (e.g. flipping `roadmap` from `verbatim` to `drop` would keep the
+ * gate green if it read from a copy) — exactly the
+ * `DEFECT.GENERATIVE-FIX` divergence class this extraction exists to
+ * prevent. Pure; performs no I/O and has no side effects.
+ */
+function buildBudgetFragments(sections, projectMdHeadLines) {
+    const { instructions, roadmap, plans, projectMd: projectMdRaw = null, context: contextRaw = null, research: researchRaw = null, requirements: requirementsRaw = null, } = sections;
+    // Unique per-plan fragment ids: plain `plan:<file>` unless a filename
+    // collision forces disambiguation by index — composeWithinBudget throws on
+    // duplicate ids, and legitimate input may repeat a filename across plans.
+    const usedPlanIds = new Set();
+    const planIds = plans.map((p, idx) => {
+        let id = `plan:${p.file}`;
+        if (usedPlanIds.has(id))
+            id = `plan:${idx}:${p.file}`;
+        usedPlanIds.add(id);
+        return id;
+    });
+    const planFragments = plans.map((p, idx) => ({
+        id: planIds[idx],
+        content: p.content,
+        wrapper: `### ${p.file}\n\n`,
+        strategy: { kind: 'proportional-truncate', floorChars: MIN_PLAN_BYTES },
+        group: 'plans',
+        required: true,
+    }));
+    return [
+        { id: 'instructions', content: instructions, wrapper: '', strategy: { kind: 'verbatim' }, required: true },
+        { id: 'roadmap', content: roadmap, wrapper: '## Roadmap\n\n', strategy: { kind: 'verbatim' }, required: true },
+        {
+            id: 'projectMd',
+            content: projectMdRaw ?? '',
+            wrapper: '## Project\n\n',
+            strategy: { kind: 'head-shrink', maxLines: projectMdHeadLines },
+        },
+        { id: 'plans-header', content: '', wrapper: '## Plans\n\n', strategy: { kind: 'verbatim' }, required: true },
+        ...planFragments,
+        { id: 'context', content: contextRaw ?? '', wrapper: '## Context\n\n', strategy: { kind: 'drop' } },
+        { id: 'research', content: researchRaw ?? '', wrapper: '## Research\n\n', strategy: { kind: 'drop' } },
+        { id: 'requirements', content: requirementsRaw ?? '', wrapper: '## Requirements\n\n', strategy: { kind: 'drop' } },
+    ];
+}
 /**
  * Apply a token budget to a set of review prompt sections.
  * Returns the trimmed prompt and structured metadata.
  */
 function applyBudget({ sections, budget, options = {} }) {
     const { safetyMarginPct = 10, noteTemplate = DEFAULT_NOTE_TEMPLATE, projectMdHeadLines = 40, } = options;
-    const effectiveBudget = Math.floor(budget * (1 - safetyMarginPct / 100));
-    const { instructions, roadmap, plans, projectMd: projectMdRaw = null, context: contextRaw = null, research: researchRaw = null, requirements: requirementsRaw = null, } = sections;
-    // Working mutable state
-    let projectMd = projectMdRaw;
-    let context = contextRaw;
-    let research = researchRaw;
-    let requirements = requirementsRaw;
-    let workingPlans = plans.map((p) => ({ file: p.file, content: p.content }));
-    const omitted = [];
-    let projectMdShrunk = false;
-    let planTruncationPct = 0;
-    let noteInjected = false;
-    let hardFailed = false;
-    // Minimum-set check: instructions + roadmap + 1KB per plan.
-    // NOTE_RESERVE_TOKENS is intentionally excluded here: a note is only injected
-    // when trimming actually occurs, and a prompt that fits without any trim needs
-    // no note at all. Including NOTE_RESERVE_TOKENS here would cause false hard-fails
-    // for prompts that genuinely fit the effective budget untrimmed.
-    const MIN_PLAN_BYTES = 1024;
-    const minPlanTokens = plans.reduce((sum, p) => {
-        return sum + estimateTokens(p.content.slice(0, MIN_PLAN_BYTES));
-    }, 0);
-    const minSet = estimateTokens(instructions) +
-        estimateTokens(roadmap) +
-        minPlanTokens;
-    if (minSet > effectiveBudget) {
+    const { plans } = sections;
+    const fragments = buildBudgetFragments(sections, projectMdHeadLines);
+    // Recover the per-plan fragment ids buildBudgetFragments assigned (in
+    // `plans` declaration order) rather than re-deriving the id-collision
+    // logic here — a single source of truth for id assignment.
+    const planIds = fragments.filter((f) => f.group === 'plans').map((f) => f.id);
+    const composed = contextComposer.composeWithinBudget({
+        fragments,
+        budget,
+        measure: estimateTokens,
+        options: {
+            safetyMarginPct,
+            reserve: NOTE_RESERVE_TOKENS,
+            charsPerUnit: 4,
+            // Minimum-set floor: instructions + roadmap (in full) + 1KB per plan.
+            // NOTE_RESERVE_TOKENS is intentionally excluded — a note is only
+            // injected when trimming actually occurs, and a prompt that fits
+            // without any trim needs no note at all. Wrappers are also excluded
+            // (this checks the floor, not the steady-state budget).
+            minimumFor: (f) => {
+                if (f.id === 'instructions' || f.id === 'roadmap')
+                    return f.content;
+                if (f.id.startsWith('plan:'))
+                    return f.content.slice(0, MIN_PLAN_BYTES);
+                return null;
+            },
+        },
+    });
+    const effectiveBudget = composed.metadata.effectiveBudget;
+    if (composed.metadata.hardFailed) {
         return {
             prompt: '',
             metadata: {
@@ -145,127 +191,45 @@ function applyBudget({ sections, budget, options = {} }) {
             },
         };
     }
-    // ── Budget accounting ──────────────────────────────────────────────────────
-    const TOKENS_ROADMAP_HEADER = estimateTokens('## Roadmap\n\n');
-    const TOKENS_PROJECT_HEADER = estimateTokens('## Project\n\n');
-    const TOKENS_PLANS_HEADER = estimateTokens('## Plans\n\n');
-    const TOKENS_CONTEXT_HEADER = estimateTokens('## Context\n\n');
-    const TOKENS_RESEARCH_HEADER = estimateTokens('## Research\n\n');
-    const TOKENS_REQUIREMENTS_HEADER = estimateTokens('## Requirements\n\n');
-    const TOKENS_PLAN_ITEM_HEADERS = workingPlans.reduce((sum, p) => sum + estimateTokens('### ' + p.file + '\n\n'), 0);
-    const staticBaseTokens = estimateTokens(instructions) +
-        TOKENS_ROADMAP_HEADER +
-        estimateTokens(roadmap) +
-        TOKENS_PLANS_HEADER +
-        TOKENS_PLAN_ITEM_HEADERS;
-    let projectTokens = projectMd
-        ? TOKENS_PROJECT_HEADER + estimateTokens(projectMd)
-        : 0;
-    let contextTokens = context
-        ? TOKENS_CONTEXT_HEADER + estimateTokens(context)
-        : 0;
-    let researchTokens = research
-        ? TOKENS_RESEARCH_HEADER + estimateTokens(research)
-        : 0;
-    let requirementsTokens = requirements
-        ? TOKENS_REQUIREMENTS_HEADER + estimateTokens(requirements)
-        : 0;
-    let planContentTokens = workingPlans.reduce((sum, p) => sum + estimateTokens(p.content), 0);
-    const getCurrentBaseTokens = () => staticBaseTokens +
-        projectTokens +
-        planContentTokens +
-        contextTokens +
-        researchTokens +
-        requirementsTokens;
-    let currentBaseTokens = getCurrentBaseTokens();
-    // Detect budget pressure: is ANY trim needed?
-    // Pressure exists when the current base tokens already exceed the effective
-    // budget. Only when pressure is real do we reserve NOTE_RESERVE_TOKENS so
-    // the note itself fits after trimming. Checking against
-    // effectiveBudget - NOTE_RESERVE_TOKENS (the old threshold) would cause
-    // spurious pressure 80 tokens early, dropping sections that fit fine.
-    const baseTokens = currentBaseTokens;
-    const budgetUnderPressure = baseTokens > effectiveBudget;
-    // Available for content (reserve note slot when under pressure)
-    const contentBudget = budgetUnderPressure
-        ? effectiveBudget - NOTE_RESERVE_TOKENS
-        : effectiveBudget;
-    // ── Trim step 1: head-shrink PROJECT.md ───────────────────────────────────
-    if (currentBaseTokens > contentBudget && projectMd) {
-        const shrunk = headShrink(projectMd, projectMdHeadLines);
-        if (shrunk !== projectMd) {
-            projectMd = shrunk;
-            projectMdShrunk = true;
-            projectTokens = TOKENS_PROJECT_HEADER + estimateTokens(projectMd);
-            currentBaseTokens = getCurrentBaseTokens();
-        }
-    }
-    // ── Trim step 2: proportional plan truncation ─────────────────────────────
-    if (currentBaseTokens > contentBudget) {
-        // Compute tokens available for plan content only
-        const overhead = staticBaseTokens +
-            projectTokens +
-            contextTokens +
-            researchTokens +
-            requirementsTokens;
-        const planBudgetTokens = contentBudget - overhead;
-        const totalPlanTokens = planContentTokens;
-        if (planBudgetTokens > 0 && planBudgetTokens < totalPlanTokens) {
-            // Proportional share per plan (at least 1KB per plan)
-            const totalOriginalChars = plans.reduce((sum, p) => sum + p.content.length, 0);
-            const totalPlanCharsBudget = planBudgetTokens * 4;
-            workingPlans = workingPlans.map((p) => {
-                const proportionalShare = totalOriginalChars > 0
-                    ? Math.floor((p.content.length / totalOriginalChars) * totalPlanCharsBudget)
-                    : 0;
-                const maxChars = Math.max(proportionalShare, MIN_PLAN_BYTES);
-                return { file: p.file, content: tailTruncate(p.content, maxChars) };
-            });
-            const newTotalChars = workingPlans.reduce((sum, p) => sum + p.content.length, 0);
-            if (totalOriginalChars > 0) {
-                planTruncationPct =
-                    ((totalOriginalChars - newTotalChars) / totalOriginalChars) * 100;
-            }
-            planContentTokens = workingPlans.reduce((sum, p) => sum + estimateTokens(p.content), 0);
-            currentBaseTokens = getCurrentBaseTokens();
-        }
-    }
-    // ── Trim step 3: drop context ─────────────────────────────────────────────
-    if (currentBaseTokens > contentBudget && context) {
-        context = null;
-        omitted.push('context');
-        contextTokens = 0;
-        currentBaseTokens = getCurrentBaseTokens();
-    }
-    // ── Trim step 4: drop research ────────────────────────────────────────────
-    if (currentBaseTokens > contentBudget && research) {
-        research = null;
-        omitted.push('research');
-        researchTokens = 0;
-        currentBaseTokens = getCurrentBaseTokens();
-    }
-    // ── Trim step 5: drop requirements (last resort) ──────────────────────────
-    if (currentBaseTokens > contentBudget && requirements) {
-        requirements = null;
-        omitted.push('requirements');
-        requirementsTokens = 0;
-        currentBaseTokens = getCurrentBaseTokens();
-    }
+    const byId = new Map(composed.fragments.map((f) => [f.id, f]));
+    const get = (id) => {
+        const found = byId.get(id);
+        if (!found)
+            throw new Error(`applyBudget: missing composed fragment "${id}"`);
+        return found;
+    };
+    const instructionsOut = get('instructions').content;
+    const roadmapOut = get('roadmap').content;
+    const projectMdFragment = get('projectMd');
+    const projectMd = projectMdFragment.present ? projectMdFragment.content : null;
+    const contextFragment = get('context');
+    const context = contextFragment.present ? contextFragment.content : null;
+    const researchFragment = get('research');
+    const research = researchFragment.present ? researchFragment.content : null;
+    const requirementsFragment = get('requirements');
+    const requirements = requirementsFragment.present ? requirementsFragment.content : null;
+    // Plans are never dropped — only their content may be truncated — so map
+    // deliberately by original index/file rather than relying on `present`.
+    const workingPlans = plans.map((p, idx) => ({
+        file: p.file,
+        content: get(planIds[idx]).content,
+    }));
+    const omitted = composed.metadata.omitted;
+    const projectMdShrunk = composed.metadata.shrunk.includes('projectMd');
+    const planTruncationPct = composed.metadata.truncationPct;
     // ── Decide whether note is actually needed ────────────────────────────────
     const anyTrimOccurred = omitted.length > 0 || projectMdShrunk || planTruncationPct > 0;
     let note = null;
+    let noteInjected = false;
     if (anyTrimOccurred) {
         note = renderNote(noteTemplate, budget, omitted, planTruncationPct);
         noteInjected = true;
     }
-    // Suppress unused variable warning — currentBaseTokens is used via the
-    // closure in getCurrentBaseTokens(); the final value is not used directly.
-    void currentBaseTokens;
     // ── Assemble ──────────────────────────────────────────────────────────────
     const prompt = assemblePrompt({
-        instructions,
+        instructions: instructionsOut,
         note,
-        roadmap,
+        roadmap: roadmapOut,
         projectMd,
         plans: workingPlans,
         context,
@@ -274,7 +238,6 @@ function applyBudget({ sections, budget, options = {} }) {
     });
     const estimatedTokens = estimateTokens(prompt);
     if (estimatedTokens > effectiveBudget) {
-        hardFailed = true;
         return {
             prompt: '',
             metadata: {
@@ -284,7 +247,7 @@ function applyBudget({ sections, budget, options = {} }) {
                 omitted,
                 projectMdShrunk,
                 planTruncationPct,
-                hardFailed,
+                hardFailed: true,
                 noteInjected,
             },
         };
@@ -298,7 +261,7 @@ function applyBudget({ sections, budget, options = {} }) {
             omitted,
             projectMdShrunk,
             planTruncationPct,
-            hardFailed,
+            hardFailed: false,
             noteInjected,
         },
     };