@aragon-agent/cli 0.6.34 → 0.6.36

package/dist/ui/overlays/prompt-library-state.js

@@ -0,0 +1,335 @@
+/**
+ * The prompt manager's state machine and view models (quick-prompt-library §4.4).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`. Every sentence the
+ * user reads comes from `prompts/copy.ts`; nothing in this file may hold a literal
+ * non-ASCII byte.
+ *
+ * WHY A PURE REDUCER AND NOT `useState` INSIDE THE COMPONENT: the page stack has two
+ * transitions that are easy to get wrong and impossible to see on screen - "the
+ * second Esc discards, the first does not" and "the intent is consumed exactly
+ * once" - and both are assertions, not screenshots. Everything below can be driven
+ * from a test with no Ink mounted.
+ */
+import { PROMPT_LIMITS } from '../../prompts/limits.js';
+import { parsePromptTags, validatePromptDraft } from '../../prompts/store.js';
+// The list's read-only preview is the ONE place `wrapToRows` belongs: it is a prose
+// wrapper, so it would destroy the caret-to-cell mapping in an editable field
+// (D-11), and there is no caret here.
+import { wrapToRows } from '../layout/wrap-rows.js';
+/** The six rows `Tab` cycles on the editor page, in visual order. */
+export const PROMPT_EDITOR_FIELDS = [
+    'title', 'content', 'description', 'tags', 'save', 'cancel',
+];
+/** A new, empty draft. `id: null` is what makes `Save` a create rather than an update. */
+export const EMPTY_PROMPT_DRAFT = {
+    id: null,
+    title: '',
+    content: '',
+    description: '',
+    tags: '',
+    favorite: false,
+};
+export const INITIAL_PROMPT_LIBRARY_STATE = {
+    page: 'list',
+    index: 0,
+    focusId: null,
+    draft: EMPTY_PROMPT_DRAFT,
+    baseline: null,
+    escArmed: false,
+    pendingDeleteId: null,
+    error: null,
+    errorField: null,
+    consumedIntentNonce: 0,
+};
+/** The editable projection of a stored entry. */
+export function draftFromEntry(entry) {
+    return {
+        id: entry.id,
+        title: entry.title,
+        content: entry.content,
+        description: entry.description ?? '',
+        tags: (entry.tags ?? []).join(' '),
+        favorite: entry.favorite === true,
+    };
+}
+/** A create draft seeded from a command (`/prompts add title :: body`). */
+export function seededDraft(seed) {
+    return {
+        ...EMPTY_PROMPT_DRAFT,
+        title: seed?.title ?? '',
+        content: seed?.content ?? '',
+    };
+}
+/** Structural equality is enough: every field is a string or a boolean. */
+export function draftIsDirty(draft, baseline) {
+    if (baseline === null) {
+        return draft.title.length > 0 || draft.content.length > 0
+            || draft.description.length > 0 || draft.tags.length > 0;
+    }
+    return draft.title !== baseline.title || draft.content !== baseline.content
+        || draft.description !== baseline.description || draft.tags !== baseline.tags
+        || draft.favorite !== baseline.favorite;
+}
+/**
+ * Validate a draft and turn it into what the store accepts (D-12).
+ *
+ * THE VALIDATOR IS `store.ts`'S, not a second copy here: the sentence the editor
+ * shows and the rule the write applies have to be the same rule, or a user can be
+ * told a title is fine by the form and refused by the store.
+ */
+export function finishPromptEditor(draft) {
+    return validatePromptDraft({
+        title: draft.title,
+        content: draft.content,
+        description: draft.description,
+        tags: parsePromptTags(draft.tags),
+        favorite: draft.favorite,
+    });
+}
+/** Index of the first focusable row, for a refusal that named a field. */
+export function fieldIndex(field) {
+    if (field === null)
+        return 0;
+    const at = PROMPT_EDITOR_FIELDS.indexOf(field);
+    return at < 0 ? 0 : at;
+}
+function enterEditor(state, draft, baseline) {
+    return {
+        ...state,
+        page: 'editor',
+        draft,
+        baseline,
+        escArmed: false,
+        error: null,
+        errorField: null,
+    };
+}
+/**
+ * The reducer.
+ *
+ * `init` is the ONLY action that can jump straight to the editor or the delete page:
+ * that is what makes `/prompts edit 2` land where it should (D-21). The intent's
+ * nonce is stored as `consumedIntentNonce` by the component before dispatching, so a
+ * replayed intent is a no-op at the component, not a second edit here.
+ */
+export function promptLibraryReducer(state, action, library) {
+    switch (action.type) {
+        case 'init': {
+            if (action.nonce <= state.consumedIntentNonce)
+                return state;
+            const consumed = { ...state, consumedIntentNonce: action.nonce };
+            const entry = action.entry;
+            if (entry.kind === 'create') {
+                return enterEditor(consumed, seededDraft(entry.seed), null);
+            }
+            if (entry.kind === 'edit') {
+                const found = action.library.prompts.find((prompt) => prompt.id === entry.id);
+                if (!found)
+                    return { ...consumed, page: 'list', focusId: null };
+                const draft = draftFromEntry(found);
+                return enterEditor(consumed, draft, { ...draft });
+            }
+            if (entry.kind === 'delete') {
+                const found = action.library.prompts.find((prompt) => prompt.id === entry.id);
+                if (!found)
+                    return { ...consumed, page: 'list', focusId: null };
+                return { ...consumed, page: 'delete', pendingDeleteId: entry.id };
+            }
+            return { ...consumed, page: 'list', focusId: entry.focusId ?? null, index: 0 };
+        }
+        case 'list':
+            return {
+                ...state,
+                page: 'list',
+                focusId: action.focusId ?? state.focusId,
+                escArmed: false,
+                pendingDeleteId: null,
+                error: null,
+                errorField: null,
+            };
+        case 'focus':
+            return { ...state, index: Math.max(0, Math.floor(action.index)) };
+        case 'create':
+            return enterEditor(state, seededDraft(action.seed), null);
+        case 'edit': {
+            const found = action.library.prompts.find((prompt) => prompt.id === action.id);
+            if (!found)
+                return { ...state, page: 'list', error: 'not_found' };
+            const draft = draftFromEntry(found);
+            return enterEditor(state, draft, { ...draft });
+        }
+        case 'delete':
+            return { ...state, page: 'delete', pendingDeleteId: action.id };
+        case 'draft':
+            return { ...state, draft: { ...state.draft, ...action.patch }, escArmed: false };
+        case 'commit':
+            return {
+                ...state,
+                page: 'list',
+                focusId: action.id,
+                baseline: null,
+                escArmed: false,
+                error: null,
+                errorField: null,
+                draft: EMPTY_PROMPT_DRAFT,
+            };
+        case 'failed':
+            return { ...state, error: action.code, errorField: action.field ?? null };
+        case 'esc': {
+            if (state.page !== 'editor')
+                return { ...state, page: 'list', pendingDeleteId: null };
+            // A CLEAN EDITOR CLOSES ON THE FIRST Esc. A dirty one asks once, and the answer
+            // has to be a second Esc rather than a modal: losing a body typed into a
+            // multi-line field because one key was pressed is the failure this guards.
+            if (!draftIsDirty(state.draft, state.baseline)) {
+                return { ...state, page: 'list', baseline: null, draft: EMPTY_PROMPT_DRAFT };
+            }
+            if (state.escArmed) {
+                return {
+                    ...state, page: 'list', baseline: null, escArmed: false, draft: EMPTY_PROMPT_DRAFT,
+                };
+            }
+            return { ...state, escArmed: true };
+        }
+        case 'cancelled':
+            return { ...state, page: 'list', baseline: null, escArmed: false, draft: EMPTY_PROMPT_DRAFT };
+    }
+}
+/** `1.2k` for anything a fixed-width column cannot show in full. */
+export function formatCount(count) {
+    if (count < 1000)
+        return String(count);
+    return `${(count / 1000).toFixed(1)}k`;
+}
+/** `3d ago` / `2h ago` / `just now`. Deliberately coarse: it is a hint, not a clock. */
+export function formatAgo(timestamp, now) {
+    if (timestamp === undefined || timestamp <= 0)
+        return 'never';
+    const seconds = Math.max(0, Math.floor((now - timestamp) / 1000));
+    if (seconds < 60)
+        return 'just now';
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    return `${Math.floor(hours / 24)}d ago`;
+}
+/**
+ * The list, one row per entry, in the library's own order.
+ *
+ * DUPLICATE TITLES GET AN ID PREFIX (I-2), exactly as `kit-picker-state.ts` does for
+ * duplicate kit names: two rows reading the same words make `Enter` a coin flip.
+ */
+export function libraryRows(library) {
+    const seen = new Map();
+    for (const prompt of library.prompts) {
+        seen.set(prompt.title, (seen.get(prompt.title) ?? 0) + 1);
+    }
+    return library.prompts.map((prompt) => {
+        const duplicate = (seen.get(prompt.title) ?? 0) > 1;
+        const identity = duplicate ? `#${prompt.id.slice(0, 8)} ` : '';
+        const marks = [];
+        if (prompt.favorite === true)
+            marks.push('[fav]');
+        const tags = prompt.tags ?? [];
+        for (const tag of tags.slice(0, 2))
+            marks.push(`#${tag}`);
+        if (tags.length > 2)
+            marks.push(`+#${tags.length - 2}`);
+        marks.push(`${formatCount([...prompt.content].length)}c`);
+        if (prompt.useCount > 0)
+            marks.push(`${formatCount(prompt.useCount)}x`);
+        return {
+            id: prompt.id,
+            label: `${identity}${prompt.title}  ${marks.join(' ')}`,
+            markers: {
+                favorite: prompt.favorite === true,
+                hasTags: tags.length > 0,
+                uses: prompt.useCount,
+            },
+            chars: [...prompt.content].length,
+        };
+    });
+}
+/**
+ * The detail block under the list: at most `detailMaxLines` rows, fixed shape.
+ *
+ * FIXED, because `OverlayFrame`'s window is shared with the list (D-16): a body that
+ * participated in row height would squeeze six prompts into two visible rows. The
+ * full text has exactly one home, and it is the editor.
+ */
+export function libraryDetail(row, library, cols, now = Date.now()) {
+    if (!row)
+        return [];
+    const prompt = library.prompts.find((entry) => entry.id === row.id);
+    if (!prompt)
+        return [];
+    const tags = (prompt.tags ?? []).map((tag) => `#${tag}`).join(' ');
+    const facts = [
+        `${formatCount(row.chars)} chars`,
+        `${prompt.useCount} uses`,
+        formatAgo(prompt.lastUsedAt, now),
+        prompt.favorite === true ? '[fav]' : '',
+    ].filter(Boolean).join('  ');
+    const body = prompt.content.split('\n').slice(0, PROMPT_LIMITS.detailPreviewLines).join('\n');
+    const preview = wrapToRows(body, Math.max(8, cols - 8))
+        .slice(0, PROMPT_LIMITS.detailPreviewLines);
+    return [prompt.title, ...(tags.length > 0 ? [tags] : []), facts, ...preview]
+        .slice(0, PROMPT_LIMITS.detailMaxLines);
+}
+/**
+ * The list page's footer.
+ *
+ * THE LAST CLAUSE IS ALWAYS THE WAY OUT (§9.5): a narrow terminal clips from the
+ * left, so the reader always keeps `Esc close`. The reorder keys are named here
+ * rather than in the row above it because they are the one affordance a user cannot
+ * discover by pressing a key they already know.
+ */
+export function libraryHint(state, count) {
+    if (state.page === 'delete')
+        return 'Enter delete | Esc cancel';
+    if (state.page === 'editor')
+        return editorHint(state);
+    if (count === 0)
+        return 'a create your first prompt | Esc close';
+    return 'Enter edit | a new | d delete | f favorite | ^up/^dn reorder | Esc close';
+}
+function editorHint(state) {
+    if (state.escArmed)
+        return 'Esc again discards the draft | Tab next field';
+    return 'Tab next field | Ctrl+S save | Esc close';
+}
+/** The delete page's four lines: what it is, how big, and what it costs. */
+export function deleteDetail(library, id) {
+    const prompt = library.prompts.find((entry) => entry.id === id);
+    if (!prompt)
+        return [];
+    return [
+        prompt.title,
+        `${[...prompt.content].length} chars, ${prompt.content.split('\n').length} lines`,
+        'This cannot be undone.',
+        'Enter or y deletes it; Esc or n keeps it.',
+    ];
+}
+/**
+ * The draft as the store accepts it.
+ *
+ * THE TAGS FIELD IS PARSED HERE, ONCE, and nowhere else: the editor edits a raw
+ * string, the store validates a `string[]`, and a second parser between them is how
+ * `a,b` and `a b` come to mean different things depending on which surface saved it.
+ */
+export function draftToInput(draft) {
+    const input = {
+        title: draft.title,
+        content: draft.content,
+        tags: parsePromptTags(draft.tags),
+        favorite: draft.favorite,
+    };
+    const description = draft.description.trim();
+    if (description.length > 0)
+        input.description = description;
+    return input;
+}

package/dist/ui/overlays/prompt-picker-state.d.ts

@@ -0,0 +1,71 @@
+/**
+ * The prompt picker's view model (quick-prompt-library §4.5).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * THE ROWS ARE COMPUTED OUTSIDE THE COMPONENT for the reason `kit-picker-state.ts`
+ * records one surface over: the same library is rendered by two overlays and by
+ * `/prompts list`, and three independent row builders is how "the manager says four
+ * entries and the picker says five" becomes possible without a single failing test.
+ */
+import type { PromptLibrary, PromptSortView } from '../../prompts/types.js';
+export interface PromptPickerRow {
+    id: string;
+    /** 1-based position in the CURRENT view, i.e. the number `1`-`9` addresses. */
+    index: number;
+    title: string;
+    tags: string[];
+    favorite: boolean;
+}
+export interface PromptPickerInput {
+    library: PromptLibrary;
+    query: string;
+    view: PromptSortView;
+}
+/**
+ * Filter the library and number the result.
+ *
+ * THE VIEW IS APPLIED FIRST, THEN THE FILTER: searching inside `recent` must return
+ * the recent order, not the manual one. Reversing the two would make `Ctrl+S` appear
+ * to do nothing whenever a query is active - which is exactly when the user is
+ * looking at the footer to see whether it worked.
+ */
+export declare function pickerRows(input: PromptPickerInput): PromptPickerRow[];
+/**
+ * The block under the list: at most four rows, and never the whole body.
+ *
+ * The picker exists to CHOOSE. The full text belongs to the editor, and printing it
+ * here would push the chosen row off the frame that has to show it.
+ */
+export declare function pickerDetail(row: PromptPickerRow | undefined, library: PromptLibrary, now?: number): string[];
+/**
+ * The empty-library guidance (AC-23).
+ *
+ * IT NAMES TWO WAYS OUT, because the picker is reachable from two directions: the
+ * user who typed `/prompts` on an empty library can press `a` here, and the user who
+ * does not want to type can press `Ctrl+P` later. Naming only one of them leaves the
+ * other audience pressing a key that does nothing.
+ */
+export declare const NO_PROMPTS_HINT = "No prompts yet. Press Ctrl+P to create one, or a to add one here.";
+/**
+ * The footer, ordered by WHICH PATH SURVIVES ON THE WORST TERMINAL (§9.11).
+ *
+ * `Enter fill` comes before `^Enter fill & send` because a terminal without keyboard
+ * enhancement delivers `Ctrl+Enter` as a plain `Enter`: the reader who works left to
+ * right must meet the path that always works first. `tab manage` sits after the two
+ * fill actions for the same reason - it is navigation, not the point of the screen.
+ */
+export declare function pickerHint(input: {
+    count: number;
+    query: string;
+    view: PromptSortView;
+}): string;
+/**
+ * The `1`-`9` shortcut, or `null`.
+ *
+ * A DIGIT IS ONLY A SHORTCUT WHILE THE QUERY IS EMPTY. Otherwise `3` is the third
+ * character of what the user is searching for, and stealing it would make numeric
+ * queries impossible to type - so the guard is the emptiness of the query, not the
+ * shape of the key.
+ */
+export declare function pickerDigitTarget(rows: readonly PromptPickerRow[], input: string): string | null;

package/dist/ui/overlays/prompt-picker-state.js

@@ -0,0 +1,98 @@
+/**
+ * The prompt picker's view model (quick-prompt-library §4.5).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * THE ROWS ARE COMPUTED OUTSIDE THE COMPONENT for the reason `kit-picker-state.ts`
+ * records one surface over: the same library is rendered by two overlays and by
+ * `/prompts list`, and three independent row builders is how "the manager says four
+ * entries and the picker says five" becomes possible without a single failing test.
+ */
+import { PROMPT_PICKER_LIMITS } from '../../prompts/limits.js';
+import { searchPrompts, viewOrder } from '../../prompts/search.js';
+import { formatAgo, formatCount } from './prompt-library-state.js';
+/**
+ * Filter the library and number the result.
+ *
+ * THE VIEW IS APPLIED FIRST, THEN THE FILTER: searching inside `recent` must return
+ * the recent order, not the manual one. Reversing the two would make `Ctrl+S` appear
+ * to do nothing whenever a query is active - which is exactly when the user is
+ * looking at the footer to see whether it worked.
+ */
+export function pickerRows(input) {
+    const ordered = viewOrder(input.library.prompts, input.view);
+    return searchPrompts(ordered, input.query).map(({ prompt }, at) => ({
+        id: prompt.id,
+        index: at + 1,
+        title: prompt.title,
+        tags: prompt.tags ?? [],
+        favorite: prompt.favorite === true,
+    }));
+}
+/**
+ * The block under the list: at most four rows, and never the whole body.
+ *
+ * The picker exists to CHOOSE. The full text belongs to the editor, and printing it
+ * here would push the chosen row off the frame that has to show it.
+ */
+export function pickerDetail(row, library, now = Date.now()) {
+    if (!row)
+        return [];
+    const prompt = library.prompts.find((entry) => entry.id === row.id);
+    if (!prompt)
+        return [];
+    const lines = [
+        `${formatCount([...prompt.content].length)} chars, `
+            + `${prompt.content.split('\n').length} lines, ${formatAgo(prompt.lastUsedAt, now)}`,
+    ];
+    if ((prompt.tags ?? []).length > 0)
+        lines.push((prompt.tags ?? []).map((t) => `#${t}`).join(' '));
+    const firstLine = prompt.content.split('\n')[0] ?? '';
+    if (firstLine.length > 0)
+        lines.push(firstLine);
+    if (prompt.description !== undefined)
+        lines.push(prompt.description);
+    return lines.slice(0, PROMPT_PICKER_LIMITS.detailMaxLines);
+}
+/**
+ * The empty-library guidance (AC-23).
+ *
+ * IT NAMES TWO WAYS OUT, because the picker is reachable from two directions: the
+ * user who typed `/prompts` on an empty library can press `a` here, and the user who
+ * does not want to type can press `Ctrl+P` later. Naming only one of them leaves the
+ * other audience pressing a key that does nothing.
+ */
+export const NO_PROMPTS_HINT = 'No prompts yet. Press Ctrl+P to create one, or a to add one here.';
+/**
+ * The footer, ordered by WHICH PATH SURVIVES ON THE WORST TERMINAL (§9.11).
+ *
+ * `Enter fill` comes before `^Enter fill & send` because a terminal without keyboard
+ * enhancement delivers `Ctrl+Enter` as a plain `Enter`: the reader who works left to
+ * right must meet the path that always works first. `tab manage` sits after the two
+ * fill actions for the same reason - it is navigation, not the point of the screen.
+ */
+export function pickerHint(input) {
+    if (input.count === 0) {
+        return input.query.length > 0
+            ? 'No match | Backspace to widen | Esc close'
+            : `${NO_PROMPTS_HINT} Esc close`;
+    }
+    return 'Enter fill | ^Enter fill & send | 1-9 pick | '
+        + `^S sort: ${input.view} | tab manage | Esc close`;
+}
+/**
+ * The `1`-`9` shortcut, or `null`.
+ *
+ * A DIGIT IS ONLY A SHORTCUT WHILE THE QUERY IS EMPTY. Otherwise `3` is the third
+ * character of what the user is searching for, and stealing it would make numeric
+ * queries impossible to type - so the guard is the emptiness of the query, not the
+ * shape of the key.
+ */
+export function pickerDigitTarget(rows, input) {
+    if (input.length !== 1)
+        return null;
+    const digit = input.charCodeAt(0) - 48;
+    if (digit < 1 || digit > PROMPT_PICKER_LIMITS.quickDigits)
+        return null;
+    return rows[digit - 1]?.id ?? null;
+}

package/dist/ui/scrollback/LiveTail.d.ts

@@ -4,8 +4,8 @@
  *
  * WHY THIS FILE EXISTS. Native scroll mode cannot print an entry until it settles, so
  * the live region used to show `buildLivePreview`'s plain-text projection - and for a
- * running dispatch that projection is four grey rows saying `Team: 2/4 running`. That
- * is the "simple look" the feature was opened for. A text-only region can never fix
+ * running dispatch that projection was four grey rows saying `Team: 2/4 running`. It
+ * was the "simple look" the feature was opened for. A text-only region can never fix
  * it, which is why the region's content type changed from `readonly string[]` to a
  * fixed-height box that can hold components.
  *

package/dist/ui/scrollback/LiveTail.js

@@ -3,7 +3,7 @@ import { Box } from 'ink';
 import { EntryView, nowSecFor } from '../Transcript.js';
 import { estimateEntryRows } from '../layout/virtual-window.js';
 import { SCROLLBACK_LIMITS } from './limits.js';
-import { isExcluded } from './settled-boundary.js';
+import { isSlotless } from './tail-window.js';
 import { resolveTailAnchor } from './tail-anchor.js';
 /**
  * The last `maxEntries` printable entries, each with its predecessor.
@@ -13,7 +13,12 @@ import { resolveTailAnchor } from './tail-anchor.js';
  * separation row the transcript shows above the same card.
  */
 export function selectTailEntries(entries, maxEntries) {
-    const printable = entries.filter((entry) => !isExcluded(entry));
+    // A LIVE DISPATCH CARD TAKES NO SLOT (tui-subagent-double-roster A-2): the roster
+    // draws it and `EntryView` returns null for it, so the window must not spend one of
+    // its slots on an entry that is not on screen. `isSlotless` is `tail-window.ts`'s
+    // predicate - the one `selectTailWindow` and the print pump apply - so the box and
+    // `planOverflowPrint` cannot drift into different windows.
+    const printable = entries.filter((entry) => !isSlotless(entry));
     const limit = Number.isFinite(maxEntries) ? Math.max(0, Math.floor(maxEntries)) : 0;
     if (limit === 0)
         return [];

package/dist/ui/scrollback/band.js

@@ -109,7 +109,20 @@ export function buildLiveBand(input) {
         // now gets the pool too. The branch stays as the named expression of the older policy.
         : Math.max(0, remaining - teamRows - railReserved);
     const bandRows = fill ? remaining : Math.max(railReserved, teamRows + previewRows);
-    const railRows = railVisible ? bandRows : 0;
+    // THE RAIL NO LONGER OWNS THE BAND'S FULL HEIGHT WHEN A ROSTER IS DRAWN
+    // (tui-subagent-panel §4.1.2 / D-3). The roster is now a FULL-WIDTH slot below
+    // the rail's row region, so the two no longer overlap: the rail gets exactly the
+    // rows the roster does not take. With no roster this is `bandRows`, i.e.
+    // byte-identical to the previous behaviour (I-6).
+    //
+    // I-6a, WHY THIS CANNOT STARVE THE RAIL: `teamRows <= teamCeiling =
+    // min(teamRowsNatural, remaining - panelMinRows - 1)` (step 2 above) and in
+    // `fill` mode `bandRows === remaining`, so `railRows >= panelMinRows + 1 = 4`.
+    // Four satisfies both `TODO_LIMITS.panelMinRows(3)` (the rail stays mounted) and
+    // `SCROLLBACK_LIMITS.railBandMinRows(4)` (the band still reports
+    // `reason === 'visible'`). The price of a screen-right clock is a SHORTER rail
+    // during a dispatch, never a missing one - see §4.1.4's worked example.
+    const railRows = railVisible ? Math.max(0, bandRows - teamRows) : 0;
     const railColsOut = railVisible ? railCols : 0;
     return {
         reason,

package/dist/ui/scrollback/live-preview.js

@@ -20,6 +20,7 @@
 import { clampLiveText } from '../live-clamp.js';
 import { wrapToRows } from '../layout/wrap-rows.js';
 import { isExcluded } from './settled-boundary.js';
+import { isLiveTeamCard, outcomePhrase, rosterCounts } from '../team-status.js';
 import { clipLine } from './writer-shapes.js';
 const MAX_TEAM_RUN_ROWS = 3;
 const TOOL_LIVE_ROWS = 6;
@@ -56,8 +57,10 @@ function toolRows(entry, cols) {
     return out;
 }
 function teamRows(entry, cols) {
-    const running = entry.runs.filter((run) => !['queued', 'done', 'failed', 'aborted'].includes(run.phase)).length;
-    const out = [fit(`Team: ${running}/${entry.runs.length} running`, cols)];
+    // ONLY A SETTLED CARD REACHES HERE (the live one projects nothing, below), so the
+    // outcome phrase - `team-status.ts`'s own sentence - replaces an always-zero fraction.
+    const counts = rosterCounts(entry.runs);
+    const out = [fit(`Team: ${outcomePhrase(counts)}`, cols)];
     for (const run of entry.runs.slice(0, MAX_TEAM_RUN_ROWS)) {
         out.push(fit(`  ${run.label} ${run.phase}`, cols));
     }
@@ -71,7 +74,11 @@ function entryRows(entry, input) {
         case 'tool':
             return toolRows(entry, cols);
         case 'team':
-            return teamRows(entry, cols);
+            // THE LIVE DISPATCH HAS ONE SURFACE (tui-subagent-double-roster A-2): this
+            // projection is the text fallback for the same slot `LiveTail` fills, so a
+            // `Team: n/m running` line here would be the second live block again, one level
+            // down. A settled card still projects normally.
+            return isLiveTeamCard(entry) ? [] : teamRows(entry, cols);
         case 'todo':
             return [fit(`Todo: ${entry.doneCount}/${entry.total}`, cols)];
         case 'compaction':

package/dist/ui/scrollback/tail-window.d.ts

@@ -27,6 +27,18 @@
  * closes, and `/perf`'s `window=<start>/<n> head=<rows>` is how it stays observable.
  */
 import type { Entry } from '../../agent/reducer.js';
+/**
+ * Entries that take NO slot in the window: they neither print nor take a row.
+ *
+ * A LIVE DISPATCH CARD JOINS THE NON-TERMINAL SERVICE CARD HERE
+ * (tui-subagent-double-roster A-2'): the roster draws the live dispatch and the
+ * transcript draws nothing, so the window must not spend one of its slots on an
+ * entry that is not on screen. THE PRINT PUMP AND THE BOX MUST AGREE ABOUT SLOTS:
+ * so both window functions below skip it, and `LiveTail.selectTailEntries` - the
+ * window function the box renders - imports this one instead of spelling the
+ * composition out a second time.
+ */
+export declare function isSlotless(entry: Entry): boolean;
 export interface TailWindow {
     /** First index of the window inside the full entry list. */
     start: number;

package/dist/ui/scrollback/tail-window.js

@@ -27,6 +27,21 @@
  * closes, and `/perf`'s `window=<start>/<n> head=<rows>` is how it stays observable.
  */
 import { isExcluded, settledCount } from './settled-boundary.js';
+import { isLiveTeamCard } from '../team-status.js';
+/**
+ * Entries that take NO slot in the window: they neither print nor take a row.
+ *
+ * A LIVE DISPATCH CARD JOINS THE NON-TERMINAL SERVICE CARD HERE
+ * (tui-subagent-double-roster A-2'): the roster draws the live dispatch and the
+ * transcript draws nothing, so the window must not spend one of its slots on an
+ * entry that is not on screen. THE PRINT PUMP AND THE BOX MUST AGREE ABOUT SLOTS:
+ * so both window functions below skip it, and `LiveTail.selectTailEntries` - the
+ * window function the box renders - imports this one instead of spelling the
+ * composition out a second time.
+ */
+export function isSlotless(entry) {
+    return isExcluded(entry) || isLiveTeamCard(entry);
+}
 /**
  * The index of the first entry that is still on screen: count backwards up to
  * `maxEntries` PRINTABLE entries. Everything before it has left the region and is the
@@ -42,7 +57,7 @@ export function tailWindowStart(entries, maxEntries) {
         return entries.length;
     let seen = 0;
     for (let i = entries.length - 1; i >= 0; i -= 1) {
-        if (isExcluded(entries[i]))
+        if (isSlotless(entries[i]))
             continue;
         seen += 1;
         if (seen === limit)
@@ -54,7 +69,7 @@ export function tailWindowStart(entries, maxEntries) {
 /** `entries.slice(start)` with the entries that never print dropped. */
 export function selectTailWindow(entries, maxEntries) {
     const start = tailWindowStart(entries, maxEntries);
-    return { start, entries: entries.slice(start).filter((entry) => !isExcluded(entry)) };
+    return { start, entries: entries.slice(start).filter((entry) => !isSlotless(entry)) };
 }
 /**
  * The print boundary: never print what the region is still showing.