@aragon-agent/cli 0.6.4 → 0.6.7

package/dist/exec/runner.js

@@ -17,6 +17,7 @@
 import { formatStreamError } from '../agent/reducer.js';
 import { setSignalTerminator } from '../logging/install.js';
 import { advanceBudget, decideFollowThrough, emptyBudget, } from '../todo/follow-through.js';
+import { ExecProgressReporter } from './progress-reporter.js';
 export function singlePrompt(text) {
     let served = false;
     return {
@@ -40,6 +41,7 @@ export class ExecRunner {
     opts;
     signals;
     now;
+    progress;
     controller = null;
     unsubscribers = [];
     turns = 0;
@@ -62,6 +64,7 @@ export class ExecRunner {
         this.opts = options;
         this.signals = options.signals ?? DEFAULT_SIGNAL_PORT;
         this.now = options.now ?? Date.now;
+        this.progress = new ExecProgressReporter(this.sessionId, (event) => this.emit(event));
     }
     // -----------------------------------------------------------------------
     // Attach / detach
@@ -103,20 +106,65 @@ export class ExecRunner {
         });
         if (todos)
             this.unsubscribers.push(todos);
+        // FOUR BRANCHES, and the split is the whole of W2
+        // (web-use-tier-cooperation-and-control-closure §4.2.1):
+        //
+        //  · `usage`         — folded into the run's totals (unchanged).
+        //  · `review_end`    — the EXISTING `fast_review` still fires only when the
+        //                      critique has text, byte-for-byte as before; a
+        //                      `fast_tier` now fires UNCONDITIONALLY beside it, so a
+        //                      failed / empty / dropped review is finally visible.
+        //  · `tier_changed`  — a `fast_tier` with no `review` sub-object. This is the
+        //                      one that carries `selfDisabled: true`, because the
+        //                      reviewer emits it right after switching itself off.
+        //  · `review_start`  — DROPPED. `inFlight` on the snapshot already says it,
+        //                      and once every N turns it is pure noise.
         const fast = controller.subscribeFast?.((event) => {
             if (event.type === 'usage') {
                 this.usage.inputTokens += event.usage.inputTokens;
                 this.usage.outputTokens += event.usage.outputTokens;
                 return;
             }
-            if (event.type !== 'review_end' || !event.review.text)
+            if (event.type === 'review_start')
+                return;
+            if (event.type === 'review_end' && event.review.text) {
+                this.emit({
+                    type: 'fast_review',
+                    sessionId: this.sessionId,
+                    turn: event.review.turn,
+                    model: event.review.model,
+                    text: event.review.text,
+                });
+            }
+            // `null` means this session never registered a tier, and a session with no
+            // tier has no business appearing on this channel at all.
+            const snapshot = controller.fastSnapshot?.();
+            if (!snapshot)
                 return;
             this.emit({
-                type: 'fast_review',
+                type: 'fast_tier',
                 sessionId: this.sessionId,
-                turn: event.review.turn,
-                model: event.review.model,
-                text: event.review.text,
+                turn: this.turns,
+                live: snapshot.live,
+                selfDisabled: snapshot.selfDisabled,
+                model: snapshot.model,
+                sameAsMain: snapshot.sameAsMain,
+                reviews: snapshot.reviews,
+                reviewBudget: snapshot.reviewBudget,
+                budgetReached: snapshot.budgetReached,
+                delegated: snapshot.delegated,
+                inFlight: snapshot.inFlight,
+                ...(event.type === 'review_end'
+                    ? {
+                        review: {
+                            index: event.review.index,
+                            kind: event.review.kind,
+                            ...(event.review.detail !== undefined ? { detail: event.review.detail } : {}),
+                            durationMs: event.review.durationMs,
+                            injected: event.review.injected,
+                        },
+                    }
+                    : {}),
             });
         });
         if (fast)
@@ -132,6 +180,7 @@ export class ExecRunner {
                 return;
             }
             if (event.type === 'compaction_start') {
+                this.progress.record('compaction');
                 this.emit({
                     type: 'compaction',
                     sessionId: this.sessionId,
@@ -143,6 +192,7 @@ export class ExecRunner {
             }
             if (event.type !== 'compaction_end')
                 return;
+            this.progress.record('model');
             const r = event.record;
             this.emit({
                 type: 'compaction',
@@ -177,6 +227,7 @@ export class ExecRunner {
         if (this.detached)
             return;
         this.detached = true;
+        this.progress.dispose();
         for (const off of this.unsubscribers.splice(0)) {
             try {
                 off();
@@ -241,15 +292,42 @@ export class ExecRunner {
             // nothing more to say exits 0 with `end_turn`, not 3 with `max_turns`.
             if (next === null)
                 break;
-            if (this.turnBudgetExhausted()) {
-                this.stopReason = 'max_turns';
-                break;
+            const requestSeq = ++this.requestSeq;
+            this.requestHadError = false;
+            this.progress.begin(requestSeq);
+            this.emit({ type: 'turn_state', sessionId: this.sessionId, requestSeq, phase: 'started' });
+            this.progress.started(requestSeq);
+            try {
+                if (this.isRequestCancelled())
+                    break;
+                if (this.turnBudgetExhausted()) {
+                    this.stopReason = 'max_turns';
+                    break;
+                }
+                const finished = await this.runFollowThroughChain(controller, next, followThrough);
+                if (finished)
+                    break;
+            }
+            catch (err) {
+                this.errored = true;
+                this.recordError('agent_error', err instanceof Error ? err.message : String(err));
+                throw err;
+            }
+            finally {
+                this.progress.finish(requestSeq);
+                const phase = this.isRequestCancelled()
+                    ? 'cancelled'
+                    : this.requestHadError ? 'failed' : 'completed';
+                this.emit({ type: 'turn_state', sessionId: this.sessionId, requestSeq, phase });
             }
-            const finished = await this.runFollowThroughChain(controller, next, followThrough);
-            if (finished)
-                break;
         }
     }
+    requestSeq = 0;
+    requestHadError = false;
+    isRequestCancelled() {
+        return this.stopReason === 'interrupted' || this.stopReason === 'timeout' ||
+            this.stopReason === 'max_turns';
+    }
     /** One caller message plus every auto-continuation it produces. */
     async runFollowThroughChain(controller, initial, followThrough) {
         let budget = emptyBudget();
@@ -281,7 +359,7 @@ export class ExecRunner {
                 // `aborted` is false here for the same structural reason `-p` gives: an
                 // interrupt sets `stopReason` and returns above, so this branch is only
                 // reached by a run that ended on its own terms.
-                runEnd: { aborted: false, errored: this.errored },
+                runEnd: { aborted: false, errored: this.requestHadError },
                 budget,
                 interactive: false,
             });
@@ -394,18 +472,39 @@ export class ExecRunner {
      * this and add the getter.
      */
     installTerminator() {
-        this.signals.setTerminator((signo) => {
-            const at = this.now();
-            const secondSignal = at - this.lastSignalAt <= SECOND_SIGNAL_WINDOW_MS;
-            if (this.detached || (this.lastSignalAt > 0 && secondSignal)) {
-                this.signals.exit(128 + signo);
-                return;
-            }
-            this.lastSignalAt = at;
-            this.signalNumber = signo;
-            this.stopReason = 'interrupted';
-            this.controller?.abort();
-        });
+        this.signals.setTerminator((signo) => this.onSignal(signo));
+    }
+    /**
+     * Exactly synonymous with a SIGINT, only it does not travel through a signal.
+     *
+     * The stdin `{"type":"interrupt"}` frame routes here. It used to route through
+     * `process.kill(process.pid, 'SIGINT')`, which is fine on POSIX and WRONG on
+     * Windows: Node does not deliver a self-directed SIGINT to its own handlers
+     * there, so the process terminates with exit code 1 having run neither the
+     * terminator below, nor the settle path, nor `persist()`, nor the `result`
+     * event. A wrapper that interrupts a turn and respawns on the same
+     * `--session-id` would silently get a conversation missing everything since the
+     * last save - and `exec/index.ts` was already designed for exactly that caller
+     * ("PERSIST FIRST, ANNOUNCE SECOND").
+     *
+     * POSIX behaviour is byte-for-byte unchanged: the same closure runs, with
+     * `signalNumber = 2`, `exitCode() = 130`, and the two-second second-signal
+     * escape hatch intact.
+     */
+    requestInterrupt() {
+        this.onSignal(2);
+    }
+    onSignal(signo) {
+        const at = this.now();
+        const secondSignal = at - this.lastSignalAt <= SECOND_SIGNAL_WINDOW_MS;
+        if (this.detached || (this.lastSignalAt > 0 && secondSignal)) {
+            this.signals.exit(128 + signo);
+            return;
+        }
+        this.lastSignalAt = at;
+        this.signalNumber = signo;
+        this.stopReason = 'interrupted';
+        this.controller?.abort();
     }
     // -----------------------------------------------------------------------
     // Event translation
@@ -431,6 +530,7 @@ export class ExecRunner {
                 this.checkTurnBudget();
                 break;
             case 'tool_execution_start':
+                this.progress.record('tool');
                 this.emit({
                     type: 'tool_call',
                     sessionId: this.sessionId,
@@ -441,6 +541,7 @@ export class ExecRunner {
                 });
                 break;
             case 'tool_execution_end':
+                this.progress.record('model');
                 this.emit({
                     type: 'tool_result',
                     sessionId: this.sessionId,
@@ -457,7 +558,7 @@ export class ExecRunner {
                 break;
             case 'agent_end':
                 // A swallowed throw (missing key / empty stream) produces no `turn_end`.
-                if (!this.sawTurnEnd && !this.errored && this.stopReason === 'end_turn') {
+                if (!this.sawTurnEnd && !this.requestHadError && !this.isRequestCancelled()) {
                     this.errored = true;
                     this.recordError('agent_error', 'The run produced no assistant turn.');
                 }
@@ -467,6 +568,16 @@ export class ExecRunner {
         }
     }
     onStreamEvent(se) {
+        if (se.type === 'text_delta' && se.delta)
+            this.progress.record('model');
+        if (se.type === 'thinking_delta' && se.delta)
+            this.progress.record('thinking');
+        if (se.type === 'tool_call_delta' && se.argsDelta)
+            this.progress.record('tool_arguments');
+        if (se.type === 'retry_scheduled')
+            this.progress.record('retry', se.delayMs);
+        if (se.type === 'retry_attempt')
+            this.progress.record('model');
         if (se.type === 'text_delta') {
             this.flushThinking();
             if (this.opts.partialMessages) {
@@ -527,6 +638,7 @@ export class ExecRunner {
         this.emit({ type: 'thinking', sessionId: this.sessionId, turn: this.turns + 1, text });
     }
     recordError(code, message) {
+        this.requestHadError = true;
         if (this.errorCode)
             return;
         this.errorCode = code;

package/dist/fast/reviewer.d.ts

@@ -59,7 +59,7 @@
 import type { AgentEvent, AssistantMessage, LLMRequest, TokenUsage } from '@aragon-agent/core';
 import type { FastConfig } from '../config/schema.js';
 import type { NoticeLevel } from '../agent/reducer.js';
-import type { FastEvent, FastTier } from './types.js';
+import type { FastEvent, FastSnapshot, FastTier } from './types.js';
 /**
  * Everything the reviewer needs from the rest of the world.
  *
@@ -93,6 +93,14 @@ export interface FastReviewerDeps {
     available(): boolean;
     getApiKey(providerId: string): string | undefined;
     emit(event: FastEvent): void;
+    /**
+     * `FastWiring.snapshot()`, so the self-disable can announce itself.
+     *
+     * The reviewer cannot build a `FastSnapshot` on its own — `live`,
+     * `sameAsMain`, `delegated` and `pricingUnknown` all belong to the wiring —
+     * and the two existing `tier_changed` emitters read it the same way.
+     */
+    snapshot(): FastSnapshot;
     notify(level: NoticeLevel, text: string): void;
     /** Injected clock. A test that reads the wall clock fails on a slow machine
      *  and nowhere else - the reason `TodoStore` and `TeamPanel` take one. */
@@ -155,6 +163,16 @@ export declare class FastReviewer {
     isBudgetReached(): boolean;
     sessionUsage(): TokenUsage;
     isReviewInFlight(): boolean;
+    /**
+     * Whether this reviewer switched itself off after
+     * `FAST_LIMITS.maxConsecutiveFailures` non-transient failures in a row.
+     *
+     * Carried onto `FastSnapshot` so a wrapper can say "the fast reviews stopped,
+     * and here is why" instead of showing a tier that reads as healthy while not
+     * one review ever arrives. Same shape as `reviewCount()` / `isBudgetReached()`
+     * — a read-only accessor, no side effects.
+     */
+    isSelfDisabled(): boolean;
     /**
      * `AgentController.abort()`.
      *

package/dist/fast/reviewer.js

@@ -141,6 +141,18 @@ export class FastReviewer {
     isReviewInFlight() {
         return this.inFlight;
     }
+    /**
+     * Whether this reviewer switched itself off after
+     * `FAST_LIMITS.maxConsecutiveFailures` non-transient failures in a row.
+     *
+     * Carried onto `FastSnapshot` so a wrapper can say "the fast reviews stopped,
+     * and here is why" instead of showing a tier that reads as healthy while not
+     * one review ever arrives. Same shape as `reviewCount()` / `isBudgetReached()`
+     * — a read-only accessor, no side effects.
+     */
+    isSelfDisabled() {
+        return this.selfDisabled;
+    }
     /**
      * `AgentController.abort()`.
      *
@@ -561,6 +573,16 @@ export class FastReviewer {
             this.selfDisabled = true;
             this.deps.notify('warn', `Fast review disabled for this session after ${FAST_LIMITS.maxConsecutiveFailures} ` +
                 `failures. Last error: ${errorText(err)}`);
+            // THE ONE LINE THAT MAKES THE FLAG OBSERVABLE OUTSIDE THIS PROCESS.
+            //
+            // `emitReview({kind:'failed'})` above already fired, carrying a snapshot
+            // in which `selfDisabled` was still `false`, and after this point the
+            // reviewer emits NOTHING EVER AGAIN (`shouldReview()` opens with
+            // `if (this.selfDisabled) return false;`). Without this extra
+            // `tier_changed`, the field exists, the accessor exists, the snapshot line
+            // exists — and no consumer can ever see it as `true`. The `App` chip also
+            // consumes `tier_changed`; one more refresh is free.
+            this.deps.emit({ type: 'tier_changed', snapshot: this.deps.snapshot() });
         }
     }
     // -----------------------------------------------------------------------

package/dist/fast/types.d.ts

@@ -78,6 +78,21 @@ export interface FastReview {
 export interface FastSnapshot {
     /** The tier resolved AND the live switch is on. */
     live: boolean;
+    /**
+     * The reviewer switched ITSELF off after `maxConsecutiveFailures` in a row
+     * (`FastReviewer.onReviewFailure`).
+     *
+     * ORTHOGONAL TO `live`, AND NEITHER IMPLIES THE OTHER. `live` answers "did
+     * this tier resolve at all" and is `registered && enabled && tier.ok`; the
+     * self-disable touches none of those three, so `live` stays `true` after it.
+     * A consumer that wants to report "the fast reviews stopped happening" MUST
+     * read this field: deriving it as `live === false` is a predicate that can
+     * never be true, and a hand-written fixture makes its test green for ever.
+     *
+     * `available()` is deliberately NOT widened to include it — see the note on
+     * `FastWiring.available`.
+     */
+    selfDisabled: boolean;
     model: string;
     sameAsMain: boolean;
     reviews: number;

package/dist/fast/wiring.d.ts

@@ -115,7 +115,16 @@ export declare class FastWiring {
     private getFastRegistry;
     isRegistered(): boolean;
     isEnabled(): boolean;
-    /** §3.3's live predicate. THE THIRD TERM IS THE POINT - see the header. */
+    /**
+     * §3.3's live predicate. THE THIRD TERM IS THE POINT - see the header.
+     *
+     * `FastReviewer.isSelfDisabled()` is DELIBERATELY NOT a fourth term. Folding
+     * it in would look tidier and would break something else: `delegationAvailable()`
+     * is `available() && config.fast.delegate === true`, so three consecutive
+     * REVIEW failures would silently switch DELEGATION off as well - turning a
+     * diagnostic signal into a behaviour change for every user. The two facts are
+     * reported separately on `FastSnapshot` instead (`live` / `selfDisabled`).
+     */
     available(): boolean;
     /**
      * Whether `model: "fast"` on `task` is honoured right now.

package/dist/fast/wiring.js

@@ -53,6 +53,9 @@ export function offFastStatus() {
         tier: { ok: false, reason: 'disabled' },
         snapshot: {
             live: false,
+            // A tier that never existed was never switched off by its reviewer, so
+            // `false` here is the truth and not a placeholder.
+            selfDisabled: false,
             model: '',
             sameAsMain: false,
             reviews: 0,
@@ -113,6 +116,9 @@ export class FastWiring {
             available: () => this.available(),
             getApiKey: deps.getApiKey,
             emit: (event) => this.emit(event),
+            // The reviewer announces its own self-disable with a `tier_changed`, and
+            // only the wiring can build the snapshot that carries it.
+            snapshot: () => this.snapshot(),
             notify: deps.notify,
         });
     }
@@ -158,7 +164,16 @@ export class FastWiring {
     isEnabled() {
         return this.enabled;
     }
-    /** §3.3's live predicate. THE THIRD TERM IS THE POINT - see the header. */
+    /**
+     * §3.3's live predicate. THE THIRD TERM IS THE POINT - see the header.
+     *
+     * `FastReviewer.isSelfDisabled()` is DELIBERATELY NOT a fourth term. Folding
+     * it in would look tidier and would break something else: `delegationAvailable()`
+     * is `available() && config.fast.delegate === true`, so three consecutive
+     * REVIEW failures would silently switch DELEGATION off as well - turning a
+     * diagnostic signal into a behaviour change for every user. The two facts are
+     * reported separately on `FastSnapshot` instead (`live` / `selfDisabled`).
+     */
     available() {
         return this.registered && this.enabled && this.tier.ok;
     }
@@ -272,6 +287,8 @@ export class FastWiring {
         const ref = this.tier.ok ? this.tier.ref : null;
         return {
             live: this.available(),
+            // ORTHOGONAL TO `live`, never derivable from it (see `FastSnapshot`).
+            selfDisabled: this.reviewer.isSelfDisabled(),
             model: ref ? ref.modelId : '',
             sameAsMain: this.tier.ok ? this.tier.sameAsMain : false,
             // THE NUMERATOR, THE DENOMINATOR AND THE FLAG ARE READ IN ONE EXPRESSION,

package/dist/todo/limits.d.ts

@@ -32,13 +32,10 @@ export declare const TODO_LIMITS: {
      * there (§3.3 step 2).
      */
     readonly minFreshItems: 2;
-    /** Rows the in-progress row may wrap to. Every other row truncates. */
-    readonly activeWrapRows: 2;
-    /**
-     * Below this many AVAILABLE rail rows (`todoRailRows`, NOT `viewportBudget`)
-     * the rail is not mounted at all.
-     */
-    readonly panelMinRows: 6;
+    /** Minimum shared middle rows for the compact rail. */
+    readonly panelMinRows: 3;
+    /** Full rail includes a blank separator and separate overflow markers. */
+    readonly panelFullRows: 6;
     /** Below this many terminal columns the status-bar counter degrades to `[3/7]`. */
     readonly statusCompactCols: 100;
     /**
@@ -51,16 +48,6 @@ export declare const TODO_LIMITS: {
      * component was a third policy or a typo for one of them.
      */
     readonly stripDoneCols: 80;
-    /**
-     * Rows `todoRailRows()` subtracts while a team dispatch is live (§3.9 / P1-3).
-     *
-     * `TEAM_LIMITS.panelMaxRows` (5) + header + `+N more` + the mail line = 8, and
-     * this is deliberately the FULL worst case rather than a measurement: an
-     * over-subtraction costs one item row, an under-subtraction eats the `+N
-     * below` marker - the one row whose absence is indistinguishable from "the
-     * list is short" - and those two mistakes are not equally bad.
-     */
-    readonly railReservedRows: 8;
     /**
      * Consecutive user turns an UNFINISHED list survives without a `todo_write`
      * before `beginUserTurn()` drops it (§3.2 / P1-7). Three keeps the common

package/dist/todo/limits.js

@@ -32,13 +32,10 @@ export const TODO_LIMITS = {
      * there (§3.3 step 2).
      */
     minFreshItems: 2,
-    /** Rows the in-progress row may wrap to. Every other row truncates. */
-    activeWrapRows: 2,
-    /**
-     * Below this many AVAILABLE rail rows (`todoRailRows`, NOT `viewportBudget`)
-     * the rail is not mounted at all.
-     */
-    panelMinRows: 6,
+    /** Minimum shared middle rows for the compact rail. */
+    panelMinRows: 3,
+    /** Full rail includes a blank separator and separate overflow markers. */
+    panelFullRows: 6,
     /** Below this many terminal columns the status-bar counter degrades to `[3/7]`. */
     statusCompactCols: 100,
     /**
@@ -51,16 +48,6 @@ export const TODO_LIMITS = {
      * component was a third policy or a typo for one of them.
      */
     stripDoneCols: 80,
-    /**
-     * Rows `todoRailRows()` subtracts while a team dispatch is live (§3.9 / P1-3).
-     *
-     * `TEAM_LIMITS.panelMaxRows` (5) + header + `+N more` + the mail line = 8, and
-     * this is deliberately the FULL worst case rather than a measurement: an
-     * over-subtraction costs one item row, an under-subtraction eats the `+N
-     * below` marker - the one row whose absence is indistinguishable from "the
-     * list is short" - and those two mistakes are not equally bad.
-     */
-    railReservedRows: 8,
     /**
      * Consecutive user turns an UNFINISHED list survives without a `todo_write`
      * before `beginUserTurn()` drops it (§3.2 / P1-7). Three keeps the common

package/dist/todo/panel-rows.d.ts

@@ -37,17 +37,19 @@ export interface TodoRowSelection {
 export declare function todoAnchorIndex(items: TodoItem[]): number;
 /**
  * @param maxRows Rows available for the item rows AND the two overflow markers
- *                together. `todoRailRows()` upstream is what makes this number
- *                honest while a team dispatch is live (I-10 / P1-3).
+ *                together. The shared layout subtracts actual team/menu rows.
  *
  * THE ANCHOR IS ALWAYS VISIBLE, and that beats the row bound when the two
  * conflict. They can only conflict below `maxRows` 3 with overflow on BOTH
  * sides — one item plus two markers is three rows — where this returns the
  * anchor and lets the caller's `overflow="hidden"` clip a marker. Hiding the
  * one row the user is watching in order to keep a `+N above` would be the wrong
- * trade. `TODO_LIMITS.panelMinRows` (6) gates the mount and leaves `TodoPanel`
- * at least 4 item rows, so the case is unreachable from the rail; a future
- * caller with a smaller budget should read this paragraph before assuming
- * otherwise.
+ * trade. The full rail has at least four item rows. The compact rail uses
+ * `selectCompactTodoRows` with a single merged footer instead.
  */
 export declare function selectTodoRows(items: TodoItem[], maxRows: number): TodoRowSelection;
+/** Select an anchored contiguous window without reserving overflow-marker rows.
+ * maxItemRows is a row count; invalid/nonpositive values return an empty window
+ * with every item counted below it. Does not mutate the list or throw.
+ */
+export declare function selectCompactTodoRows(items: TodoItem[], maxItemRows: number): TodoRowSelection;

package/dist/todo/panel-rows.js

@@ -58,18 +58,15 @@ function windowFor(count, anchor, slots) {
 }
 /**
  * @param maxRows Rows available for the item rows AND the two overflow markers
- *                together. `todoRailRows()` upstream is what makes this number
- *                honest while a team dispatch is live (I-10 / P1-3).
+ *                together. The shared layout subtracts actual team/menu rows.
  *
  * THE ANCHOR IS ALWAYS VISIBLE, and that beats the row bound when the two
  * conflict. They can only conflict below `maxRows` 3 with overflow on BOTH
  * sides — one item plus two markers is three rows — where this returns the
  * anchor and lets the caller's `overflow="hidden"` clip a marker. Hiding the
  * one row the user is watching in order to keep a `+N above` would be the wrong
- * trade. `TODO_LIMITS.panelMinRows` (6) gates the mount and leaves `TodoPanel`
- * at least 4 item rows, so the case is unreachable from the rail; a future
- * caller with a smaller budget should read this paragraph before assuming
- * otherwise.
+ * trade. The full rail has at least four item rows. The compact rail uses
+ * `selectCompactTodoRows` with a single merged footer instead.
  */
 export function selectTodoRows(items, maxRows) {
     const count = items.length;
@@ -101,3 +98,19 @@ export function selectTodoRows(items, maxRows) {
         visible.push({ item: items[i], index: i });
     return { visible, hiddenAbove: start, hiddenBelow: count - end };
 }
+/** Select an anchored contiguous window without reserving overflow-marker rows.
+ * maxItemRows is a row count; invalid/nonpositive values return an empty window
+ * with every item counted below it. Does not mutate the list or throw.
+ */
+export function selectCompactTodoRows(items, maxItemRows) {
+    const slots = Number.isFinite(maxItemRows) ? Math.max(0, Math.floor(maxItemRows)) : 0;
+    if (slots === 0 || items.length === 0) {
+        return { visible: [], hiddenAbove: 0, hiddenBelow: items.length };
+    }
+    const { start, end } = windowFor(items.length, todoAnchorIndex(items), slots);
+    return {
+        visible: items.slice(start, end).map((item, offset) => ({ item, index: start + offset })),
+        hiddenAbove: start,
+        hiddenBelow: items.length - end,
+    };
+}