@aragon-agent/cli 0.6.45 → 0.6.46

package/dist/commands/subagent-command.js

@@ -17,7 +17,7 @@
  * file therefore holds ONE delegation and one line of deprecation text, and
  * `subagent-command.test.ts` asserts both (I-8).
  */
-import { runTeamCommand } from './team-command.js';
+import { runTeamCommand, teamRendersInvocationCard } from './team-command.js';
 /**
  * Run `/team`, having first said out loud that this is the same thing.
  *
@@ -33,6 +33,8 @@ export function runSubagentCommand(ctx) {
 export function registerSubagentCommand(registry) {
     registry.register({
         name: 'subagent',
+        // A fresh object inherits nothing from `/team`: reference the SAME predicate (RV-5).
+        rendersInvocationCard: teamRendersInvocationCard,
         description: 'Deprecated alias of /team - same arguments',
         run: (ctx) => { runSubagentCommand(ctx); },
     });

package/dist/commands/team-command.d.ts

@@ -43,6 +43,12 @@
  * `Team 4` chip would wait for an unrelated state change before appearing.
  */
 import type { CommandContext, CommandRegistry } from './registry.js';
+/**
+ * Whether `/team <args>` ends in a card. The SAME function the command branches on
+ * (`readTeamIntent`), and shared by `/team` and the `/subagent` alias by reference: the
+ * alias builds a fresh object and inherits nothing (RV-5, I-8).
+ */
+export declare function teamRendersInvocationCard(args: string): boolean;
 /** The command body; `registerTeamCommand` is the only registration site. */
 export declare function runTeamCommand(ctx: CommandContext): void;
 /** Registered from `builtins.ts` with one line, next to every other subsystem. */

package/dist/commands/team-command.js

@@ -43,7 +43,7 @@
  * `Team 4` chip would wait for an unrelated state change before appearing.
  */
 import { buildForcedDirective } from '../team/forced-dispatch.js';
-import { DEFAULT_FORCED_COUNT, planForced, planNotice, readTeamIntent, } from '../team/forced-mode.js';
+import { DEFAULT_FORCED_COUNT, forcedCardNote, planForced, planNotice, readTeamIntent, } from '../team/forced-mode.js';
 import { subagentModelSummary } from '../ui/overlays/model-profile-state.js';
 /**
  * The subagent model line, phrased by the same authority the settings root row
@@ -199,6 +199,34 @@ function enterForcedMode(ctx) {
     ctx.notify('info', `Forced team mode on: ${adopted} subagents per turn. `
         + 'Your next message dispatches.');
 }
+/**
+ * The card's raw material for `/team <brief>` (tui-invocation-cards section 3.3). The
+ * command line is always spelled `/team`, even when the user came in through the
+ * deprecated `/subagent` alias: the card names the canonical command.
+ */
+function forcedCardInput(args, planned, note, ctx) {
+    const noun = planned.count === 1 ? 'subagent' : 'subagents';
+    const facts = [
+        planned.parts.length > 0 ? `parts ${planned.parts.join(', ')}` : `${planned.count} ${noun}`,
+        ...(planned.readOnly ? ['read-only'] : []),
+        ...(ctx.controller.getAgentMode() === 'plan' ? ['plan mode'] : []),
+    ];
+    return {
+        variant: 'team',
+        commandLine: args === '' ? '/team' : `/team ${args}`,
+        input: planned.brief,
+        facts,
+        ...(note !== undefined ? { note } : {}),
+    };
+}
+/**
+ * Whether `/team <args>` ends in a card. The SAME function the command branches on
+ * (`readTeamIntent`), and shared by `/team` and the `/subagent` alias by reference: the
+ * alias builds a fresh object and inherits nothing (RV-5, I-8).
+ */
+export function teamRendersInvocationCard(args) {
+    return readTeamIntent(args).kind === 'brief';
+}
 /** `/team [-n n|--parts a,b] [--read-only] <brief>`: arm and submit in one act. */
 function armAndSubmit(ctx, intent) {
     const team = ctx.controller.getTeamConfig();
@@ -209,7 +237,11 @@ function armAndSubmit(ctx, intent) {
     // directive names: the later turns reuse this count, so the first turn and the
     // rest of the session cannot disagree about how wide the fan-out is (D-7).
     ctx.controller.armForcedTeam(planned.count);
-    ctx.notify('info', planNotice(planned, team));
+    // With cards on, the disclosure rides on the card (`forcedCardNote`, same source as
+    // `planNotice`); with them off this is the pre-card notice, byte for byte.
+    const cards = ctx.invocationCards !== false;
+    if (!cards)
+        ctx.notify('info', planNotice(planned, team));
     const directive = buildForcedDirective({
         brief: planned.brief,
         count: planned.count,
@@ -222,7 +254,11 @@ function armAndSubmit(ctx, intent) {
     });
     // `userInitiated: false`: a directive the user did not type belongs in neither
     // the prompt history nor the hint-fade counter (todo-plan-followthrough C-12).
-    ctx.submit(directive, { userInitiated: false });
+    const note = forcedCardNote(planned, team);
+    ctx.submit(directive, {
+        userInitiated: false,
+        ...(cards ? { invocation: forcedCardInput(ctx.args, planned, note, ctx) } : {}),
+    });
 }
 /** The command body; `registerTeamCommand` is the only registration site. */
 export function runTeamCommand(ctx) {
@@ -253,6 +289,7 @@ export function runTeamCommand(ctx) {
 export function registerTeamCommand(registry) {
     registry.register({
         name: 'team',
+        rendersInvocationCard: teamRendersInvocationCard,
         description: 'Force team mode and start now: /team <brief>; /team [on|off|status]',
         run: (ctx) => { runTeamCommand(ctx); },
     });

package/dist/session/persist.js

@@ -9,6 +9,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { getSessionsDir } from '../config/store.js';
 import { stripEphemeralRuns } from '../team/settled.js';
+import { sanitizeInvocationCard } from '../agent/invocation-card.js';
 import { validateSession } from './validate-session.js';
 import { validateCompactionIdentity, verifyCompactionIdentity, } from '../compaction/memory-identity.js';
 import { getLogger } from '../logging/logger.js';
@@ -227,6 +228,15 @@ export function normalizeLoadedEntries(entries) {
         // THE ID IS KEPT: `restoreEntries` splices these positions into the
         // live transcript, and a fresh id here would collide with the next
         // `e<n>` the reducer allocates.
+        if (entry.kind === 'user' && 'invocation' in entry) {
+            // THE EIGHTH CLAUSE (tui-invocation-cards I-7). A session file is user-editable
+            // and `shape()` ignores undeclared fields, so a card arrives unchecked. Repair
+            // what can be repaired; a card that cannot be is dropped and the entry degrades
+            // to a plain user message - a corrupt card must never cost the session.
+            const { invocation: stored, ...plain } = entry;
+            const card = sanitizeInvocationCard(stored);
+            return card ? { ...plain, invocation: card } : plain;
+        }
         if (entry.kind === 'queued') {
             const downgraded = {
                 id: entry.id,

package/dist/session/validate-session.js

@@ -145,14 +145,16 @@ const subagent = shape({
     retry: optional(shape({ attempt: number, maxRetries: number })),
 });
 const ENTRY_FIELDS = {
-    user: { text: string },
+    // `invocation` is declared for self-description only: `shape()` ignores undeclared
+    // fields, and `normalizeLoadedEntries` repairs or drops a bad card (tui-invocation-cards).
+    user: { text: string, invocation: optional(() => { }) },
     // A GOVERNANCE CARD IS HISTORY, so it is validated LENIENTLY (governance-mode 10.4):
     // unknown fields are ignored (`shape` only reads the declared ones) and `card` is not
     // shape-checked here at all - `sanitizeGovernanceEntries` below repairs a card it can
     // and degrades one it cannot to a one-line notice, so a corrupt footnote never costs
     // the session. `at` is advisory.
     governance: { at: optional(number), card: () => { } },
-    queued: { text: string, queueId: optional(nonempty) },
+    queued: { text: string, queueId: optional(nonempty), invocation: optional(() => { }) },
     notice: { text: string, level: enumeration('info', 'warn', 'error') },
     assistant: {
         text: string, thinking: optional(string), thinkingOpen: boolean, streaming: boolean,

package/dist/team/forced-mode.d.ts

@@ -106,6 +106,19 @@ export interface ForcedPlan {
  * can apply, because only it can read the live config.
  */
 export declare function planForced(args: SubagentCommandArgs, team: TeamConfig): ForcedPlan;
+/**
+ * The parenthesised disclosure sentence of the plan notice - why the fan-out is not what
+ * the user typed - or `null` when nothing was narrowed.
+ *
+ * SHARED BY `planNotice` AND `forcedCardNote` (tui-invocation-cards RV-4): the notice and
+ * the transcript card must word the same fact the same way, so there is exactly one
+ * place that decides it.
+ *
+ * TWO CEILINGS, TWO SENTENCES. `forcedPartsMax` bounds what one argument may carry and
+ * `team.maxSubagents` bounds what may be dispatched; naming the wrong one sends the user
+ * to change a number that is not the reason.
+ */
+export declare function clampDisclosure(planned: ForcedPlan, team: TeamConfig): string | null;
 /**
  * The one line that says what the NEXT turn will do - a plan, not a result.
  *
@@ -114,3 +127,9 @@ export declare function planForced(args: SubagentCommandArgs, team: TeamConfig):
  * said "4 subagents started" would be a promise the command cannot keep.
  */
 export declare function planNotice(planned: ForcedPlan, team: TeamConfig): string;
+/**
+ * The card's `note`: the same disclosure, as a sentence. `undefined` when nothing was
+ * narrowed - the "Esc stops the turn" follow-up is an operating hint the status bar
+ * carries, not a fact about this invocation.
+ */
+export declare function forcedCardNote(planned: ForcedPlan, team: TeamConfig): string | undefined;

package/dist/team/forced-mode.js

@@ -123,34 +123,56 @@ export function planForced(args, team) {
     };
 }
 /**
- * The one line that says what the NEXT turn will do - a plan, not a result.
+ * The parenthesised disclosure sentence of the plan notice - why the fan-out is not what
+ * the user typed - or `null` when nothing was narrowed.
  *
- * IT IS PRINTED BEFORE THE TURN IS SUBMITTED and it never claims children
- * started: forcing is instruction-level for the first turn, and a notice that
- * said "4 subagents started" would be a promise the command cannot keep.
+ * SHARED BY `planNotice` AND `forcedCardNote` (tui-invocation-cards RV-4): the notice and
+ * the transcript card must word the same fact the same way, so there is exactly one
+ * place that decides it.
+ *
+ * TWO CEILINGS, TWO SENTENCES. `forcedPartsMax` bounds what one argument may carry and
+ * `team.maxSubagents` bounds what may be dispatched; naming the wrong one sends the user
+ * to change a number that is not the reason.
  */
-export function planNotice(planned, team) {
-    const noun = planned.count === 1 ? 'subagent' : 'subagents';
-    const head = `Forcing a fan-out of ${planned.count} ${noun}`;
-    const followUp = `${head} (max ${team.maxSubagents}) - the next turn dispatches them. `
-        + 'Esc stops the turn.';
-    // TWO CEILINGS, TWO SENTENCES. `forcedPartsMax` bounds what one argument may
-    // carry and `team.maxSubagents` bounds what may be dispatched; naming the wrong
-    // one sends the user to change a number that is not the reason.
+export function clampDisclosure(planned, team) {
     if (planned.parts.length > 0) {
         if (planned.parts.length < planned.partsAdmitted) {
-            return `${head} (asked for ${planned.partsRequested} parts; `
-                + `team.maxSubagents is ${team.maxSubagents}).`;
+            return `asked for ${planned.partsRequested} parts; team.maxSubagents is ${team.maxSubagents}`;
         }
         if (planned.partsAdmitted < planned.partsRequested) {
-            return `${head} (asked for ${planned.partsRequested} parts, `
-                + `the first ${planned.parts.length} are used).`;
+            return `asked for ${planned.partsRequested} parts, the first ${planned.parts.length} are used`;
         }
-        return followUp;
+        return null;
     }
     if (planned.requested > planned.count) {
-        return `${head} (asked for ${planned.requested}; `
-            + `team.maxSubagents is ${team.maxSubagents}).`;
+        return `asked for ${planned.requested}; team.maxSubagents is ${team.maxSubagents}`;
     }
-    return followUp;
+    return null;
+}
+/**
+ * The one line that says what the NEXT turn will do - a plan, not a result.
+ *
+ * IT IS PRINTED BEFORE THE TURN IS SUBMITTED and it never claims children
+ * started: forcing is instruction-level for the first turn, and a notice that
+ * said "4 subagents started" would be a promise the command cannot keep.
+ */
+export function planNotice(planned, team) {
+    const noun = planned.count === 1 ? 'subagent' : 'subagents';
+    const head = `Forcing a fan-out of ${planned.count} ${noun}`;
+    const disclosure = clampDisclosure(planned, team);
+    if (disclosure !== null)
+        return `${head} (${disclosure}).`;
+    return `${head} (max ${team.maxSubagents}) - the next turn dispatches them. `
+        + 'Esc stops the turn.';
+}
+/**
+ * The card's `note`: the same disclosure, as a sentence. `undefined` when nothing was
+ * narrowed - the "Esc stops the turn" follow-up is an operating hint the status bar
+ * carries, not a fact about this invocation.
+ */
+export function forcedCardNote(planned, team) {
+    const disclosure = clampDisclosure(planned, team);
+    if (disclosure === null)
+        return undefined;
+    return `${disclosure.charAt(0).toUpperCase()}${disclosure.slice(1)}.`;
 }

package/dist/ui/App.js

@@ -92,7 +92,8 @@ import { SettingsScreen, compactionSettingsFrom, fastSettingsFrom, } from './ove
 import { ConfirmDialog } from './overlays/ConfirmDialog.js';
 import { QuestionOverlay } from './overlays/QuestionOverlay.js';
 import { PlanReviewOverlay } from './overlays/PlanReviewOverlay.js';
-import { CommandRegistry, runSlashInput } from '../commands/registry.js';
+import { CommandRegistry, parseSlashInput, runSlashInput, } from '../commands/registry.js';
+import { buildInvocationCard, invocationCardsEnabled } from '../agent/invocation-card.js';
 import { registerBuiltinCommands } from '../commands/builtins.js';
 import { makeSkillsCommand, registerSkillCommands } from '../commands/skills.js';
 import { MODE_TOGGLE_KEYS } from '../agent/agent-mode.js';
@@ -1942,8 +1943,10 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             dispatch({ type: 'taskSummaryReady', view: outcome.view });
         });
     };
+    const invocationCardsOn = invocationCardsEnabled();
     const makeCtx = (args) => ({
         args,
+        invocationCards: invocationCardsOn,
         requestCopy: copyCoordinator.requestCopy,
         controller,
         state: stateRef.current,
@@ -2121,10 +2124,17 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // must be the one that runs, whichever branch it takes.
         cancelFollowThrough();
         cancelConfirmation();
+        // THE ONE PLACE A CARD IS BUILT (tui-invocation-cards I-3 / I-6): redact -> normalise ->
+        // limit, with the same redactor the `Command:` echo uses. `message` below is the model's
+        // input and is never touched; the card only replaces what the TRANSCRIPT shows.
+        const card = invocationCardsOn && opts.invocation
+            ? buildInvocationCard(opts.invocation, (text) => redactText(text, getSecrets()))
+            : undefined;
+        const shown = card?.commandLine ?? message;
         if (interactionPhase.current === 'running' || controller.isCompactionBusy?.()) {
             try {
                 const queueId = controller.queueUserMessage(message);
-                dispatch({ type: 'steerQueued', queueId, text: message });
+                dispatch({ type: 'steerQueued', queueId, text: shown, ...(card ? { invocation: card } : {}) });
                 return { accepted: true };
             }
             catch (error) {
@@ -2143,7 +2153,10 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // the user has learned, so suppressing the fade is correct rather than
         // incidental — which is why the parameter is named for the CAUSE (P2-8).
         if (opts.userInitiated !== false) {
-            recordPrompt(message);
+            // A card's command line was already recorded by `executeSlashInput`; the payload
+            // behind it must never reach the up-arrow history (I-9: the gate is unchanged).
+            if (!card)
+                recordPrompt(message);
             // THE ONE PLACE THE NUDGE BUDGET IS REFILLED (P0-2 / I-10). Same predicate
             // as `recordPrompt`, and for the same reason: the question is "did a human
             // ask for this?", and only a human may hand the gate another attempt. A
@@ -2154,7 +2167,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // Mirrors where the reducer clears its own copies, in the same action
         // (C-11): a new turn's end reason must not inherit the previous one's.
         endReasonRef.current = { aborted: false, errored: false };
-        dispatch({ type: 'submit', text: message });
+        dispatch({ type: 'submit', text: shown, ...(card ? { invocation: card } : {}) });
         const pre = controller.preflight();
         if (!pre.ok) {
             dispatch({ type: 'runError' });
@@ -2174,7 +2187,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // model call that describes a turn nobody ran; and below, in the queueing
         // branch, the message is steering rather than a new task.
         if (opts.userInitiated !== false)
-            ensureTaskSummary(message);
+            ensureTaskSummary(shown);
         void controller.prompt(message, { todoPolicy: opts.todoPolicy ?? 'new-task' }).then((outcome) => {
             if (!mounted.current || sequence !== submissionSequence.current)
                 return;
@@ -2213,7 +2226,13 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // Retain a recoverable command before any asynchronous handler can fail.
         const safe = redactText(raw, getSecrets());
         recordPrompt(safe);
-        notify('info', `Command: ${safe}`);
+        // The echo is suppressed BEFORE the command runs and never deleted afterwards: printed
+        // scrollback rows cannot be rewritten (I-5). The predicate is the command's own (I-8).
+        const parsed = parseSlashInput(raw);
+        const rendersCard = invocationCardsOn && parsed !== null
+            && registry.get(parsed.name)?.rendersInvocationCard?.(parsed.args) === true;
+        if (!rendersCard)
+            notify('info', `Command: ${safe}`);
         try {
             await runSlashInput(registry, raw, makeCtx);
         }

package/dist/ui/Transcript.js

@@ -8,6 +8,7 @@ import { pickGlyphs, toolGlyph } from './glyphs.js';
 import { separationRows } from './density.js';
 import { EntryFrame } from './entries/EntryFrame.js';
 import { UserEntry } from './entries/UserEntry.js';
+import { InvocationCard } from './entries/InvocationCard.js';
 import { QueuedEntry } from './entries/QueuedEntry.js';
 import { AssistantEntry } from './entries/AssistantEntry.js';
 import { ToolCard, statusColor, toolEntryGlyph } from './entries/ToolCard.js';
@@ -78,7 +79,9 @@ function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion,
     const frame = (glyph, color, children) => (_jsx(EntryFrame, { glyph: glyph, color: color, continuation: glyphs.railVertical, separation: separation, spacerColor: theme.border, children: children }));
     switch (entry.kind) {
         case 'user':
-            return frame(glyphs.user, theme.user, _jsx(UserEntry, { text: entry.text, theme: theme, caps: caps }));
+            return frame(glyphs.user, theme.user, entry.invocation
+                ? _jsx(InvocationCard, { card: entry.invocation, theme: theme, caps: caps })
+                : _jsx(UserEntry, { text: entry.text, theme: theme, caps: caps }));
         case 'queued':
             // `theme.muted`: quieter than a user message, louder than a notice --
             // the row exists to be noticed UNTIL it is accepted, then rewritten in

package/dist/ui/entries/InvocationCard.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Render a `user` entry that carries an invocation card (tui-invocation-cards).
+ *
+ * Like `UserEntry`, this renders CONTENT only: the role glyph, rail and spacing belong
+ * to `EntryFrame`, so the card stays "the user's turn" for density, turn counting and
+ * the settled boundary. The header text comes from `invocationHeaderSegments` and is
+ * never assembled here (RV-10); the row count it implies is `invocationCardRows`.
+ */
+import React from 'react';
+import type { Theme } from '../theme.js';
+import type { TermCapabilities } from '../capabilities.js';
+import type { InvocationCard as InvocationCardData } from '../../agent/invocation-card.js';
+declare function InvocationCardImpl({ card, theme, caps, }: {
+    card: InvocationCardData;
+    theme: Theme;
+    caps: TermCapabilities;
+}): React.ReactElement;
+/** Default comparator: `mapEntry` preserves identity for untouched entries (L2 / R3). */
+export declare const InvocationCard: React.MemoExoticComponent<typeof InvocationCardImpl>;
+export {};

package/dist/ui/entries/InvocationCard.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Render a `user` entry that carries an invocation card (tui-invocation-cards).
+ *
+ * Like `UserEntry`, this renders CONTENT only: the role glyph, rail and spacing belong
+ * to `EntryFrame`, so the card stays "the user's turn" for density, turn counting and
+ * the settled boundary. The header text comes from `invocationHeaderSegments` and is
+ * never assembled here (RV-10); the row count it implies is `invocationCardRows`.
+ */
+import React from 'react';
+import { Box, Text } from 'ink';
+import { pickGlyphs } from '../glyphs.js';
+import { invocationHeaderSegments, invocationHiddenText, invocationInputText, } from '../layout/invocation-card.js';
+import { GUTTER_WIDTH } from '../layout/Gutter.js';
+import { useTerminalSize } from '../layout/useTerminalSize.js';
+import { fitCells } from '../layout/cells.js';
+function toneColor(tone, theme) {
+    if (tone === 'label')
+        return theme.accent;
+    if (tone === 'name')
+        return theme.user;
+    return theme.muted;
+}
+function InvocationCardImpl({ card, theme, caps, }) {
+    const glyphs = pickGlyphs(caps);
+    const { cols } = useTerminalSize();
+    const usable = Math.max(1, cols - GUTTER_WIDTH);
+    const header = invocationHeaderSegments(card, glyphs, usable);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { wrap: "truncate", children: header.map((part, index) => (_jsx(Text, { color: toneColor(part.tone, theme), bold: part.bold, children: part.text }, index))) }), card.input !== '' && _jsx(Text, { color: theme.user, children: invocationInputText(card) }), card.inputHidden > 0 && (_jsx(Text, { color: theme.muted, wrap: "truncate", children: invocationHiddenText(card, glyphs) })), card.note !== undefined && card.note !== '' && (_jsx(Text, { color: theme.muted, wrap: "truncate", children: fitCells(card.note, usable, glyphs.ellipsis) }))] }));
+}
+/** Default comparator: `mapEntry` preserves identity for untouched entries (L2 / R3). */
+export const InvocationCard = React.memo(InvocationCardImpl);

package/dist/ui/layout/invocation-card.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Invocation card layout (tui-invocation-cards section 3.7): what a `user` entry that
+ * carries an `invocation` says, as pure data. No Ink, no React. ASCII ONLY.
+ *
+ * THE CARD'S HEIGHT IS A FUNCTION OF ITS DATA AND THE USABLE WIDTH (I-4).
+ * `InvocationCard.tsx` renders exactly the rows `invocationCardRows` counts, and both
+ * read `INVOCATION_LIMITS` plus the one `invocationInputText` below - an estimate that
+ * disagrees with the painter is permanent, because an over-estimated entry is never
+ * mounted and so never measured (see `virtual-window.ts`).
+ */
+import type { InvocationCard } from '../../agent/invocation-card.js';
+import type { Glyphs } from '../glyphs.js';
+/** Colour slots the component maps onto the theme; kept local so this file needs no `Theme`. */
+export type InvocationTone = 'label' | 'name' | 'muted';
+export interface InvocationSegment {
+    text: string;
+    tone: InvocationTone;
+    bold: boolean;
+}
+/**
+ * The header row, already fitted to `usable` columns (RV-10). Narrow terminals drop
+ * facts from the right WHOLE before anything else is cut; only when the identity alone
+ * is too wide is the name shortened. Ink's `wrap="truncate"` stays on the row as a
+ * backstop, but it is never what produces the visible ellipsis.
+ */
+export declare function invocationHeaderSegments(card: InvocationCard, glyphs: Glyphs, usable: number): InvocationSegment[];
+/** The text painted for `input`: tabs expanded per line, the same rule `UserEntry` follows. */
+export declare function invocationInputText(card: InvocationCard): string;
+/** Singular/plural for the hidden-characters tail. */
+export declare function invocationHiddenText(card: InvocationCard, glyphs: Glyphs): string;
+/**
+ * Rows the card occupies at `usable` columns. `wrappedRows` is injected by the caller
+ * (`virtual-window.ts` owns the one wrapping rule) so this file stays import-cycle free.
+ */
+export declare function invocationCardRows(card: InvocationCard, usable: number, wrappedRows: (text: string, usable: number) => number): number;
+/**
+ * The lines the exit replay / export prints UNDER the command line (section 2.4):
+ * a bracketed fact line, and the disclosure note when there is one. Plain ASCII
+ * separators - the replay is pasted into issues and must survive any terminal.
+ */
+export declare function invocationCardLines(card: InvocationCard): string[];

package/dist/ui/layout/invocation-card.js

@@ -0,0 +1,91 @@
+/**
+ * Invocation card layout (tui-invocation-cards section 3.7): what a `user` entry that
+ * carries an `invocation` says, as pure data. No Ink, no React. ASCII ONLY.
+ *
+ * THE CARD'S HEIGHT IS A FUNCTION OF ITS DATA AND THE USABLE WIDTH (I-4).
+ * `InvocationCard.tsx` renders exactly the rows `invocationCardRows` counts, and both
+ * read `INVOCATION_LIMITS` plus the one `invocationInputText` below - an estimate that
+ * disagrees with the painter is permanent, because an over-estimated entry is never
+ * mounted and so never measured (see `virtual-window.ts`).
+ */
+import { expandTabs } from '../display-tab.js';
+import { cellWidth, fitCells } from './cells.js';
+/** Two spaces between the identity (`skill . pdf-forms`) and the facts. */
+const FACT_GAP = '  ';
+function seg(text, tone, bold = false) {
+    return { text, tone, bold };
+}
+function segmentsWidth(segments) {
+    return segments.reduce((sum, part) => sum + cellWidth(part.text), 0);
+}
+function identitySegments(card, glyphs, name) {
+    const parts = [seg(card.variant, 'label', true)];
+    if (name !== '')
+        parts.push(seg(` ${glyphs.midDot} `, 'muted'), seg(name, 'name', true));
+    return parts;
+}
+function factSegments(facts, glyphs) {
+    if (facts.length === 0)
+        return [];
+    const parts = [seg(FACT_GAP, 'muted')];
+    facts.forEach((fact, index) => {
+        if (index > 0)
+            parts.push(seg(` ${glyphs.midDot} `, 'muted'));
+        parts.push(seg(fact, 'muted'));
+    });
+    return parts;
+}
+/**
+ * The header row, already fitted to `usable` columns (RV-10). Narrow terminals drop
+ * facts from the right WHOLE before anything else is cut; only when the identity alone
+ * is too wide is the name shortened. Ink's `wrap="truncate"` stays on the row as a
+ * backstop, but it is never what produces the visible ellipsis.
+ */
+export function invocationHeaderSegments(card, glyphs, usable) {
+    const width = Math.max(1, Math.floor(usable));
+    for (let kept = card.facts.length; kept >= 0; kept -= 1) {
+        const candidate = [
+            ...identitySegments(card, glyphs, card.name),
+            ...factSegments(card.facts.slice(0, kept), glyphs),
+        ];
+        if (segmentsWidth(candidate) <= width)
+            return candidate;
+    }
+    const head = identitySegments(card, glyphs, '');
+    const room = width - segmentsWidth(head) - cellWidth(` ${glyphs.midDot} `);
+    if (card.name !== '' && room > 1) {
+        return identitySegments(card, glyphs, fitCells(card.name, room, glyphs.ellipsis));
+    }
+    return [seg(fitCells(card.variant, width, glyphs.ellipsis), 'label', true)];
+}
+/** The text painted for `input`: tabs expanded per line, the same rule `UserEntry` follows. */
+export function invocationInputText(card) {
+    return card.input.split('\n').map((line) => expandTabs(line)).join('\n');
+}
+/** Singular/plural for the hidden-characters tail. */
+export function invocationHiddenText(card, glyphs) {
+    const unit = card.inputHidden === 1 ? 'char' : 'chars';
+    return `${glyphs.ellipsis} +${card.inputHidden} ${unit} not shown`;
+}
+/**
+ * Rows the card occupies at `usable` columns. `wrappedRows` is injected by the caller
+ * (`virtual-window.ts` owns the one wrapping rule) so this file stays import-cycle free.
+ */
+export function invocationCardRows(card, usable, wrappedRows) {
+    const inputRows = card.input === '' ? 0 : wrappedRows(invocationInputText(card), usable);
+    return 1 + inputRows + (card.inputHidden > 0 ? 1 : 0) + (card.note ? 1 : 0);
+}
+const REPLAY_INDENT = '    ';
+/**
+ * The lines the exit replay / export prints UNDER the command line (section 2.4):
+ * a bracketed fact line, and the disclosure note when there is one. Plain ASCII
+ * separators - the replay is pasted into issues and must survive any terminal.
+ */
+export function invocationCardLines(card) {
+    const identity = card.name === '' ? card.variant : `${card.variant} ${card.name}`;
+    const detail = card.facts.length === 0 ? identity : `${identity} ${card.facts.join(' - ')}`;
+    const lines = [`${REPLAY_INDENT}[${detail}]`];
+    if (card.note)
+        lines.push(`${REPLAY_INDENT}${card.note}`);
+    return lines;
+}

package/dist/ui/layout/virtual-window.js

@@ -40,6 +40,7 @@ import { GUTTER_WIDTH } from './Gutter.js';
 import { expandTabs } from '../display-tab.js';
 import { USER_ENTRY_MAX_ROWS } from '../composer-limits.js';
 import { isLiveTeamCard } from '../team-status.js';
+import { invocationCardRows } from './invocation-card.js';
 export const VIRTUAL_LIMITS = {
     /**
      * Entries kept mounted on each side of the visible band.
@@ -68,8 +69,12 @@ export const VIRTUAL_LIMITS = {
  */
 export function entryRevision(entry) {
     switch (entry.kind) {
+        // A card's shape is fixed at creation; the suffix only tells "card" from "plain" (and
+        // the three row-bearing parts), which is what makes a `queued -> user` rewrite re-measure.
         case 'user':
-            return 'u';
+            return entry.invocation
+                ? `i${entry.invocation.input.length}.${entry.invocation.inputHidden > 0 ? 1 : 0}.${entry.invocation.note ? 1 : 0}`
+                : 'u';
         case 'notice':
             return 'n';
         // `thinkingMs` is O(1) and it CHANGES THE ROW: sealing the clock turns
@@ -259,6 +264,11 @@ export function estimateEntryRows(entry, cols, density, expanded, thinkingVisibl
     const separation = density === 'comfortable' ? 1 : 0;
     switch (entry.kind) {
         case 'user':
+            // A CARD HAS ITS OWN, BOUNDED HEIGHT (tui-invocation-cards I-4): the same
+            // `invocationCardRows` the painter is built from, never the command line's wrapped rows.
+            if (entry.invocation) {
+                return separation + invocationCardRows(entry.invocation, usable, wrappedRows);
+            }
             // MIRRORS `UserEntry`'s RENDER CAP (+1 for the `... +N more lines` tail).
             // THESE TWO NUMBERS ARE ONE NUMBER (I-13). Capping the renderer alone
             // would leave this function believing a 5 000-line message is 5 000 rows

package/dist/ui/transcript-text.js

@@ -3,6 +3,7 @@ import { formatRetryLine } from '../agent/retry-view.js';
 import { childStatus, outcomePhrase, rosterCounts, statusMarkerCell } from './team-status.js';
 import { expandTabs } from './display-tab.js';
 import { governanceCardLines } from './layout/governance-card.js';
+import { invocationCardLines } from './layout/invocation-card.js';
 const DEFAULT_MAX_ENTRIES = 200;
 const CONTINUATION_INDENT = '  ';
 const TOOL_INDENT = '  ';
@@ -87,7 +88,9 @@ function renderEntry(entry, glyphs) {
         case 'queued':
             return block('Queued but never sent:', entry.text);
         case 'user':
-            return block(glyphs.user, entry.text);
+            return entry.invocation
+                ? [...block(glyphs.user, entry.text), ...invocationCardLines(entry.invocation)]
+                : block(glyphs.user, entry.text);
         case 'assistant': {
             const suffix = entry.aborted ? ' (aborted)' : '';
             return block(glyphs.assistant, `${entry.text}${suffix}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aragon-agent/cli",
-  "version": "0.6.45",
+  "version": "0.6.46",
   "description": "AragonAgent CLI — a Claude-Code / Codex-style interactive terminal UI (TUI) on top of the @aragon-agent/core engine. Installable and runnable via npm / npx.",
   "license": "MIT",
   "author": "AragonAgent contributors",
@@ -56,7 +56,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@aragon-agent/core": "^0.2.57",
+    "@aragon-agent/core": "^0.2.58",
     "chalk": "^5.6.2",
     "cli-highlight": "^2.0.0",
     "commander": "^12.1.0",