@aragon-agent/cli 0.6.45 → 0.6.46

package/README.md

@@ -3013,6 +3013,57 @@ declares no placeholder, the arguments are appended under an `## Arguments`
 heading instead. Where a skill's name collides with a built-in command, the
 **built-in wins** and the skill is reachable as `/skill:<name>`.
 
+### Invocation cards
+
+A command that starts a task by submitting a long prompt on your behalf does not
+print that prompt. `/pdf-forms`, `/skill:<name>`, `/team <brief>`, `/todo continue`
+and `/gov resume` each leave one **card** in the transcript instead: what you
+started, a few facts, and your own words.
+
+```
+> skill . pdf-forms  v1.2.0 . user . 31 KB . 4 files
+  Fill the W-9 form in ./tax/w9.pdf with the values from data.json
+
+> team  4 subagents . read-only
+  Audit the auth module for session fixation and add regression tests
+  Asked for 12; team.maxSubagents is 8.
+
+> todo . continue  3 of 7 steps left
+```
+
+(`.` is `·` on a Unicode terminal.) The first row names the command and its
+facts and is shortened to the width of the window - facts go first, then the name.
+Your own words follow, capped at 8 lines / 480 characters with an honest
+`... +N chars not shown` tail. A line below it appears only when the command
+changed what you asked for (a fan-out above `team.maxSubagents`). `Ctrl+I` shows a
+`ctrl+i` fact and no input row: the sentence it sends the model is not something
+you said.
+
+What changes and what does not:
+
+- **The model receives exactly the bytes it did before.** Only the transcript
+  entry is different; the skill body, the team directive and the continuation text
+  are untouched.
+- The `Command:` echo and the old `Skill "x" loaded (...)` / `Forcing a fan-out...`
+  notices are folded into the card, so one act is stated once.
+- Up-arrow history and the header task label hold the command you typed
+  (`/skill:pdf-forms a.pdf`), not the prompt behind it. Canned turns the commands
+  submit for you (`/team`, `/todo continue`, `/gov resume`) still stay out of
+  history and do not trigger a task label, exactly as before.
+- A skill run now adds one history entry instead of two to the hint-fade counter.
+- Secrets in your arguments are redacted **before** anything is cut, so a key that
+  straddles a cut cannot leave a readable prefix in the transcript, the session
+  file or the exit replay.
+- The exit replay prints the command line plus one `[skill pdf-forms v1.2.0 - ...]`
+  line. A very long brief is capped at 2000 characters there; the full text is in
+  the up-arrow history and in the conversation itself.
+- Sessions written before cards existed load unchanged; a damaged card in a session
+  file degrades to the plain command line instead of failing the load.
+
+`ARAGON_NO_INVOCATION_CARDS=1` restores the previous behaviour completely (echo,
+notices and the full prompt in the transcript). It is an emergency switch, not a
+setting.
+
 ### Where skills come from
 
 Four scopes, later ones overriding earlier ones by name:

package/dist/agent/invocation-card.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Invocation cards (tui-invocation-cards): what a transcript shows INSTEAD of the
+ * system prompt a command submitted on the user's behalf.
+ *
+ * Pure and total: no IO, no React, no Ink, nothing but `import type`. ASCII ONLY -
+ * `src/agent/**` new files sit inside the `glyphs.test.ts` scan scope.
+ *
+ * ONE CONSTRUCTOR (I-3). `buildInvocationCard` is the only function that turns raw
+ * command-layer material into a card, `App.submitMessage` is its only caller, and
+ * `sanitizeInvocationCard` (the session-load path) shares its normaliser so a card
+ * written today and a card read back tomorrow cannot drift apart.
+ *
+ * ORDER IS REDACT -> NORMALISE -> LIMIT, and it is the load-bearing part (I-6). Cut
+ * first and a secret that straddles the cut leaves a prefix shorter than the
+ * redaction patterns' minimum length: the half-key sails through into the
+ * transcript, the session file and the exit replay.
+ */
+export type InvocationVariant = 'skill' | 'team' | 'todo' | 'govern';
+/** Everything one card needs; persisted, queued and rendered in this one shape. */
+export interface InvocationCard {
+    readonly variant: InvocationVariant;
+    /** Skill name / 'continue' / 'resume'; '' for team. */
+    readonly name: string;
+    /** What the user typed (or its equivalent), redacted and capped; also `Entry.text`. */
+    readonly commandLine: string;
+    /** The user's own words (args / brief), redacted and trimmed; may be ''. */
+    readonly input: string;
+    /** Characters cut from `input`; 0 when nothing was cut. */
+    readonly inputHidden: number;
+    /** Fact fragments, each at most `factMaxChars`, at most `factsMax` of them. */
+    readonly facts: readonly string[];
+    /** One disclosure sentence. */
+    readonly note?: string;
+}
+/**
+ * The renderer, the height estimate and the loader all read THESE numbers (I-4).
+ * A card's height is a function of its data and these limits, so it is bounded:
+ * header + `inputMaxLines` + hidden tail + note.
+ */
+export declare const INVOCATION_LIMITS: {
+    readonly commandLineMaxChars: 2000;
+    readonly inputMaxChars: 480;
+    readonly inputMaxLines: 8;
+    readonly nameMaxChars: 64;
+    readonly factsMax: 5;
+    readonly factMaxChars: 28;
+    readonly noteMaxChars: 140;
+};
+/**
+ * Raw material from the command layer: NOT redacted, NOT trimmed. Commands must not
+ * cut or scrub it themselves - both happen exactly once, in `buildInvocationCard`.
+ */
+export interface InvocationCardInput {
+    variant: InvocationVariant;
+    name?: string;
+    commandLine: string;
+    input?: string;
+    facts?: readonly string[];
+    note?: string;
+}
+/**
+ * Total, never throws. `redact` is injected (the same closure `Command:` echo uses) so
+ * this module depends on nothing; the default is the identity for tests and the loader.
+ */
+export declare function buildInvocationCard(input: InvocationCardInput, redact?: (text: string) => string): InvocationCard;
+/**
+ * Session-load path: `null` for anything that is not a plausible card, so the caller
+ * drops the field and the entry degrades to a plain user message (I-7). Re-derives
+ * `inputHidden` from nothing - it trusts the stored count only when it is a sane integer.
+ */
+export declare function sanitizeInvocationCard(value: unknown): InvocationCard | null;
+/**
+ * Emergency kill switch (`ARAGON_NO_INVOCATION_CARDS=1`): every command and the App fall
+ * back to the pre-card behaviour. Read at call time, not import time, so a test (or a
+ * wrapper script) that sets the variable after load is honoured.
+ */
+export declare function invocationCardsEnabled(env?: NodeJS.ProcessEnv): boolean;

package/dist/agent/invocation-card.js

@@ -0,0 +1,169 @@
+/**
+ * Invocation cards (tui-invocation-cards): what a transcript shows INSTEAD of the
+ * system prompt a command submitted on the user's behalf.
+ *
+ * Pure and total: no IO, no React, no Ink, nothing but `import type`. ASCII ONLY -
+ * `src/agent/**` new files sit inside the `glyphs.test.ts` scan scope.
+ *
+ * ONE CONSTRUCTOR (I-3). `buildInvocationCard` is the only function that turns raw
+ * command-layer material into a card, `App.submitMessage` is its only caller, and
+ * `sanitizeInvocationCard` (the session-load path) shares its normaliser so a card
+ * written today and a card read back tomorrow cannot drift apart.
+ *
+ * ORDER IS REDACT -> NORMALISE -> LIMIT, and it is the load-bearing part (I-6). Cut
+ * first and a secret that straddles the cut leaves a prefix shorter than the
+ * redaction patterns' minimum length: the half-key sails through into the
+ * transcript, the session file and the exit replay.
+ */
+/**
+ * The renderer, the height estimate and the loader all read THESE numbers (I-4).
+ * A card's height is a function of its data and these limits, so it is bounded:
+ * header + `inputMaxLines` + hidden tail + note.
+ */
+export const INVOCATION_LIMITS = {
+    commandLineMaxChars: 2000,
+    inputMaxChars: 480,
+    inputMaxLines: 8,
+    nameMaxChars: 64,
+    factsMax: 5,
+    factMaxChars: 28,
+    noteMaxChars: 140,
+};
+const VARIANTS = ['skill', 'team', 'todo', 'govern'];
+// C0 except TAB (\x09) and LF (\x0a), then DEL and C1 (which includes the 8-bit CSI
+// \x9b). Matches the range `QueueOverlay` strips, so the card is no more permissive.
+// eslint-disable-next-line no-control-regex
+const CONTROL_CHARS = /[\x00-\x08\x0b-\x1f\x7f-\x9f]/g;
+const CAP_MARK = '...';
+/** Cut at a code-point boundary: a surrogate pair is never split. */
+function sliceCodePoints(text, count) {
+    if (count <= 0)
+        return '';
+    if (text.length <= count)
+        return text;
+    let end = count;
+    const last = text.charCodeAt(end - 1);
+    // A high surrogate at the cut would orphan its low half.
+    if (last >= 0xd800 && last <= 0xdbff)
+        end -= 1;
+    return text.slice(0, end);
+}
+function countCodePoints(text) {
+    let count = 0;
+    for (const _ of text)
+        count += 1;
+    return count;
+}
+/** CRLF and bare CR to LF (a bare CR returns Ink's cursor to column 0), then strip controls. */
+function normalizeText(text) {
+    return text.replace(/\r\n?/g, '\n').replace(CONTROL_CHARS, '');
+}
+function capCommandLine(text) {
+    const max = INVOCATION_LIMITS.commandLineMaxChars;
+    if (text.length <= max)
+        return text;
+    return sliceCodePoints(text, max - CAP_MARK.length) + CAP_MARK;
+}
+function capInput(text) {
+    const trimmed = text.trim();
+    if (trimmed === '')
+        return { input: '', hidden: 0 };
+    const lines = trimmed.split('\n');
+    let kept = lines.length > INVOCATION_LIMITS.inputMaxLines
+        ? lines.slice(0, INVOCATION_LIMITS.inputMaxLines).join('\n') : trimmed;
+    kept = sliceCodePoints(kept, INVOCATION_LIMITS.inputMaxChars).trimEnd();
+    return { input: kept, hidden: countCodePoints(trimmed) - countCodePoints(kept) };
+}
+function capSingleLine(text, max) {
+    const flat = text.replace(/\s+/g, ' ').trim();
+    if (countCodePoints(flat) <= max)
+        return flat;
+    return sliceCodePoints(flat, max - CAP_MARK.length) + CAP_MARK;
+}
+function capFacts(facts) {
+    return facts
+        .map((fact) => capSingleLine(fact, INVOCATION_LIMITS.factMaxChars))
+        .filter((fact) => fact !== '')
+        .slice(0, INVOCATION_LIMITS.factsMax);
+}
+function capNote(note) {
+    if (note === undefined)
+        return undefined;
+    const capped = capSingleLine(note, INVOCATION_LIMITS.noteMaxChars);
+    return capped === '' ? undefined : capped;
+}
+/** Shared by the write path and the load path so the two cannot diverge. */
+function assemble(parts) {
+    const { input, hidden } = capInput(normalizeText(parts.input));
+    const note = capNote(normalizeText(parts.note ?? ''));
+    return {
+        variant: parts.variant,
+        name: capSingleLine(normalizeText(parts.name), INVOCATION_LIMITS.nameMaxChars),
+        commandLine: capCommandLine(normalizeText(parts.commandLine).trim()),
+        input,
+        inputHidden: hidden,
+        facts: capFacts(parts.facts.map(normalizeText)),
+        ...(note !== undefined ? { note } : {}),
+    };
+}
+/**
+ * Total, never throws. `redact` is injected (the same closure `Command:` echo uses) so
+ * this module depends on nothing; the default is the identity for tests and the loader.
+ */
+export function buildInvocationCard(input, redact = (text) => text) {
+    const scrub = (text) => {
+        if (text === undefined)
+            return '';
+        try {
+            return redact(text);
+        }
+        catch {
+            return '';
+        }
+    };
+    return assemble({
+        variant: input.variant,
+        name: scrub(input.name),
+        commandLine: scrub(input.commandLine),
+        input: scrub(input.input),
+        facts: (input.facts ?? []).map((fact) => scrub(fact)),
+        note: input.note === undefined ? undefined : scrub(input.note),
+    });
+}
+function asString(value) {
+    return typeof value === 'string' ? value : null;
+}
+/**
+ * Session-load path: `null` for anything that is not a plausible card, so the caller
+ * drops the field and the entry degrades to a plain user message (I-7). Re-derives
+ * `inputHidden` from nothing - it trusts the stored count only when it is a sane integer.
+ */
+export function sanitizeInvocationCard(value) {
+    if (typeof value !== 'object' || value === null)
+        return null;
+    const raw = value;
+    const variant = VARIANTS.find((candidate) => candidate === raw.variant);
+    const commandLine = asString(raw.commandLine);
+    if (variant === undefined || commandLine === null)
+        return null;
+    const name = asString(raw.name) ?? '';
+    const input = asString(raw.input) ?? '';
+    const facts = Array.isArray(raw.facts)
+        ? raw.facts.filter((fact) => typeof fact === 'string') : [];
+    const note = asString(raw.note) ?? undefined;
+    const card = assemble({ variant, name, commandLine, input, facts, note });
+    // A stored card that was already capped must keep its recorded `inputHidden`; the
+    // re-cap above can only ever add to it.
+    const stored = raw.inputHidden;
+    const storedHidden = typeof stored === 'number' && Number.isInteger(stored) && stored > 0
+        ? Math.min(stored, 10_000_000) : 0;
+    return { ...card, inputHidden: Math.max(card.inputHidden, storedHidden) };
+}
+/**
+ * Emergency kill switch (`ARAGON_NO_INVOCATION_CARDS=1`): every command and the App fall
+ * back to the pre-card behaviour. Read at call time, not import time, so a test (or a
+ * wrapper script) that sets the variable after load is honoured.
+ */
+export function invocationCardsEnabled(env = process.env) {
+    return env.ARAGON_NO_INVOCATION_CARDS !== '1';
+}

package/dist/agent/prompt-options.d.ts

@@ -1,3 +1,4 @@
+import type { InvocationCardInput } from './invocation-card.js';
 /** Explicit TUI task boundary; omission retains legacy programmatic behavior. */
 export interface PromptOptions {
     todoPolicy?: 'new-task' | 'continue';
@@ -5,6 +6,11 @@ export interface PromptOptions {
 /** History recording is independent of whether this message continues a plan. */
 export interface SubmitMessageOptions extends PromptOptions {
     userInitiated?: boolean;
+    /**
+     * Raw material for the transcript card. `submitMessage` builds the card exactly once
+     * (redact -> normalise -> limit); the payload sent to the model is unaffected.
+     */
+    invocation?: InvocationCardInput;
 }
 /** Startup outcome only; engine events still describe the result of the run. */
 export type PromptOutcome = {

package/dist/agent/queued-messages.d.ts

@@ -1,8 +1,11 @@
 import type { Entry } from './reducer.js';
+import type { InvocationCard } from './invocation-card.js';
 /** Full user text retained until Core acknowledges its opaque ID. */
 export interface PendingSteering {
     readonly queueId: string;
     readonly text: string;
+    /** Carried so the `queued -> user` rewrite keeps the card (tui-invocation-cards). */
+    readonly invocation?: InvocationCard;
 }
 /** Hide only active pending entries, using the same projection for measurement and paint. */
 export declare function selectTranscriptEntries(entries: Entry[], pending: readonly PendingSteering[]): Entry[];

package/dist/agent/queued-messages.js

@@ -13,7 +13,10 @@ export function reconcileSteeringReceipt(options) {
     if (!ids.size)
         return { entries: options.entries, pending: [...options.pending], changed: false };
     const entries = mergePendingEntries(options.entries, options.pending).map((entry) => entry.kind === 'queued' && ids.has(entry.queueId ?? '')
-        ? { id: entry.id, kind: 'user', text: entry.text } : entry);
+        ? {
+            id: entry.id, kind: 'user', text: entry.text,
+            ...(entry.invocation ? { invocation: entry.invocation } : {}),
+        } : entry);
     return { entries, pending: options.pending.filter((item) => !ids.has(item.queueId)), changed: true };
 }
 /** Supplement trimmed/cleared history for save and exit without deduplicating text. */

package/dist/agent/reducer.d.ts

@@ -11,6 +11,7 @@
  *     synthesizes a generic error notice (a swallowed throw is never a no-op).
  */
 import type { PendingSteering } from './queued-messages.js';
+import type { InvocationCard } from './invocation-card.js';
 import type { AgentEvent, ModelCost, ToolResult, TokenUsage } from '@aragon-agent/core';
 import type { AgentMode } from './agent-mode.js';
 import type { DispatchOutcome, SubagentRun, SubagentSpec, TeamSnapshot } from '../team/types.js';
@@ -47,6 +48,7 @@ export type Entry = {
     id: string;
     kind: 'user';
     text: string;
+    invocation?: InvocationCard;
 }
 /**
  * A message submitted while a run was in flight (tui-shift-enter-copy-queue
@@ -63,6 +65,7 @@ export type Entry = {
     kind: 'queued';
     text: string;
     queueId?: string;
+    invocation?: InvocationCard;
 } | {
     id: string;
     kind: 'assistant';
@@ -507,6 +510,7 @@ export declare function initialViewState(seed?: ViewStateSeed): ViewState;
 export type ViewAction = {
     type: 'submit';
     text: string;
+    invocation?: InvocationCard;
 }
 /**
  * `controller.steer` was accepted; append the persistent queue marker
@@ -517,6 +521,7 @@ export type ViewAction = {
     type: 'steerQueued';
     queueId: string;
     text: string;
+    invocation?: InvocationCard;
 } | {
     type: 'steeringAccepted';
     ids: readonly string[];

package/dist/agent/reducer.js

@@ -484,7 +484,10 @@ export function viewReducer(state, action) {
     switch (action.type) {
         case 'submit': {
             const { id, seq } = nextId(state);
-            const entry = { id, kind: 'user', text: action.text };
+            const entry = {
+                id, kind: 'user', text: action.text,
+                ...(action.invocation ? { invocation: action.invocation } : {}),
+            };
             return {
                 ...state,
                 seq,
@@ -507,7 +510,10 @@ export function viewReducer(state, action) {
             if (state.seenSteeringIds.has(action.queueId))
                 return state;
             const { id, seq } = nextId(state);
-            const entry = { id, kind: 'queued', queueId: action.queueId, text: action.text };
+            const entry = {
+                id, kind: 'queued', queueId: action.queueId, text: action.text,
+                ...(action.invocation ? { invocation: action.invocation } : {}),
+            };
             // NOTHING ELSE RESETS. This is not a new turn -- `turnProduced`,
             // `errorNoticed` and `aborted` describe the run that is still in
             // flight, and clearing them here would let the next `runEnd` failure
@@ -515,7 +521,10 @@ export function viewReducer(state, action) {
             return {
                 ...state, seq, ...appendEntry(state, state.entries, entry),
                 seenSteeringIds: new Set([...state.seenSteeringIds, action.queueId]),
-                pendingSteering: [...state.pendingSteering, { queueId: action.queueId, text: action.text }],
+                pendingSteering: [...state.pendingSteering, {
+                        queueId: action.queueId, text: action.text,
+                        ...(action.invocation ? { invocation: action.invocation } : {}),
+                    }],
             };
         }
         case 'steeringAccepted': {

package/dist/commands/builtins.js

@@ -621,6 +621,8 @@ const COMMANDS = [
     },
     {
         name: 'todo',
+        // Same verb parse as `run` below, so the echo is suppressed exactly when a card can appear (I-8).
+        rendersInvocationCard: (args) => args.trim().toLowerCase().split(/\s+/)[0] === 'continue',
         description: 'Todo planning: status | on | off | panel on|off | follow <mode> | ' +
             'acceptance [on|off|reset] | clear | continue',
         /**
@@ -782,6 +784,16 @@ const COMMANDS = [
                 // the more verbose of the two forms (AC-17).
                 ctx.submit(buildContinuationMessage(snapshot), {
                     userInitiated: false, todoPolicy: 'continue',
+                    // The transcript shows a card instead of the canned paragraph; the payload above
+                    // is unchanged (tui-invocation-cards I-1).
+                    ...(ctx.invocationCards === false ? {} : {
+                        invocation: {
+                            variant: 'todo',
+                            name: 'continue',
+                            commandLine: '/todo continue',
+                            facts: [`${Math.max(0, snapshot.total - snapshot.doneCount)} of ${snapshot.total} steps left`],
+                        },
+                    }),
                 });
                 return;
             }

package/dist/commands/governance-command.js

@@ -198,7 +198,17 @@ async function resume(ctx) {
         return;
     // `userInitiated: false` keeps the canned turn out of the prompt history, exactly like
     // `/todo continue` (todo-plan-followthrough C-12).
-    ctx.submit(resumeTurnText(runId), { userInitiated: false });
+    ctx.submit(resumeTurnText(runId), {
+        userInitiated: false,
+        ...(ctx.invocationCards === false ? {} : {
+            invocation: {
+                variant: 'govern',
+                name: 'resume',
+                commandLine: requested === '' ? '/gov resume' : `/gov resume ${requested}`,
+                facts: [`run ${runId.slice(0, 8)}`],
+            },
+        }),
+    });
 }
 function abort(ctx) {
     if (!ctx.controller.isGovernanceStageRunning()) {
@@ -286,6 +296,8 @@ export async function runGovernanceCommand(ctx) {
 export function registerGovernanceCommand(registry) {
     registry.register({
         name: 'gov',
+        // Same verb parse as `runGovernanceCommand`, so the echo is suppressed exactly when a card can appear (I-8).
+        rendersInvocationCard: (args) => (args.trim().split(/\s+/)[0] ?? '').toLowerCase() === 'resume',
         description: GOV_COMMAND_SUMMARY,
         run: (ctx) => runGovernanceCommand(ctx),
     });

package/dist/commands/index-build.d.ts

@@ -26,6 +26,14 @@ export declare function hasProjectIndex(cwd: string): boolean;
  * second time (the skill's own edge-case list says exactly that).
  */
 export declare function indexBuildInvocationArgs(hasExistingIndex: boolean): string;
+/**
+ * True when `args` is one of the two machine-written sentences above. The invocation
+ * card uses this to NOT present them as something the user said (tui-invocation-cards
+ * RV-3): it shows a `ctrl+i` fact instead. Same file as the generator so the two cannot
+ * drift - a reworded sentence that stops matching would silently put machine words
+ * back on the card.
+ */
+export declare function isIndexBuildArgs(args: string): boolean;
 export interface IndexConfirmInput {
     cwd: string;
     /** True when `.claude-index/index.md` already exists (rebuild, not first build). */

package/dist/commands/index-build.js

@@ -40,6 +40,17 @@ export function indexBuildInvocationArgs(hasExistingIndex) {
         ? 'The user pressed Ctrl+I and confirmed. Rebuild the project index for this workspace now, reusing the existing .claude-index/config.md preferences.'
         : 'The user pressed Ctrl+I and confirmed. Build the project index for this workspace now, asking the configuration questions first.';
 }
+/**
+ * True when `args` is one of the two machine-written sentences above. The invocation
+ * card uses this to NOT present them as something the user said (tui-invocation-cards
+ * RV-3): it shows a `ctrl+i` fact instead. Same file as the generator so the two cannot
+ * drift - a reworded sentence that stops matching would silently put machine words
+ * back on the card.
+ */
+export function isIndexBuildArgs(args) {
+    const text = args.trim();
+    return text === indexBuildInvocationArgs(true) || text === indexBuildInvocationArgs(false);
+}
 /**
  * The Yes/No dialog body. It names WHAT WILL BE WRITTEN - an index run is a
  * batch of file writes the user never typed, and the one question a confirm

package/dist/commands/registry.d.ts

@@ -201,6 +201,13 @@ export interface CommandContext {
      * TYPE-ONLY import, for the reason the `branch` note above records.
      */
     taskSummary?: TaskSummaryCommandPort;
+    /**
+     * Whether transcript invocation cards are on (tui-invocation-cards section 3.6).
+     * `false` only under `ARAGON_NO_INVOCATION_CARDS=1`; commands then fall back to the
+     * pre-card notices and submit without `invocation`. Absent (every fixture built by
+     * literal) means ON.
+     */
+    invocationCards?: boolean;
 }
 /**
  * What `/keys` and `/task` may do.
@@ -240,6 +247,12 @@ export interface SlashCommand {
     aliases?: string[];
     description: string;
     run: (ctx: CommandContext) => void | Promise<void>;
+    /**
+     * True when running with these args will submit a message that renders as an invocation
+     * card, so the `Command:` echo would only repeat it. MUST be the same predicate the
+     * command itself branches on (I-8); absent means false.
+     */
+    rendersInvocationCard?: (args: string) => boolean;
 }
 export declare class CommandRegistry {
     private readonly byName;
@@ -247,6 +260,16 @@ export declare class CommandRegistry {
     get(name: string): SlashCommand | undefined;
     all(): SlashCommand[];
 }
+/**
+ * Split raw composer input into a command word and its trimmed args; `null` when the
+ * input is not a slash command (no leading `/`, or the `//` literal-slash escape).
+ * `runSlashInput` and the App's echo suppression both go through here so they cannot
+ * disagree about what counts as a command.
+ */
+export declare function parseSlashInput(input: string): {
+    name: string;
+    args: string;
+} | null;
 /**
  * Try to run a slash command from raw input. Returns `true` if the input was a
  * (known or unknown) slash command and was consumed; `false` if it is a normal

package/dist/commands/registry.js

@@ -19,21 +19,34 @@ export class CommandRegistry {
     }
 }
 /**
- * Try to run a slash command from raw input. Returns `true` if the input was a
- * (known or unknown) slash command and was consumed; `false` if it is a normal
- * message that should go to the agent.
+ * Split raw composer input into a command word and its trimmed args; `null` when the
+ * input is not a slash command (no leading `/`, or the `//` literal-slash escape).
+ * `runSlashInput` and the App's echo suppression both go through here so they cannot
+ * disagree about what counts as a command.
  */
-export async function runSlashInput(registry, input, makeCtx) {
+export function parseSlashInput(input) {
     const trimmed = input.trimStart();
     if (!trimmed.startsWith('/'))
-        return false;
-    // `//...` escapes a literal leading slash — not a command.
+        return null;
+    // `//...` escapes a literal leading slash - not a command.
     if (trimmed.startsWith('//'))
-        return false;
+        return null;
     const withoutSlash = trimmed.slice(1);
     const spaceIdx = withoutSlash.search(/\s/);
     const name = spaceIdx === -1 ? withoutSlash : withoutSlash.slice(0, spaceIdx);
     const args = spaceIdx === -1 ? '' : withoutSlash.slice(spaceIdx + 1).trim();
+    return { name, args };
+}
+/**
+ * Try to run a slash command from raw input. Returns `true` if the input was a
+ * (known or unknown) slash command and was consumed; `false` if it is a normal
+ * message that should go to the agent.
+ */
+export async function runSlashInput(registry, input, makeCtx) {
+    const parsed = parseSlashInput(input);
+    if (parsed === null)
+        return false;
+    const { name, args } = parsed;
     const command = registry.get(name);
     const ctx = makeCtx(args);
     if (!command) {

package/dist/commands/skills.js

@@ -16,6 +16,7 @@ import { SKILL_TRIAGE_LIMITS } from '../skills/triage.js';
 import { HOST_TOOL_NAMES, SKILL_TOOL_FLOOR } from '../tools/index.js';
 import { SKILLS_TOOL_POLICY_MODES, isSkillsToolPolicyMode } from '../config/schema.js';
 import { pickGlyphs } from '../ui/glyphs.js';
+import { INDEX_SKILL_NAME, isIndexBuildArgs } from './index-build.js';
 function marksFor(ctx) {
     const cfg = ctx.controller.getConfig();
     const glyphs = pickGlyphs({ colorLevel: cfg.colorLevel ?? 0, unicode: cfg.unicode ?? false });
@@ -673,10 +674,37 @@ export function registerSkillCommands(registry, service) {
         }
     }
 }
+/**
+ * The card's raw material for one skill run (tui-invocation-cards section 3.3). The
+ * command line always uses the namespaced `/skill:<name>` form - the stable handle -
+ * even when the user typed the bare name. Ctrl+I's machine-written sentence is NOT the
+ * user's input (RV-3): the card says `ctrl+i` and shows no input row.
+ */
+function skillCardInput(record, args, sent) {
+    const machine = record.name === INDEX_SKILL_NAME && isIndexBuildArgs(args);
+    const version = record.frontmatter.version;
+    const facts = [
+        ...(machine ? ['ctrl+i'] : []),
+        ...(version ? [`v${version}`] : []),
+        record.scope,
+        `${sent.kb} KB`,
+        ...(sent.files > 0 ? [`${sent.files} files`] : []),
+        ...(sent.policy ? ['tool ceiling'] : []),
+    ];
+    const typed = machine ? '' : args;
+    return {
+        variant: 'skill',
+        name: record.name,
+        commandLine: typed === '' ? `/skill:${record.name}` : `/skill:${record.name} ${typed}`,
+        input: typed,
+        facts,
+    };
+}
 function makeSkillCommand(record, service) {
     return {
         name: record.name,
         description: shortDescription(record),
+        rendersInvocationCard: () => true,
         run: (ctx) => {
             let loaded;
             try {
@@ -703,8 +731,14 @@ function makeSkillCommand(record, service) {
             // The SUBMITTED size, not the file's. Reporting 480 KB while sending 30 KB
             // is how a user concludes the truncation marker is a rendering glitch.
             const kb = Math.max(1, Math.round(Buffer.byteLength(message, 'utf-8') / 1024));
-            ctx.notify('info', `Skill "${record.name}" loaded (${kb} KB submitted, ${loaded.files.length} bundled files).`);
-            ctx.submit(message);
+            if (ctx.invocationCards === false) {
+                ctx.notify('info', `Skill "${record.name}" loaded (${kb} KB submitted, ${loaded.files.length} bundled files).`);
+                ctx.submit(message);
+                return;
+            }
+            ctx.submit(message, {
+                invocation: skillCardInput(record, ctx.args, { kb, files: loaded.files.length, policy: !!policy }),
+            });
         },
     };
 }