@aragon-agent/cli 0.6.45 → 0.6.47

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';
@@ -18,6 +19,7 @@ import type { FastReview, FastSnapshot } from '../fast/types.js';
 import type { CompactionMode, CompactionPhase, CompactionRecord, CompactionSnapshot, CompactionUiTrigger, ContextUsageSnapshot } from '../compaction/types.js';
 import type { AcceptanceSnapshot, TodoItem, TodoSnapshot } from '../todo/types.js';
 import type { JobKind, ServiceSnapshot, ServiceStatus } from '../proc/types.js';
+import type { WaitView } from '../proc/wait-view.js';
 import type { RetryPhase } from './retry-view.js';
 import type { FilePatch } from '../tools/patch.js';
 import type { TaskSummaryView } from '../fast/task-summary-types.js';
@@ -47,6 +49,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 +66,7 @@ export type Entry = {
     kind: 'queued';
     text: string;
     queueId?: string;
+    invocation?: InvocationCard;
 } | {
     id: string;
     kind: 'assistant';
@@ -137,6 +141,16 @@ export type Entry = {
     liveSeq?: number;
     /** Epoch ms of the last output row, for the stall row (§3.3.4). */
     lastOutputAt?: number;
+    /**
+     * The live view of a running `job_wait` (extended-job-wait §3.8.1), refreshed
+     * at 1 Hz. RUNTIME ONLY, and it lives and dies with `live` (I-9): cleared by
+     * `toolExecEnd` AND by every idle path through `releaseLiveTails`, and never
+     * persisted. `job_wait` never streams, so `live` is always empty for it - which
+     * is exactly why the idle clean-up cannot key off `live` alone.
+     */
+    wait?: WaitView;
+    /** Monotonic counter: the revision term that invalidates the render cache. */
+    waitSeq?: number;
 } | {
     id: string;
     kind: 'notice';
@@ -507,6 +521,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 +532,7 @@ export type ViewAction = {
     type: 'steerQueued';
     queueId: string;
     text: string;
+    invocation?: InvocationCard;
 } | {
     type: 'steeringAccepted';
     ids: readonly string[];
@@ -575,6 +591,15 @@ export type ViewAction = {
     toolCallId: string;
     rows: readonly string[];
     at: number;
+}
+/**
+ * `job_wait`'s 1 Hz view (extended-job-wait). Carries the WHOLE view, so the
+ * coalescer keeps only the last per `toolCallId`, like `toolOutputDelta`.
+ */
+ | {
+    type: 'waitUpdate';
+    toolCallId: string;
+    view: WaitView;
 } | {
     type: 'turnEnd';
     usage: TokenUsage;

package/dist/agent/reducer.js

@@ -400,12 +400,22 @@ function settleRetryCard(state, entries, phase) {
 function releaseLiveTails(entries) {
     let touched = false;
     const next = entries.map((e) => {
-        if (e.kind !== 'tool' || !e.live)
+        // `!e.live && !e.wait`, NOT `!e.live` (extended-job-wait RV-2): a `job_wait`
+        // never streams, so its `live` is always empty and the old guard would skip it,
+        // leaving a wait card that says "running" in the transcript forever.
+        if (e.kind !== 'tool' || (!e.live && !e.wait))
             return e;
         if (e.status !== 'running' && e.status !== 'pending')
             return e;
         touched = true;
-        return { ...e, live: undefined, lastOutputAt: undefined, liveSeq: (e.liveSeq ?? 0) + 1 };
+        return {
+            ...e,
+            live: undefined,
+            lastOutputAt: undefined,
+            liveSeq: (e.liveSeq ?? 0) + 1,
+            wait: undefined,
+            waitSeq: (e.waitSeq ?? 0) + 1,
+        };
     });
     return touched ? next : entries;
 }
@@ -484,7 +494,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 +520,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 +531,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': {
@@ -660,6 +679,23 @@ export function viewReducer(state, action) {
                     : e),
             };
         }
+        /**
+         * ONLY A RUNNING, MATCHING ENTRY. `begin` travels from the controller and can
+         * beat `tool_execution_start` through the agent-event pipe, so a miss is
+         * normal and is dropped on purpose: the next 1 Hz beat repairs it (RV-5).
+         */
+        case 'waitUpdate': {
+            const id = findToolEntryId(state, action.toolCallId);
+            if (!id)
+                return state;
+            const target = state.entries.find((e) => e.id === id);
+            if (!target || target.kind !== 'tool' || target.status !== 'running')
+                return state;
+            return {
+                ...state,
+                entries: mapEntry(state.entries, id, (e) => e.kind === 'tool' ? { ...e, wait: action.view, waitSeq: (e.waitSeq ?? 0) + 1 } : e),
+            };
+        }
         case 'toolExecEnd': {
             const id = findToolEntryId(state, action.toolCallId);
             if (!id)
@@ -680,6 +716,8 @@ export function viewReducer(state, action) {
                         // `bashBadge`'s last-line parse (`ToolPreview.tsx:35-54`).
                         live: undefined,
                         lastOutputAt: undefined,
+                        wait: undefined,
+                        waitSeq: undefined,
                     }
                     : e),
             };

package/dist/agent/user-attention.d.ts

@@ -0,0 +1,17 @@
+/**
+ * "The user just spoke" as a subscribable edge (extended-job-wait §3.4).
+ *
+ * ASCII ONLY: `src/agent/**` is inside the glyph scanner's scope.
+ *
+ * EDGE-TRIGGERED ON PURPOSE: there is no "is anything pending" probe. A wait that
+ * could be woken by pre-existing state would return at once whenever that state
+ * went stale, and a model that gets an instant return from every `job_wait` burns
+ * tokens in a hot loop. Only a `notify()` that happens after `subscribe()` counts.
+ */
+export interface UserAttention {
+    /** Announce one new user input to every current subscriber. */
+    notify(): void;
+    /** Register a listener; returns its unsubscribe. */
+    subscribe(listener: () => void): () => void;
+}
+export declare function createUserAttention(): UserAttention;

package/dist/agent/user-attention.js

@@ -0,0 +1,32 @@
+/**
+ * "The user just spoke" as a subscribable edge (extended-job-wait §3.4).
+ *
+ * ASCII ONLY: `src/agent/**` is inside the glyph scanner's scope.
+ *
+ * EDGE-TRIGGERED ON PURPOSE: there is no "is anything pending" probe. A wait that
+ * could be woken by pre-existing state would return at once whenever that state
+ * went stale, and a model that gets an instant return from every `job_wait` burns
+ * tokens in a hot loop. Only a `notify()` that happens after `subscribe()` counts.
+ */
+export function createUserAttention() {
+    const listeners = new Set();
+    return {
+        notify() {
+            // Snapshot first: a listener may unsubscribe itself while we iterate.
+            for (const listener of [...listeners]) {
+                try {
+                    listener();
+                }
+                catch {
+                    // One broken listener must not deprive the others of the wake-up.
+                }
+            }
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+    };
+}

package/dist/cli.js

@@ -1765,9 +1765,8 @@ function runConfigSetValue(key, value) {
     const jobsPatch = applyJobsConfigSet(key, value);
     if (jobsPatch) {
         // Echoed from the STORED value, so `config set jobs.waitSeconds 1` prints 5
-        // and `jobs.waitSeconds 9999` prints 60 — the rule every section above
-        // states. It matters here too: `waitSeconds` is ALSO converged against the
-        // tool ceiling by I-4, so the stored value is the only honest answer.
+        // and `jobs.waitSeconds 9999` prints 1200 — the rule every section above
+        // states.
         const merged = updatePersistedConfig(jobsPatch);
         const field = key.slice('jobs.'.length);
         process.stdout.write(`Set ${key} = ${String(merged.jobs[field])}\n`);

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 }),
+            });
         },
     };
 }

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/config/load.js

@@ -6,7 +6,6 @@
  * legitimately long single tool run can never be watchdog-killed.
  */
 import process from 'node:process';
-import { JOB_WAIT_MARGIN_MS } from '../proc/limits.js';
 import { DEFAULT_CONFIG, DEFAULT_SCROLL_MODE, IDLE_TIMEOUT_MARGIN_MS, clampDensity, clampHumanTimeout, clampCompactionConfig, clampLogConfig, clampFastConfig, clampRetryConfig, clampSkillsConfig, clampTeamConfig, clampTodoConfig, clampBashConfig, clampJobsConfig, clampPromptsConfig, clampTaskSummaryConfig, clampUpdateConfig, clampTheme, clampThinkingLevel, clampContextWindow, clampMaxTokens, clampMaxRenderInterval, clampScrollMode, clampScrollResumeMs, clampTranscriptRetain, clampTranscriptWindow, coercePositiveInt, isAutoToken, isSkillsToolPolicyMode, legacyTeamCeilingPatch, legacyTeamFanoutPatch, LEGACY_TEAM_FANOUT_DEFAULTS, parseThresholdInput, } from './schema.js';
 import { loadDotenv, readEnvConfig, readEnvDisabledSkills } from './env.js';
 import { readConfigFile, updatePersistedConfig } from './store.js';
@@ -622,32 +621,14 @@ export function loadConfig(flags = {}, options = {}) {
         DEFAULT_CONFIG.planModeDefault;
     const planModeHumanTimeoutMs = clampHumanTimeout(file.planModeHumanTimeoutMs, DEFAULT_CONFIG.planModeHumanTimeoutMs);
     const toolTimeoutMs = coercePositiveInt(pick(flags.toolTimeout, file.toolTimeoutMs), DEFAULT_CONFIG.toolTimeoutMs);
-    // THE `jobs` SECTION IS RESOLVED HERE, ABOVE THE TIMEOUT BLOCK, and the
-    // position is the whole of RV-P1-2. The design's first draft put the I-4 clamp
-    // next to the `idleTimeoutMs` invariant below, but `jobs` is parsed inside the
-    // big config literal a hundred lines further down — a reference to it here would
-    // be a use-before-declaration, and "resolve it later and patch the object" is
-    // how the invariant gets silently skipped. Resolving it first makes the clamp
-    // impossible to omit.
+    // `jobs.waitSeconds` is NOT converged against `toolTimeoutMs` (extended-job-wait
+    // I-4'): `job_wait` has its own executor ceiling and pauses the idle watchdog,
+    // so the section is resolved once, as-is.
     const jobs = resolveJobsConfig(env.partial, file);
     let idleTimeoutMs = coercePositiveInt(pick(flags.idleTimeout, file.idleTimeoutMs), DEFAULT_CONFIG.idleTimeoutMs);
     // Timeout invariant (R1): idle must be strictly greater than the tool ceiling
     // so a long single tool run is never aborted by the idle watchdog.
     idleTimeoutMs = Math.max(idleTimeoutMs, toolTimeoutMs + IDLE_TIMEOUT_MARGIN_MS);
-    // INVARIANT I-4 (long-task-jobs): a wait must fit inside the tool call that
-    // hosts it, `jobs.waitSeconds * 1000 + JOB_WAIT_MARGIN_MS <= toolTimeoutMs`.
-    //
-    // `Math.min`, AND THE DIRECTION IS THE POINT. The invariant above RAISES the
-    // idle window to accommodate the tool; this one LOWERS the wait to accommodate
-    // the tool. Copying `Math.max` here would produce a wait that outlives its own
-    // tool call — which is exactly the `Command timed out` failure the feature
-    // exists to remove, re-created by its own config check.
-    //
-    // With an operator-set ceiling below the margin the floor of 1s applies rather
-    // than a negative wait: the invariant wins over the minimum, because a wait
-    // longer than its host is worse than a short wait.
-    const waitCeilingSeconds = Math.floor((toolTimeoutMs - JOB_WAIT_MARGIN_MS) / 1000);
-    jobs.waitSeconds = Math.max(1, Math.min(jobs.waitSeconds, waitCeilingSeconds));
     // Resolve API keys: config-file key wins over the provider env var.
     const fileKeys = file.apiKeys ?? {};
     const apiKeys = {};
@@ -798,9 +779,7 @@ export function loadConfig(flags = {}, options = {}) {
         update: resolveUpdateConfig(flags, env.partial, file),
         compaction: resolveCompactionConfig(flags, env.partial, file),
         bash: resolveBashConfig(env.partial, file),
-        // The already-resolved-and-converged section from the timeout block above.
-        // NOT `resolveJobsConfig(...)` a second time: that would re-apply the
-        // un-converged `waitSeconds` and silently undo I-4.
+        // The already-resolved section from the top of this function.
         jobs,
         // The quick-prompt library's three policy scalars (quick-prompt-library D-19).
         // Resolved through the SAME clamp the read and write paths use, so an env-only