@cspeach/cli 1.1.51 → 1.1.53

package/dist/commands/plan-resume.js

@@ -45,6 +45,7 @@ import { resolveAtTokenAsync, formatProjectFileList, ensureWorkspace } from '../
 import { parsePlanContent, phaseWrites } from '../projects/plan-schema.js';
 import { statusesFromItems, computeNextPhase, computeNextPhaseForRun, pendingAuditPhaseIds, renderPlanTracker, renderPlanProgressLine, buildPlanRevision, isPhaseSatisfied, isAuditResolved, planCompletionLines, findServiceBinding, phaseDisplayTitle, } from '../projects/plan-run.js';
 import { extractPlan, NO_PLAN_MANIFEST_MESSAGE } from '../projects/extract-plan.js';
+import { finishCheckGuard } from './finish-check-guard.js';
 import { recordFullNotice } from '../renderer/notice-log.js';
 import { isSapUnreachableNoted } from '../sap/reachability-state.js';
 import { saveProject } from '../projects/save.js';
@@ -66,6 +67,8 @@ import { isCredentialHandoverApproved } from '../repl/credential-handover-gate.j
 import { FIORI_DEPLOY_HANDOVER_SCOPE } from '../tools/fiori/deploy/scope.js';
 import { resolvePlanSources, renderPlanSourcesBlock } from '../projects/plan-sources.js';
 import { regroundPlan } from './plan-reground.js';
+import { getGrantTransport, isPlanGrantInForceFor } from '../approvals/plan-grant.js';
+import { projectTransport, transportForWrite } from '../register/project-transport.js';
 import { PAUSED_LINE, makeSapProbe, pauseUntilSapReachable, promptLockedChoice, resumeCommandFor } from './plan-sap-pause.js';
 /**
  * Parse and STRIP the per-run chaining-mode (`--guarded` / `--step`) and
@@ -166,6 +169,51 @@ export function buildUiPhaseContext(phases, next) {
     }
     return lines;
 }
+const sameTransport = (a, b) => !!a && !!b && a.trim().toUpperCase() === b.trim().toUpperCase();
+/**
+ * 2026-10-23 (owner-approved fix, review round 1) — the transport a create in
+ * this step would go to, by the write path's own order, so the step prompt can
+ * name it. Never the step's own work.transport ahead of that order.
+ *   - A plan grant of THIS plan is in force: its transport (writes under the
+ *     grant are held to it; a grant whose new transport is not bound yet names
+ *     none).
+ *   - Guarded mode, no grant yet: the grant offered for this step would bind
+ *     the plan's recorded transport, else the session one; if it is not
+ *     installed, writes take transportForWrite's order. Named only when the
+ *     two agree.
+ *   - Otherwise (step mode): transportForWrite for a create: the joined team
+ *     project's request, else the session transport (an explicit /transport).
+ * Resolve-mode writes (set_source, update_method, delete) never fall back to
+ * the session transport, and an object's owning lock still wins over any
+ * transport passed. Pure.
+ */
+export function resolveStepWriteTransport(i) {
+    if (i.grantInstalled)
+        return i.grantTransport?.trim() || undefined;
+    const perWrite = transportForWrite({ op: 'create', project: i.project, session: i.session }).request;
+    if (i.mode !== 'guarded')
+        return perWrite || undefined;
+    const planned = recordedPlanTransport(i.phases) ?? i.session ?? undefined;
+    return sameTransport(planned, perWrite) ? perWrite : undefined;
+}
+/**
+ * The step-prompt line naming the transport. `transport` is passed only when
+ * it is the one the write path uses AND the pre-step SAP check listed it as
+ * open. Returns [] (prompt unchanged) with no transport, for read-only steps
+ * (writes:false), design steps, and UI/CAP steps (local files; a UI deploy
+ * names its own).
+ */
+export function buildStepTransportLine(next, transport) {
+    if (!transport)
+        return [];
+    if (!phaseWrites(next))
+        return [];
+    if (next.delegateTo === 'abap-design')
+        return [];
+    if (next.layer === 'ui' || next.layer.startsWith('cap.'))
+        return [];
+    return [`Transport for this step: ${transport} (already settled: use it, do not ask the developer which transport).`];
+}
 /** Compact-example work keys for ui phases — the write-back contract
  * (review C3). Returns an OBJECT fragment because compactExample renders
  * via JSON.stringify: it is spread into the `work` object exactly like the
@@ -473,7 +521,7 @@ export async function preparePlanResume(args) {
             // C2 (D24): a finished UI-less backend stack chains to /abap-fiori-build
             // with the exact binding name — the marketed idea→app story must not
             // silently end at the service binding.
-            args.log(...planCompletionLines(content.phases));
+            args.log(...planCompletionLines(content.phases, undefined, planBuildTransport(content.phases)));
         }
         else {
             const blocked = content.phases.filter((p) => statuses[p.id] === 'blocked').map((p) => titleOfId(p.id));
@@ -528,17 +576,31 @@ export async function preparePlanResume(args) {
     // what this plan built, what a dead run left inactive (a stale lock is
     // waited out, then reported), and whether the transport is still open.
     let sapStateBlock = [];
+    // 2026-10-23 — the transport this step's writes would use (write-path
+    // order). It is named in the prompt only when the re-check lists it open.
+    // A grant counts only while it is in force (this plan, not expired, approvals
+    // = plan); otherwise writes take the per-write order, and so does the line.
+    const stepWriteTransport = resolveStepWriteTransport({
+        phases: content.phases,
+        mode: effectiveMode,
+        grantInstalled: isPlanGrantInForceFor(envelope.id),
+        grantTransport: getGrantTransport(),
+        project: projectTransport(args.cwd),
+        session: getCurrentTransport(),
+    });
+    let stepTransportOpen = false;
     if (args.reground) {
         const regroundDeps = args.reground;
         const canAsk = args.interactive === true && !!args.prompt;
         const resumeCommand = resumeCommandFor({ path, mode: flags.mode, auditFlag: flags.audit });
         for (;;) {
-            const r = await regroundPlan({ content, statuses, deps: regroundDeps, log: args.log });
+            const r = await regroundPlan({ content, statuses, deps: regroundDeps, log: args.log, ...(stepWriteTransport ? { stepTransport: stepWriteTransport } : {}) });
             if (r.ok) {
                 // An in-run hop stays quiet unless something needs attention.
                 if (!r.quiet || args.boardStyle !== 'line')
                     args.log(formatInfo(r.summary).trimEnd());
                 sapStateBlock = r.sapStateBlock;
+                stepTransportOpen = r.stepTransportOpen === true;
                 break;
             }
             if (r.reason === 'unreachable') {
@@ -562,6 +624,7 @@ export async function preparePlanResume(args) {
                     continue;
                 if (choice === 'continue') {
                     sapStateBlock = r.sapStateBlock;
+                    stepTransportOpen = r.stepTransportOpen === true;
                     break;
                 }
                 args.log(PAUSED_LINE);
@@ -631,6 +694,10 @@ export async function preparePlanResume(args) {
     // '' already ends the prior element). Spread the blank AFTER the block so
     // context keeps single-blank separation on both sides.
     const uiContext = buildUiPhaseContext(content.phases, next);
+    // Named only when it is the transport the write uses, it is listed open, and
+    // it does not contradict the plan's recorded transport in <sap_state>.
+    const recordedTr = recordedPlanTransport(content.phases);
+    const stepTransport = buildStepTransportLine(next, stepTransportOpen && (!recordedTr || sameTransport(recordedTr, stepWriteTransport)) ? stepWriteTransport : undefined);
     // 2026-10-04 (plan sources) — the spec-gap items this phase reads, in full,
     // from the file the plan was made from (or the plan's creation snapshot).
     // A phase must never have to hunt the folder for its gap answers.
@@ -671,6 +738,7 @@ export async function preparePlanResume(args) {
         'Only if the plan itself must change structurally (a phase added, removed, or re-sequenced) fall back to the full shape with "content" — CSPeach accepts both. The manifest block is how the result is persisted; a turn that ends without it LOSES the phase.',
         '',
         ...(uiContext.length ? [...uiContext, ''] : []),
+        ...(stepTransport.length ? [...stepTransport, ''] : []),
         PLAN_RESUME_HARNESS_OVERRIDE,
     ].join('\n');
     return {
@@ -935,6 +1003,12 @@ export async function finishPlanResume(args) {
             return null;
         }
     }
+    // 2026-10-23 — finish-check guard (inline-waiver findings §6 Option A): a
+    // step claimed "validated" while this turn's LAST rap_finish_check is below
+    // 5 of 5 is saved "blocked" (a waiver only when its notes name every failed
+    // item). Downgrade, never refuse. No check this turn, a 5 of 5, an
+    // unreadable result or any other status → saved exactly as written.
+    applyFinishCheckGuard(extract, args);
     const nowIso = new Date().toISOString();
     const statuses = extract.statuses;
     const executedId = args.prepared.nextPhaseId;
@@ -1028,7 +1102,7 @@ export async function finishPlanResume(args) {
         args.log(renderPlanProgressLine({ content: { ...extract.content, phases: provisionalPhases }, statuses, currentId: null }));
         if (!next && provisionalPhases.every((p) => isPhaseSatisfied(statuses[p.id], p.audit))) {
             // C2 (D24): same chain as preparePlanResume — single source in plan-run.ts.
-            args.log(...planCompletionLines(provisionalPhases));
+            args.log(...planCompletionLines(provisionalPhases, undefined, planBuildTransport(provisionalPhases)));
             // Step 2 (C5): the live run finished — a rebuild whose plan this is reads built.
             // Not at the re-opened complete plan above (preparePlanResume).
             await afterPlanComplete(args.prepared.path);
@@ -1056,6 +1130,42 @@ export async function finishPlanResume(args) {
         nextTitle: next ? phaseDisplayTitle(next, extract.content.phases) : null,
     };
 }
+/**
+ * The finish-check guard's write: when finishCheckGuard rules the executed
+ * step down, set it to 'blocked' in the status map, the item list and the
+ * summary, append the note to its work.notes and log the same line.
+ */
+function applyFinishCheckGuard(extract, args) {
+    const executedId = args.prepared.nextPhaseId;
+    const executed = extract.content.phases.find((p) => p.id === executedId);
+    if (!executed)
+        return;
+    const ruling = finishCheckGuard({
+        messages: args.messages,
+        messagesStart: args.messagesStart,
+        status: extract.statuses[executedId],
+        step: phaseDisplayTitle(executed, extract.content.phases),
+        notes: executed.work?.notes,
+    });
+    if (!ruling)
+        return;
+    extract.statuses[executedId] = ruling.status;
+    for (const it of extract.items)
+        if (it.id === executedId)
+            it.status = ruling.status;
+    const prevNotes = executed.work?.notes;
+    executed.work = { ...(executed.work ?? {}), notes: prevNotes ? `${prevNotes}\n${ruling.note}` : ruling.note };
+    const phases = extract.content.phases;
+    const next = computeNextPhase(phases, extract.statuses);
+    extract.content.summary = {
+        ...extract.content.summary,
+        validated: phases.filter((p) => isPhaseSatisfied(extract.statuses[p.id], p.audit)).length,
+        blocked: phases.filter((p) => extract.statuses[p.id] === 'blocked').length,
+        next: next?.id ?? null,
+    };
+    args.log('');
+    args.log(ruling.note);
+}
 /**
  * Final fix wave, item 5 — save a new plan version beside the plan file. When
  * that write fails (a read-only or missing folder), save it in the working

package/dist/commands/plan-startup.js

@@ -17,7 +17,7 @@ import { basename, dirname } from 'node:path';
 import { readProjectFile } from '../projects/status.js';
 import { parsePlanContent } from '../projects/plan-schema.js';
 import { computeNextPhaseForRun, isPhaseSatisfiedForRun, phaseDisplayTitle, statusesFromItems, } from '../projects/plan-run.js';
-import { collectPlannedObjects, plannedObjectFacts, planGrantFactLines } from '../projects/plan-objects.js';
+import { collectPlannedObjects, plannedObjectFacts, planGrantCoversWrites, planGrantFactLines, planTransportFact, } from '../projects/plan-objects.js';
 import { adoptPlanTransportOnResume, buildResumeCommand, planBuildTransport } from './plan-resume.js';
 import { newestPlanFamilyFiles } from '../session/recap.js';
 import { recordCliCard } from '../session/cli-record.js';
@@ -100,8 +100,8 @@ function objectListFacts(objects, transport, grantable) {
     return [
         `It will create or change these ${objects.length} SAP object${objects.length === 1 ? '' : 's'}:`,
         ...plannedObjectFacts(objects).map((r) => `  ${r}`),
-        `Transport: ${transport ?? 'a new one for this build'}`,
-        ...(grantable ? planGrantFactLines() : ['CSPeach asks before each write.']),
+        planTransportFact(transport, objects),
+        ...(grantable && planGrantCoversWrites(transport, objects) ? planGrantFactLines() : ['CSPeach asks before each write.']),
     ];
 }
 const OBJECT_LIST_FAILED = 'The object list could not be approved. Each SAP write asks first.';

package/dist/config/loader.js

@@ -45,7 +45,8 @@ export const DEFAULT_CONFIG = {
     // (staged rollout, owner 2026-10-17; users opt in with /chat on, a later
     // release flips this); 'professional' sends no style; 'developer' sends no
     // level (§10 D13).
-    assistant: { lane: 'skills', style: DEFAULT_STYLE, level: DEFAULT_LEVEL },
+    // Stage 1A — 'system' is today's request; 'inline' is opt-in (config set).
+    assistant: { lane: 'skills', style: DEFAULT_STYLE, level: DEFAULT_LEVEL, skills: 'system' },
     // Default `approval-gated` — preserves current UX (user approves each write).
     write_mode: 'approval-gated',
     // Default `managed` — lowest-friction entry point; uses the cspeach.dev proxy.
@@ -321,6 +322,9 @@ async function readConfig() {
             merged.assistant.lane = DEFAULT_CONFIG.assistant.lane;
         merged.assistant.style = parseStyle(merged.assistant.style) ?? DEFAULT_CONFIG.assistant.style;
         merged.assistant.level = parseLevel(merged.assistant.level) ?? DEFAULT_CONFIG.assistant.level;
+        // Stage 1A — unknown values fall back, like the lane.
+        if (merged.assistant.skills !== 'system' && merged.assistant.skills !== 'inline')
+            merged.assistant.skills = DEFAULT_CONFIG.assistant.skills;
         if (merged.ui.background !== undefined && merged.ui.background !== 'dark' && merged.ui.background !== 'light') {
             delete merged.ui.background;
         }

package/dist/cost/cost-log.js

@@ -87,6 +87,12 @@ export function buildEntry(opts) {
         entry.skill = opts.skill;
     if (opts.system_block !== undefined)
         entry.system_block = opts.system_block;
+    if (opts.system_mode !== undefined)
+        entry.system_mode = opts.system_mode;
+    if (opts.skill_appended !== undefined && opts.skill_appended.length > 0)
+        entry.skill_appended = opts.skill_appended;
+    if (opts.tools_surfaced !== undefined && opts.tools_surfaced.length > 0)
+        entry.tools_surfaced = opts.tools_surfaced;
     return entry;
 }
 /**

package/dist/cost/system-block.js

@@ -11,6 +11,12 @@
  * Kept in a module WeakMap, never in the session file (no schema change). A
  * resumed session therefore starts at 'first' again.
  */
+/**
+ * Stage 1A, Task 1A.2 (M2) — the skill part of the key on an inline call: the
+ * system block is the one conversation prompt whatever the skill header says,
+ * and no delegate is composed into it (the delegate rides in the conversation).
+ */
+export const INLINE_SYSTEM_BLOCK_SKILL = '_inline';
 export function systemBlockKey(p) {
     return `${p.skill}|${p.delegateSkill ?? ''}|${p.style}|${p.level}`;
 }

package/dist/docx/doc-meta.js

@@ -11,6 +11,7 @@ const KIND_TITLE = {
     'spec-gap': 'Spec gaps', design: 'Design', estimate: 'Estimate', plan: 'Plan',
     'upgrade-scan': 'Upgrade scan', 'upgrade-report': 'Upgrade report',
     answer: 'CSPeach answer', conversation: 'CSPeach conversation',
+    'change-options': 'Change options',
 };
 /** Z/Y objects, SAP-style names: ZCL_X, ZFI_DUP_INVOICE_CHECK, Z_REPORT, /NS/ZCL_X. */
 const OBJECT_RE = /(?<![\w/])((?:\/[A-Z0-9]+\/)?[ZY][A-Z0-9_]{2,39})\b/;

package/dist/docx/markdown-to-docx.js

@@ -67,6 +67,8 @@ function titlePage(meta) {
         facts.push(`Session: ${meta.session}`);
     if (meta.person)
         facts.push(`Signed in as: ${meta.person}`);
+    if (meta.preparedFor)
+        facts.push(`Prepared for: ${meta.preparedFor}`);
     return [
         new Paragraph({ text: meta.title, heading: HeadingLevel.TITLE, spacing: { before: 2400 } }),
         ...facts.map((f) => new Paragraph({ text: f })),

package/dist/lane/app-chain.js

@@ -18,7 +18,7 @@ import { readProjectFile } from '../projects/status.js';
 import { looksLikeSpecGap } from '../projects/extract-spec-gap.js';
 import { parsePlanContent } from '../projects/plan-schema.js';
 import { adoptPlanTransportOnResume, buildResumeCommand, planBuildTransport } from '../commands/plan-resume.js';
-import { collectPlannedObjects, plannedObjectFacts, planGrantFactLines } from '../projects/plan-objects.js';
+import { collectPlannedObjects, plannedObjectFacts, planGrantCoversWrites, planGrantFactLines, planTransportFact, } from '../projects/plan-objects.js';
 import { phaseDisplayTitle } from '../projects/plan-run.js';
 import { isDeployPhase } from '../projects/plan-lane.js';
 import { installPlanGrant, planGrantAllowed } from '../approvals/plan-grant.js';
@@ -255,12 +255,15 @@ export function buildStartCardFacts(content, opts = {}) {
     // The plan's recorded transport, else the session's current one: the grant
     // is minted with it bound, so the card names it.
     const transport = planBuildTransport(content.phases);
+    // A local-only plan with no transport: the grant covers no write (it needs
+    // a bound transport), so the card says each write asks.
+    const covers = opts.grant !== false && planGrantCoversWrites(transport, objects);
     const facts = [`Steps: ${content.phases.map((p) => phaseDisplayTitle(p, content.phases)).join(' · ')}`];
     if (objects.length > 0) {
         facts.push(`It will create or change these ${objects.length} SAP object${objects.length === 1 ? '' : 's'}:`);
         facts.push(...plannedObjectFacts(objects).map((r) => `  ${r}`));
-        facts.push(`Transport: ${transport ?? 'a new one for this build'}`);
-        if (opts.grant === false)
+        facts.push(planTransportFact(transport, objects));
+        if (!covers)
             facts.push('CSPeach asks before each write.');
         else
             facts.push(...planGrantFactLines());
@@ -273,7 +276,7 @@ export function buildStartCardFacts(content, opts = {}) {
     }
     // The closing fact follows what was granted: with no object-list approval
     // every SAP write asks, so it never promises "only a write not on the list".
-    facts.push(opts.grant !== false && objects.length > 0
+    facts.push(covers && objects.length > 0
         ? 'It runs every step and stops only for your answers, a write not on the list, a failed check, or the deploy.'
         : 'It runs every step and stops for your answers, each SAP write, a failed check, or the deploy.');
     return { facts, objects, ...(transport ? { transport } : {}) };
@@ -314,8 +317,12 @@ export async function afterSpecGapSave(h, savedPath) {
     h.queueNext(cmd, APP_ORIGIN);
     h.emit(STEP_2);
 }
-/** The result was written but could not be read as a spec-gap: the flow waits at step 1. */
-export const SPEC_GAP_NOT_SAVED_LINE = (specToken) => `The /abap-app run is paused at step 1: the spec-gap result could not be saved. Ask CSPeach to "re-issue the spec gap in the standard structure", or run /abap-app ${shownToken(specToken, 'spec file')} again.`;
+/**
+ * The result was written but could not be read as a spec-gap: the flow waits at step 1.
+ * Task 17 fix round 1: it follows the save step's plain "We couldn't save this…"
+ * line, so it says the same thing in the same voice, with no phrase to type.
+ */
+export const SPEC_GAP_NOT_SAVED_LINE = (specToken) => `The /abap-app run is paused at step 1 until the spec-gap result is saved. When we write it again in the usual layout, the run goes on. To start over, run /abap-app ${shownToken(specToken, 'spec file')}.`;
 /** The user said No to the save: the run ends here. */
 export const SPEC_GAP_DECLINED_LINE = (specToken) => `The /abap-app run stopped at step 1 because the spec-gap result was not saved. To start again, run /abap-app ${shownToken(specToken, 'spec file')}.`;
 /**

package/dist/models/server-config.js

@@ -284,7 +284,7 @@ export function managedProxyServesNewShapes() {
  * conversation prompt? True only when its served config says
  * `inline_skills: true`; false with no snapshot or an older proxy. Managed
  * snapshot only: BYOK builds its own system prompt and never needs it.
- * Dormant — nothing calls it until stage 2 (pinned by
+ * Read only by repl/inline-mode.ts `inlineServed` (Stage 1A; pinned by
  * __tests__/served-inline-skills-pin.test.ts). Pure sync read.
  */
 export function servedInlineSkills() {

package/dist/one-shot.js

@@ -82,6 +82,7 @@ import './tools/project/upgrade_merge_progress.js';
 import './tools/project/team_findings.js';
 import './tools/project/team_estate.js';
 import './tools/project/team_lane_move.js';
+import './tools/project/spec_answers_record.js';
 import './tools/subagent/_background-shared.js';
 import './tools/subagent/background_run.js';
 import './tools/subagent/monitor_emit.js';

package/dist/project-context/conventions.js

@@ -25,6 +25,7 @@
  */
 import { promises as fs } from 'node:fs';
 import * as path from 'node:path';
+import { MAX_ENTRIES_VISITED } from './index-files.js';
 /**
  * Default conventions used when no source has anything to say. Picked
  * to match the most common conventions in modern SAP / web projects:
@@ -268,8 +269,11 @@ async function inferStyleFromExistingFiles(cwd) {
  * node_modules, .git, dist, build, .cspeach output dirs. Prefers files
  * likely to reflect human-authored style (ts, js, abap, cds, xml).
  */
-async function findSampleFiles(cwd, limit) {
+export async function findSampleFiles(cwd, limit, maxEntries = MAX_ENTRIES_VISITED) {
     const out = [];
+    // 1.1.53 item 12 — the same entries budget as the index walk: a folder of
+    // ~283,000 empty folders held no sample file and was walked to the end.
+    let entriesLeft = maxEntries;
     const TEXT_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.abap', '.cds', '.xml', '.yaml', '.yml'];
     const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.cspeach', '.abapforge']);
     async function walk(d) {
@@ -285,6 +289,9 @@ async function findSampleFiles(cwd, limit) {
         for (const ent of entries) {
             if (out.length >= limit)
                 return;
+            if (entriesLeft <= 0)
+                return;
+            entriesLeft--;
             if (ent.isFile()) {
                 if (TEXT_EXTENSIONS.some((ext) => ent.name.endsWith(ext))) {
                     out.push(path.join(d, ent.name));

package/dist/project-context/index-files.js

@@ -35,6 +35,15 @@ import * as path from 'node:path';
 const MAX_FILES_TRAVERSED = 10_000;
 /** Cap on paths shipped in FileIndex. Selected by relevance. */
 const MAX_PATHS_IN_INDEX = 500;
+/**
+ * 1.1.53 item 12 — budget on entries (files AND folders) the walk looks at.
+ * %TEMP% held ~283,000 empty folders: the file cap never fired and the walk
+ * opened every one (~10 s). Spent ⇒ the walk stops and the index is cut.
+ * Measured there: 20,000 took ~2.4 s, 5,000 ~0.95 s (with two root reads).
+ * Controller ruling: 12,000, so a real project (an abapGit export of
+ * thousands of files) keeps its full picture up to the 10,000-file cap.
+ */
+export const MAX_ENTRIES_VISITED = 12_000;
 const ALWAYS_SKIPPED_DIRS = new Set([
     'node_modules',
     '.git',
@@ -71,14 +80,32 @@ const SOURCE_EXTENSIONS = new Set([
  * IO errors during the walk are silently skipped (the offending dir/file
  * just doesn't contribute to the count). Never throws.
  */
-export async function indexFiles(cwd) {
+export async function indexFiles(cwd, options = {}) {
+    const maxEntries = options.maxEntries ?? MAX_ENTRIES_VISITED;
+    let entriesLeft = maxEntries;
+    let walkCut = false;
     const ignoreMatchers = await loadIgnoreMatchers(cwd);
-    /** Files collected with their stat info — used to rank for the path list. */
+    /**
+     * Files collected with their stat info — used to rank for the path list.
+     * `order` is the file's place in a plain depth-first walk (the readdir
+     * index at each level), so the output keeps today's order although the
+     * walk now visits each level's files before its folders.
+     */
     const collected = [];
-    const byExtension = {};
     let totalFiles = 0;
     let truncated = false;
-    async function walk(dir, relPrefix) {
+    let rootEntries = null;
+    /** One entry of the budget; false (and the walk marked cut) once it is spent. */
+    function spend() {
+        if (entriesLeft <= 0) {
+            walkCut = true;
+            truncated = true;
+            return false;
+        }
+        entriesLeft--;
+        return true;
+    }
+    async function walk(dir, relPrefix, order) {
         if (truncated)
             return;
         let entries;
@@ -88,45 +115,68 @@ export async function indexFiles(cwd) {
         catch {
             return;
         }
-        for (const ent of entries) {
+        // The root listing is kept for the top-level list (one read, not two).
+        if (relPrefix === '')
+            rootEntries = entries;
+        // 1.1.53 item 12 (fix round 3) — this level's files first, then its
+        // folders: one big early folder can no longer spend the entries budget
+        // before a spec or plan file at this level is seen.
+        for (let i = 0; i < entries.length; i++) {
+            const ent = entries[i];
+            if (ent.isDirectory())
+                continue;
             if (truncated)
                 return;
+            if (!spend())
+                return;
+            if (!ent.isFile())
+                continue;
             const relPath = relPrefix ? `${relPrefix}/${ent.name}` : ent.name;
-            if (ent.isDirectory()) {
-                if (ALWAYS_SKIPPED_DIRS.has(ent.name))
-                    continue;
-                if (matchesIgnore(ignoreMatchers, relPath, /* isDirectory */ true))
-                    continue;
-                await walk(path.join(dir, ent.name), relPath);
+            if (matchesIgnore(ignoreMatchers, relPath, /* isDirectory */ false))
+                continue;
+            if (totalFiles >= MAX_FILES_TRAVERSED) {
+                truncated = true;
+                return;
             }
-            else if (ent.isFile()) {
-                if (matchesIgnore(ignoreMatchers, relPath, /* isDirectory */ false))
-                    continue;
-                if (totalFiles >= MAX_FILES_TRAVERSED) {
-                    truncated = true;
-                    return;
-                }
-                totalFiles++;
-                const ext = extOf(ent.name);
-                byExtension[ext] = (byExtension[ext] ?? 0) + 1;
-                // Read mtime cheaply; on error use 0 so the file sorts late.
-                let mtime = 0;
-                try {
-                    const s = await fs.stat(path.join(dir, ent.name));
-                    mtime = s.mtimeMs;
-                }
-                catch {
-                    // ignore
-                }
-                collected.push({ path: relPath, ext, mtime });
+            totalFiles++;
+            // Read mtime cheaply; on error use 0 so the file sorts late.
+            let mtime = 0;
+            try {
+                const s = await fs.stat(path.join(dir, ent.name));
+                mtime = s.mtimeMs;
             }
+            catch {
+                // ignore
+            }
+            collected.push({ path: relPath, ext: extOf(ent.name), mtime, order: [...order, i] });
+        }
+        for (let i = 0; i < entries.length; i++) {
+            const ent = entries[i];
+            if (!ent.isDirectory())
+                continue;
+            if (truncated)
+                return;
+            if (!spend())
+                return;
+            if (ALWAYS_SKIPPED_DIRS.has(ent.name))
+                continue;
+            const relPath = relPrefix ? `${relPrefix}/${ent.name}` : ent.name;
+            if (matchesIgnore(ignoreMatchers, relPath, /* isDirectory */ true))
+                continue;
+            await walk(path.join(dir, ent.name), relPath, [...order, i]);
         }
     }
-    await walk(cwd, '');
+    await walk(cwd, '', []);
+    // Back to the plain depth-first order, so the counts and the ranking below
+    // see the files in exactly today's order.
+    collected.sort((a, b) => compareOrder(a.order, b.order));
+    const byExtension = {};
+    for (const f of collected)
+        byExtension[f.ext] = (byExtension[f.ext] ?? 0) + 1;
     // Top-level dirs that survived the walk (i.e. weren't skipped).
     let topLevelDirs = [];
     try {
-        const topLevel = await fs.readdir(cwd, { withFileTypes: true });
+        const topLevel = rootEntries ?? await fs.readdir(cwd, { withFileTypes: true });
         topLevelDirs = topLevel
             .filter((e) => e.isDirectory() && !ALWAYS_SKIPPED_DIRS.has(e.name) && !matchesIgnore(ignoreMatchers, e.name, true))
             .map((e) => e.name)
@@ -144,13 +194,26 @@ export async function indexFiles(cwd) {
         return b.mtime - a.mtime;
     });
     const paths = collected.slice(0, MAX_PATHS_IN_INDEX).map((f) => f.path);
-    return {
+    const index = {
         totalFiles,
         byExtension,
         topLevelDirs,
         paths,
         truncated,
     };
+    // Only a cut walk carries the field, so every other index is the same object as before.
+    if (walkCut)
+        index.walkCut = true;
+    return index;
+}
+/** Lexicographic order of two readdir-index paths (depth-first order). */
+function compareOrder(a, b) {
+    const n = Math.min(a.length, b.length);
+    for (let i = 0; i < n; i++) {
+        if (a[i] !== b[i])
+            return a[i] - b[i];
+    }
+    return a.length - b.length;
 }
 async function loadIgnoreMatchers(cwd) {
     const patterns = [];

package/dist/project-context/index.js

@@ -29,7 +29,7 @@ import { extractCap } from './domain/cap.js';
 import { extractFiori } from './domain/fiori.js';
 import { getGitState } from './git.js';
 import { indexFiles } from './index-files.js';
-export { renderProjectContext } from './render.js';
+export { renderProjectContext, renderProjectContextCapped } from './render.js';
 /**
  * Compute the full project context for a directory. Best-effort: returns
  * null on hard failure (e.g. cwd doesn't exist), otherwise an envelope