@aragon-agent/cli 0.6.39 → 0.6.42

package/dist/ui/App.js

@@ -50,6 +50,11 @@ import { acceptanceChip, acceptanceRung, buildTodoRailLayout } from './layout/to
 import { buildTeamPanelLayout } from './layout/team-panel.js';
 import { isLiveTeamCard, lastTeamEntry, rosterCounts } from './team-status.js';
 import { advanceBudget, decideFollowThrough, emptyBudget, } from '../todo/follow-through.js';
+// THE THIRD LAYER OF FORCED TEAM MODE (team-command-forced-dispatch §3.7): the
+// decision and its two strings live in a pure module, so `App` gains wiring and
+// no policy. Imported beside the todo decision it shares one timer with.
+import { decideForcedDispatch, FORCED_NUDGE_NOTICE } from '../team/dispatch-gate.js';
+import { FORCED_NUDGE_GRACE_MS } from '../team/limits.js';
 import { useTerminalSize } from './layout/useTerminalSize.js';
 import { useHeightStore } from './use-height-store.js';
 import { useRenderGovernor } from './use-render-governor.js';
@@ -435,6 +440,32 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     const updateToastPushed = useRef(false);
     const budgetRef = useRef(emptyBudget());
     const followTimer = useRef(null);
+    /**
+     * The forced-dispatch gate's three counters (team-command-forced-dispatch
+     * §3.7). REFS, for the reason the follow-through block above records: every
+     * field added to `ViewState` is a field `restoreEntries`, `/clear`, `/reset`
+     * and the session round-trip each have to have an opinion about, and none of
+     * them has an opinion about a counter that lives for one turn.
+     *
+     * `toolsUsed` and `dispatchAttempted` are cleared at `agent_start`; `nudges`
+     * is NOT - see its own comment.
+     */
+    const toolsUsedRef = useRef(0);
+    const dispatchAttemptedRef = useRef(false);
+    /**
+     * Fallback nudges spent. CLEARED BY A USER SUBMIT, NEVER BY `agent_start`
+     * (P0-2 / I-10).
+     *
+     * The nudge itself starts a NEW TURN, so a reset at `agent_start` would zero
+     * this counter at the top of every continuation and "at most one per turn"
+     * would become "one per turn, forever" - an unbounded loop of N-child
+     * dispatches that only ever fires while the model is being disobedient, which
+     * is precisely the state no manual test reproduces. The one reset lives in
+     * `submitMessage` under `opts.userInitiated !== false`, beside the
+     * `recordPrompt` call that answers the same question ("did a human ask for
+     * this?").
+     */
+    const nudgesRef = useRef(0);
     /** True while the run in flight was started by the grace timer, not the user. */
     const autoContinuationRef = useRef(false);
     /**
@@ -526,8 +557,8 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
      * Disarm an armed continuation. Idempotent; NEVER touches the budget — a
      * cancelled continuation was never issued, so it must not be charged (AC-18).
      *
-     * Three callers and there must be no fourth: `Esc` in the idle branch, the
-     * first line of `submitMessage`, and the subscription effect's cleanup.
+     * ONE SLOT: `Esc`, `submitMessage`, the reset/restore port, the effect cleanup
+     * and both follow-through arms (todo, then the gate) all cancel before arming.
      */
     const cancelFollowThrough = useCallback(() => {
         if (followTimer.current) {
@@ -639,6 +670,11 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             if (event.type === 'agent_start') {
                 interactionPhase.current = 'running';
                 manualMetrics.current = createRunMetrics();
+                // THE TWO PER-TURN COUNTERS ONLY (I-10). `nudgesRef` is deliberately
+                // absent: a nudge continuation arrives here too, and clearing it would
+                // delete the bound that keeps a disobedient model from looping.
+                toolsUsedRef.current = 0;
+                dispatchAttemptedRef.current = false;
             }
             if (event.type === 'agent_end') {
                 interactionPhase.current = 'idle';
@@ -654,6 +690,17 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
                 if (action.type === 'notice' && action.level === 'error') {
                     endReasonRef.current.errored = true;
                 }
+                // THE GATE'S TWO FACTS, counted where the reducer's own actions already
+                // flow (no second subscription to keep in step). `toolExecStart` carries
+                // the tool NAME, so a `task` call that was REFUSED - team off, dispatch
+                // busy, no key - still counts as an attempt (P1-7): the upstream already
+                // said no, and urging a re-dispatch would reproduce that refusal one
+                // turn later.
+                if (action.type === 'toolExecStart') {
+                    toolsUsedRef.current += 1;
+                    if (action.toolName === 'task')
+                        dispatchAttemptedRef.current = true;
+                }
                 if (action.type === 'textDelta' || action.type === 'thinkingDelta') {
                     pending.current.push(action);
                     if (!flushTimer.current) {
@@ -688,13 +735,36 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             const todos = controller.getTodoSnapshot();
             budgetRef.current = advanceBudget(budgetRef.current, todos, autoContinuationRef.current);
             autoContinuationRef.current = false;
-            const decision = decideFollowThrough({
-                mode: controller.getTodoConfig().followThrough,
-                snapshot: todos,
+            // --- Forced-dispatch gate (team-command-forced-dispatch §3.7). --------
+            //
+            // THE THIRD LAYER, AND THE ONLY MECHANICAL ONE: if a whole turn went by
+            // with tools used and nothing dispatched, ask ONCE for a dispatch. It is
+            // computed BEFORE the todo decision and DOWN-GRADES that decision to
+            // `none` rather than returning early (P0-3 / I-9): the two statements below
+            // - the `endReasonRef` reset and `applyPendingMode()` - belong to EVERY
+            // turn, and a `return` here would silently defer a pending `plan -> build`
+            // by a whole turn and carry `errored` into the next one. It also keeps
+            // `cancelFollowThrough()`'s callers at three: the gate reuses the timer
+            // instead of adding a fourth canceller.
+            const forced = controller.getForcedTeam();
+            const gate = decideForcedDispatch({
+                armed: forced !== null,
+                count: forced?.count ?? 0,
+                dispatchAttempted: dispatchAttemptedRef.current,
+                toolsUsed: toolsUsedRef.current,
+                nudgesUsed: nudgesRef.current,
                 runEnd: { ...endReasonRef.current },
-                budget: budgetRef.current,
-                interactive: true,
             });
+            const gated = gate.kind === 'nudge' && forced !== null;
+            const decision = gated
+                ? { kind: 'none' }
+                : decideFollowThrough({
+                    mode: controller.getTodoConfig().followThrough,
+                    snapshot: todos,
+                    runEnd: { ...endReasonRef.current },
+                    budget: budgetRef.current,
+                    interactive: true,
+                });
             endReasonRef.current = { aborted: false, errored: false };
             if (decision.kind === 'notify') {
                 dispatch({ type: 'notice', level: decision.level, text: decision.text });
@@ -739,6 +809,22 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
                     submitRef.current(decision.message, { userInitiated: false, todoPolicy: 'continue' });
                 }, decision.graceMs);
             }
+            // THE GATE'S OWN CONTINUATION: after the todo branch (which it has
+            // already silenced) and BEFORE `applyPendingMode()`, on the SAME timer and
+            // with the same re-checks. `level: 'warn'` and not `'error'` - the error
+            // level sets `endReasonRef.errored`, which would make the next turn's gate
+            // read "the run failed" and switch itself off for the rest of the session.
+            if (gated && gate.kind === 'nudge') {
+                nudgesRef.current += 1;
+                dispatch({ type: 'notice', level: 'warn', text: FORCED_NUDGE_NOTICE });
+                cancelFollowThrough(); // I-9 / I-3: at most one armed continuation, ever
+                followTimer.current = setTimeout(() => {
+                    followTimer.current = null;
+                    if (controller.isRunning() || controller.isCompactionBusy?.())
+                        return;
+                    submitRef.current(gate.message, { userInitiated: false, todoPolicy: 'continue' });
+                }, FORCED_NUDGE_GRACE_MS);
+            }
             // A deferred `plan -> build` becomes real here and nowhere else (§3.2).
             const applied = controller.applyPendingMode();
             if (applied) {
@@ -1014,6 +1100,12 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
                     // correct value (P0-1).
                     dispatch({ type: 'compactionEnd', record: event.record });
                     break;
+                case 'phase':
+                    // THE STAGE LINE ON THE LIVE CARD (context-compaction-never-fires C).
+                    // Dispatch is unconditional; the reducer is what ignores a phase that
+                    // arrives for a card the settle has already closed.
+                    dispatch({ type: 'compactionPhase', index: event.index, phase: event.phase });
+                    break;
                 case 'usage': {
                     // Compaction spend is REAL SPEND at the SUMMARIZER's price (§6.4 /
                     // AC-15), which may be neither the lead's nor the fast tier's — so the
@@ -1950,8 +2042,15 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // composer's hint fade. An auto-continuation demonstrates nothing about what
         // 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)
+        if (opts.userInitiated !== false) {
             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
+            // nudge continuation arrives here with `userInitiated: false`, so it cannot
+            // refill its own budget.
+            nudgesRef.current = 0;
+        }
         // 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 };
@@ -2960,7 +3059,13 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             // the save handler cannot disagree about what `(inherit)` means.
             ...fastSettingsFrom(cfg.fast),
             ...compactionSettingsFrom(cfg.compaction),
-        }, apiKeys: cfg.apiKeys, maxRows: overlayMaxRows, cols: viewCols, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps, draft: settingsDraft, probe: probe, onProfileSave: handleProfileSave, onReload: () => controller.createModelSettingsDraft(), onClose: () => dispatch({ type: 'setOverlay', overlay: null }), 
+        }, apiKeys: cfg.apiKeys, maxRows: overlayMaxRows, cols: viewCols, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps, draft: settingsDraft, 
+        // THE MISSING LINK (P1-5): without it the `Team` page cannot render
+        // `on (next launch)` for a `--no-team` session, because the subpage is
+        // mounted with `{...props}` and an undeclared prop arrives as
+        // `undefined`. A construction-time snapshot, so reading it per frame is
+        // honest (I-7).
+        teamRegistered: controller.isTeamRegistered(), probe: probe, onProfileSave: handleProfileSave, onReload: () => controller.createModelSettingsDraft(), onClose: () => dispatch({ type: 'setOverlay', overlay: null }), 
         // Read from `cfg` (render scope, re-read every frame), so `/retry off`
         // while the screen is open shows the new value on the next paint.
         retrySummary: cfg.retry.enabled && cfg.retry.maxRetries > 0 ? String(cfg.retry.maxRetries) : 'off' })) : overlay === 'agents' ? (
@@ -3070,6 +3175,13 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         railRows: native ? (nativeBudget?.band.railRows ?? 0) : (fullscreenRailVisible ? railRows : 0),
         width: native ? (nativeBudget?.band.railCols ?? 0) : railWidth,
     });
+    // THE FORCED-MODE CHIP'S SOURCE (team-command-forced-dispatch §3.8 / D-9),
+    // read from the controller on every frame: `armForcedTeam()` writes no
+    // `ViewState`, so a mirror would have to be kept in step by hand - which is the
+    // double-truth this design deletes elsewhere. It is handed to `StatusBar`, which
+    // plans the primary row from its own props (a copy on `statusInput` above would
+    // be a field nothing renders).
+    const forcedTeam = controller.getForcedTeam();
     const statusInput = {
         columns: viewCols, phase: state.runPhase, pendingCount: state.pendingSteering.length,
         context: state.context, usageTotal: state.usageTotal, thinkingLevel: cfg.thinkingLevel,
@@ -3138,7 +3250,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // partially stale. The window and its `known` flag now travel INSIDE
         // it, resolved by the meter - which is what makes the user's
         // `contextWindow` override reach the bar.
-        context: state.context, status: state.status, elapsedMs: elapsedMs, thinkingLevel: cfg.thinkingLevel, tokPerSec: tokPerSec, theme: theme, caps: caps, scrolledLines: scrolledLines, redrawNonce: redrawNonce, agentMode: state.agentMode, pendingAgentMode: state.pendingAgentMode, ecoRung: governor.rung, ...(state.team
+        context: state.context, status: state.status, elapsedMs: elapsedMs, thinkingLevel: cfg.thinkingLevel, tokPerSec: tokPerSec, theme: theme, caps: caps, scrolledLines: scrolledLines, redrawNonce: redrawNonce, agentMode: state.agentMode, pendingAgentMode: state.pendingAgentMode, ...(forcedTeam ? { forcedTeam } : {}), ecoRung: governor.rung, ...(state.team
             ? {
                 // `rosterCounts`, NOT a fourth inline phase filter (A-1): the chip and
                 // the roster header above it must never disagree.
@@ -3153,7 +3265,14 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             ? { todoActive: { done: state.todos.doneCount, total: state.todos.total } }
             : {}), ...(acceptanceActive ? { acceptanceActive } : {}), ...(liveServices > 0 ? { servicesActive: { live: liveServices } } : {}), ...(state.fast?.live ? { fastActive: { inFlight: state.fast.inFlight } } : {}), 
         // Manual compaction starts before its next snapshot is published.
-        compactionActive: { inFlight: statusInput.compacting ?? false }, ...(controller.isCompactionEnabled()
+        // THE AUTO-PAUSED CHIP RIDES HERE AND NOWHERE ELSE (never-fires C /
+        // analysis 3.3.1): `selfDisabled` used to live only in `/compact status`,
+        // a command nobody types while the gauge sits at 95 %. `StatusBar` plans
+        // the primary row from its own props, so a second copy of the flag on
+        // `statusInput` would be a field nothing renders - and a fact with two
+        // sources is a fact that drifts.
+        compactionActive: { inFlight: statusInput.compacting ?? false,
+            selfDisabled: state.compaction?.selfDisabled === true }, ...(controller.isCompactionEnabled()
             ? {
                 gaugeMarks: {
                     warn: cfg.compaction.warnThreshold * 100,

package/dist/ui/StatusBar.d.ts

@@ -65,6 +65,20 @@ export interface StatusBarProps {
     } | null;
     agentMode?: AgentMode;
     pendingAgentMode?: AgentMode | null;
+    /**
+     * Forced team mode is armed, with the count it was armed with
+     * (team-command-forced-dispatch §3.8 / D-9). ABSENT = not armed, and every
+     * existing caller renders the row it always did.
+     *
+     * IT RIDES THIS COMPONENT'S PROPS AND NOT THE APP'S `statusInput`, by the rule
+     * the `compactionActive` chip records where `App` builds it: this component
+     * plans the primary row from its OWN props, so a chip left on `statusInput`
+     * would be a field nothing renders - which is exactly how the only persistently
+     * visible signal of `/team` (D-9) can ship without ever appearing on screen.
+     */
+    forcedTeam?: {
+        count: number;
+    };
     teamActive?: {
         running: number;
         total: number;
@@ -92,6 +106,7 @@ export interface StatusBarProps {
     };
     compactionActive?: {
         inFlight: boolean;
+        selfDisabled?: boolean;
     };
     gaugeMarks?: {
         warn: number;

package/dist/ui/StatusBar.js

@@ -39,7 +39,9 @@ export function StatusBar(props) {
         interruptPhase: props.interruptPhase,
         waitingForConfirmation: props.waitingForConfirmation, stopping: props.stopping,
         compacting: props.compactionActive?.inFlight, retryActive: props.retryActive,
+        compactionPaused: props.compactionActive?.selfDisabled === true,
         mode: props.agentMode, pendingMode: props.pendingAgentMode, servicesActive: props.servicesActive,
+        ...(props.forcedTeam ? { forcedTeam: props.forcedTeam } : {}),
         teamActive: props.teamActive, todoActive: props.todoActive,
         ...(props.acceptanceActive ? { acceptanceActive: props.acceptanceActive } : {}),
         ecoRung: props.ecoRung, fastActive: props.fastActive, scrolledLines: props.scrolledLines,

package/dist/ui/Transcript.js

@@ -137,7 +137,7 @@ function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion,
         case 'fast':
             return frame(entry.status === 'failed' ? glyphs.toolError : glyphs.teamAgent, fastCardColor(entry.status, theme), _jsx(FastCard, { reviewIndex: entry.reviewIndex, model: entry.model, status: entry.status, text: entry.text, detail: entry.detail, turn: entry.turn, durationMs: entry.durationMs, live: entry.live, reducedMotion: reducedMotion, theme: theme, caps: caps }));
         case 'compaction':
-            return frame(entry.applied || entry.live ? glyphs.compaction : glyphs.toolError, compactionCardColor(entry, theme), _jsx(CompactionCard, { index: entry.index, decision: entry.decision, memoryVersion: entry.memoryVersion, trigger: entry.trigger, mode: entry.mode, applied: entry.applied, reason: entry.reason, messagesBefore: entry.messagesBefore, messagesAfter: entry.messagesAfter, tokensBefore: entry.tokensBefore, tokensAfter: entry.tokensAfter, summary: entry.summary, model: entry.model, durationMs: entry.durationMs, tailRelief: entry.tailRelief, 
+            return frame(entry.applied || entry.live ? glyphs.compaction : glyphs.toolError, compactionCardColor(entry, theme), _jsx(CompactionCard, { index: entry.index, decision: entry.decision, memoryVersion: entry.memoryVersion, trigger: entry.trigger, mode: entry.mode, applied: entry.applied, reason: entry.reason, messagesBefore: entry.messagesBefore, messagesAfter: entry.messagesAfter, tokensBefore: entry.tokensBefore, tokensAfter: entry.tokensAfter, summary: entry.summary, model: entry.model, durationMs: entry.durationMs, tailRelief: entry.tailRelief, phase: entry.phase, keepRelaxed: entry.keepRelaxed, retainedTurns: entry.retainedTurns, retainedMessages: entry.retainedMessages, keepRecentTurnsUsed: entry.keepRecentTurnsUsed, elidedMessages: entry.elidedMessages, 
                 // ONLY WHILE LIVE, and only when the clock has ticked at least once:
                 // `nowSec` is `undefined` until then, and a settled card must keep
                 // rendering `durationMs` rather than a figure that would drift.

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

@@ -23,7 +23,7 @@
 import React from 'react';
 import type { Theme } from '../theme.js';
 import type { TermCapabilities } from '../capabilities.js';
-import type { CompactionDecision, CompactionMode, CompactionUiTrigger } from '../../compaction/types.js';
+import type { CompactionDecision, CompactionMode, CompactionPhase, CompactionUiTrigger } from '../../compaction/types.js';
 export interface CompactionCardProps {
     decision?: CompactionDecision;
     memoryVersion?: 2;
@@ -39,6 +39,16 @@ export interface CompactionCardProps {
     summary?: string;
     model: string;
     durationMs?: number;
+    /** The live card's stage, so "compacting" also says WHAT (never-fires C). */
+    phase?: CompactionPhase;
+    /** Set when this cut existed only because `keepRecentTurns` was relaxed (B). */
+    keepRelaxed?: boolean;
+    retainedTurns?: number;
+    /** Messages the relaxed cut left verbatim, which is not the same as turns. */
+    retainedMessages?: number;
+    keepRecentTurnsUsed?: number;
+    /** Messages the digest left out and therefore cannot be quoted (A1). */
+    elidedMessages?: number;
     /**
      * Wall-clock since the card opened, LIVE ONLY
      * (context-auto-compaction-hardening §3.6 / W5).

package/dist/ui/entries/CompactionCard.js

@@ -28,6 +28,7 @@ import { pickGlyphs } from '../glyphs.js';
 import { railBorderProps } from '../layout/Gutter.js';
 import { formatDuration, formatTokens } from '../../agent/usage.js';
 import { COMPACTION_LIMITS } from '../../compaction/limits.js';
+import { compactionPhaseLabel, compactionReasonLine } from '../../compaction/reason-text.js';
 /**
  * The card's colour.
  *
@@ -56,12 +57,19 @@ function headline(props, arrow, dot) {
         // second 45 this was the only changing information on the card, and there was
         // none.
         const elapsed = props.elapsedMs === undefined ? '' : `${dot}${formatDuration(props.elapsedMs)}`;
+        // THE STAGE, NOT JUST "COMPACTING" (never-fires C). Planning and digesting run
+        // before any model call, and a user watching a card for twenty seconds cannot
+        // tell "thinking hard" from "stuck in a gate" without it.
+        const stage = props.phase === undefined ? '' : `${dot}${compactionPhaseLabel(props.phase)}`;
         return props.model
-            ? `compacting context #${index}${dot}${props.model}${elapsed}`
-            : `compacting context #${index}${elapsed}`;
+            ? `compacting context #${index}${dot}${props.model}${stage}${elapsed}`
+            : `compacting context #${index}${stage}${elapsed}`;
     }
     if (!props.applied || props.tokensAfter >= props.tokensBefore) {
-        const why = props.reason ? `: ${props.reason}` : '';
+        // THE REASON IN WORDS (never-fires C). `digest_budget_exceeded: $.digest` was
+        // a code the user could not act on; `compactionReasonLine` renders the same
+        // fact as a clause plus, where there is one, the remedy.
+        const why = props.reason ? `: ${compactionReasonLine(props.reason)}` : '';
         return `context not compacted #${index}${why}`;
     }
     const messages = `${props.messagesBefore} ${arrow} ${props.messagesAfter} messages`;
@@ -87,8 +95,15 @@ function headline(props, arrow, dot) {
  */
 function detailLine(props) {
     if (props.live) {
+        // THE ESCAPE, NOT THE STAGE (never-fires C, as corrected in review): the live
+        // headline already carries the stage, and a two-line card that names it twice
+        // is the one-fact-one-surface rule this file keeps having to restore. With no
+        // model resolved there is no call to cancel, so the whole line goes - the same
+        // rule the settled branch applies.
         if (!props.model)
             return '';
+        if (props.phase !== undefined)
+            return 'esc to cancel';
         return `summarizing with ${props.model} - esc to cancel`;
     }
     if (!props.applied || props.tokensAfter >= props.tokensBefore)
@@ -104,6 +119,50 @@ function detailLine(props) {
     const via = props.trigger === 'overflow' ? ' after a context overflow' : '';
     return `summarized ${dropped} messages with ${props.model}${via}`;
 }
+/**
+ * The relaxation disclosure (never-fires B).
+ *
+ * `planCompaction`'s second pass trades "the last N user turns are verbatim" for
+ * "a cut exists at all". That trade must be readable, because the difference
+ * between the two compactions is exactly what the user asked for: the tail is the
+ * part they care most about keeping word for word.
+ */
+function relaxedLine(props) {
+    if (props.live || !props.applied || props.keepRelaxed !== true)
+        return '';
+    const turns = props.retainedTurns ?? 0;
+    const wanted = props.keepRecentTurnsUsed;
+    const messages = props.retainedMessages;
+    // THE TAIL IS MESSAGES, NOT TURNS (review). The dominant relaxed shape is one
+    // prompt plus a hundred tool calls, so `retainedTurns` is 0 while forty messages
+    // were kept verbatim: a line reading "kept 0 recent turns" would report a total
+    // loss that did not happen. Whenever the count is available it leads, and the
+    // turn arithmetic follows as the explanation rather than as the headline.
+    if (messages !== undefined && wanted !== undefined) {
+        return `kept the last ${messages} messages - ${turns} of the ${wanted} requested turns, ` +
+            'since this run had too few user turns';
+    }
+    if (messages !== undefined)
+        return `kept the last ${messages} messages verbatim`;
+    return wanted === undefined
+        ? `kept the last ${turns} turns - this run had too few user turns to keep more`
+        : `kept ${turns} of the ${wanted} requested turns - this run had too few user turns`;
+}
+/**
+ * The digest-elision disclosure (never-fires A1).
+ *
+ * The digest never rejects for length any more; it keeps the first and last
+ * entries verbatim and elides the middle. The elided messages cannot be quoted by
+ * the summarizer, so the card says so rather than presenting a summary as if it
+ * had seen everything.
+ */
+function elidedLine(props) {
+    const n = props.elidedMessages ?? 0;
+    if (props.live || n <= 0)
+        return '';
+    return `elided ${n} ${n === 1 ? 'message' : 'messages'} from the summary input - ` +
+        'the middle is summarized without them';
+}
 /**
  * The relief disclosure, on a settled card that ALSO summarized.
  *
@@ -139,6 +198,8 @@ function CompactionCardImpl(props) {
     const head = headline(props, glyphs.arrowRight, dot);
     const detail = detailLine(props);
     const relief = reliefLine(props);
+    const relaxed = relaxedLine(props);
+    const elided = elidedLine(props);
     const showMemory = props.memoryVersion !== 2 || expanded === true;
     const rows = summary && showMemory ? summaryRows(summary, expanded === true) : [];
     const totalRows = summary ? summary.split('\n').filter((l) => l.trim().length > 0).length : 0;
@@ -150,7 +211,7 @@ function CompactionCardImpl(props) {
     // the whole run, losing the status colour along with the motion.
     const animate = live && reducedMotion !== true && caps.unicode;
     return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: theme.accent, bold: true, children: props.trigger === 'manual' ? 'Manual compaction' : props.trigger === 'overflow'
-                            ? 'Overflow: threshold reached' : 'Automatic: threshold reached' }), _jsxs(Text, { color: live ? color : theme.muted, wrap: caps.unicode ? 'truncate' : 'wrap', children: [animate ? (_jsxs(_Fragment, { children: [_jsx(Spinner, { type: "dots" }), ' '] })) : live ? (`${glyphs.spinnerStill} `) : (''), head] })] }), props.memoryVersion === 2 && (_jsxs(Text, { color: theme.muted, children: ["Task memory v2", expanded ? '' : ' (ctrl+o to expand)'] })), detail.length > 0 && (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, children: _jsx(Text, { color: color, wrap: caps.unicode ? 'truncate' : 'wrap', children: detail }) })), relief.length > 0 && (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, children: _jsx(Text, { color: theme.noticeWarn, children: relief }) })), rows.length > 0 && (_jsxs(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, theme.border), children: [rows.map((line, index) => (_jsx(Text, { color: theme.primary, children: line }, index))), hidden > 0 && (_jsxs(Text, { color: theme.muted, children: [glyphs.railEnd, " +", hidden, " more lines (ctrl+o to expand)"] })), hidden === 0 && expanded === true && totalRows > COMPACTION_LIMITS.cardTextRows && (_jsxs(Text, { color: theme.muted, children: [glyphs.railEnd, " ctrl+o to collapse"] }))] }))] }));
+                            ? 'Overflow: threshold reached' : 'Automatic: threshold reached' }), _jsxs(Text, { color: live ? color : theme.muted, wrap: caps.unicode ? 'truncate' : 'wrap', children: [animate ? (_jsxs(_Fragment, { children: [_jsx(Spinner, { type: "dots" }), ' '] })) : live ? (`${glyphs.spinnerStill} `) : (''), head] })] }), props.memoryVersion === 2 && (_jsxs(Text, { color: theme.muted, children: ["Task memory v2", expanded ? '' : ' (ctrl+o to expand)'] })), detail.length > 0 && (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, children: _jsx(Text, { color: color, wrap: caps.unicode ? 'truncate' : 'wrap', children: detail }) })), relief.length > 0 && (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, children: _jsx(Text, { color: theme.noticeWarn, children: relief }) })), relaxed.length > 0 && (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, children: _jsx(Text, { color: theme.muted, children: relaxed }) })), elided.length > 0 && (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, children: _jsx(Text, { color: theme.muted, children: elided }) })), rows.length > 0 && (_jsxs(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, theme.border), children: [rows.map((line, index) => (_jsx(Text, { color: theme.primary, children: line }, index))), hidden > 0 && (_jsxs(Text, { color: theme.muted, children: [glyphs.railEnd, " +", hidden, " more lines (ctrl+o to expand)"] })), hidden === 0 && expanded === true && totalRows > COMPACTION_LIMITS.cardTextRows && (_jsxs(Text, { color: theme.muted, children: [glyphs.railEnd, " ctrl+o to collapse"] }))] }))] }));
 }
 /**
  * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).

package/dist/ui/layout/status-layout.d.ts

@@ -31,6 +31,16 @@ export interface StatusLayoutInput {
     spinner?: string;
     waitingForConfirmation?: boolean;
     stopping?: boolean;
+    /**
+     * Auto-compaction paused itself after repeated no-progress attempts
+     * (context-compaction-never-fires C).
+     *
+     * A SEPARATE FIELD FROM `compacting`, and it renders as a SUFFIX on the context
+     * gauge rather than as a phase word: the fact belongs next to the percentage it
+     * explains ("Context 95% auto-paused"), and the phase slot must keep answering
+     * "is the agent running".
+     */
+    compactionPaused?: boolean;
     compacting?: boolean;
     retryActive?: {
         attempt: number;
@@ -43,6 +53,23 @@ export interface StatusLayoutInput {
     servicesActive?: {
         live: number;
     };
+    /**
+     * Forced team mode is ARMED, with the fan-out count it was armed with
+     * (team-command-forced-dispatch §3.8 / D-9).
+     *
+     * THE ONLY PERSISTENTLY VISIBLE SIGNAL that `/team` happened. The directive is
+     * one turn, the prompt block is invisible, and the panel only appears while a
+     * dispatch runs - so without this chip the answer to "why is my agent
+     * dispatching?" is "remember what you typed". It is read at RENDER time from
+     * `controller.getForcedTeam()`, never mirrored into `ViewState`: a mirror is a
+     * second copy that can disagree, the exact defect §2.4 is about.
+     *
+     * ABSENT means "not armed" and keeps every existing caller's plan BYTE-
+     * IDENTICAL (the same discipline `reserveRight` records below).
+     */
+    forcedTeam?: {
+        count: number;
+    };
     teamActive?: {
         running: number;
         total: number;

package/dist/ui/layout/status-layout.js

@@ -53,6 +53,22 @@ function contextPercent(context) {
     const mark = context.source === 'estimate' || context.deltaTokens > 0 ? '~' : '';
     return mark + (context.pct > 999 ? '>999' : Math.round(context.pct)) + '%';
 }
+/**
+ * The words that ride on the gauge when auto-compaction has given up (C).
+ *
+ * IT RIDES ON THE GAUGE RATHER THAN OCCUPYING ITS OWN FIELD. "Auto-paused" is the
+ * only fact that explains a stuck percentage, so the two belong in one field for
+ * the same reason `/context` prints them on adjacent lines. A second field would
+ * also be the first thing the width ladder drops, and this is precisely the state
+ * that must survive a narrow terminal.
+ *
+ * `paused` at the tight rungs: the full phrase costs twelve cells the row does
+ * not have at rung 3 and beyond, and dropping the fact entirely would be worse
+ * than abbreviating it.
+ */
+function pausedSuffix(full) {
+    return full ? ' auto-paused' : ' paused';
+}
 export function shortDuration(ms) {
     if (!Number.isFinite(ms) || ms <= 0)
         return '0s';
@@ -204,11 +220,21 @@ export function planPrimaryStatusFields(input) {
         const label = (notification ? undefined : feedbackLabel(input, form))
             ?? (full ? labels[1] : rung >= 4 ? labels[0].slice(0, 4) : labels[0]);
         const modeText = modeFieldText(input.mode, input.pendingMode, full);
+        // IMMEDIATELY AFTER `mode`, and kept at EVERY rung: both describe a state
+        // the USER armed, so the row's emphasis budget goes on them and nothing
+        // else (`accent`). It shortens to `T4` instead of disappearing because a
+        // chip that vanishes on a narrow terminal is indistinguishable from a
+        // disarmed session - the one question it exists to answer.
+        const forcedText = input.forcedTeam
+            ? (rung >= 3 ? `T${input.forcedTeam.count}` : `Team ${input.forcedTeam.count}`)
+            : null;
         return statusLinePlan([
             statusField('phase', glyph + (rung >= 5 ? '' : ' ') + label, phaseTone),
             ...(notice ? [statusField('feedback', notice, feedbackTone)] : []),
             ...(modeText ? [statusField('mode', modeText, 'accent')] : []),
-            statusField('context', (full ? 'Context ' : 'C') + pct),
+            ...(forcedText ? [statusField('forcedTeam', forcedText, 'accent')] : []),
+            statusField('context', (full ? 'Context ' : 'C') + pct
+                + (input.compactionPaused === true ? pausedSuffix(full) : '')),
             statusField('thinking', full ? 'Think ' + (thinkingCodes[input.thinkingLevel] ? input.thinkingLevel : '?')
                 : (rung >= 2 ? '' : 'Th:') + code),
             statusField('speed', speed + (full ? ' tok/s' : rung >= 3 ? '/s' : 't/s')),

package/dist/ui/overlays/HelpOverlay.js

@@ -121,7 +121,7 @@ const COMMANDS = [
     ['/theme <name>', 'auto | warm | cool | light'],
     ['/thinking <level>', 'Set thinking level'],
     ['/max-tokens [n|auto]', 'Output token cap; no argument reports the effective one'],
-    ['/team [on|off|max n]', 'Team subagents: status, switch, fan-out width'],
+    ['/team [on|off|<brief>]', 'Force team mode and start now: /team <brief> fans out'],
     ['/fast [on|off|model|review]', 'Fast model tier: status, switch, model, review cadence'],
     ['/kit [list|use <name>]', 'Agent kits: what is in effect, list them, use one for this session'],
     [
@@ -179,12 +179,16 @@ const PLAN_ROWS = [
 ];
 const TEAM_ROWS = [
     ['task', 'The tool the agent uses to run 2-5 subagents in parallel'],
-    ['/team', 'Status: on/off, max subagents, and the live roster'],
-    ['/team on | off', 'Switch team mode for this session (and save it)'],
-    ['/team max <n>', 'Fan-out width, 1-10 (5 by default)'],
+    ['/team <brief>', 'Force it: arms forced mode and starts that work as a turn'],
+    ['/team on | off', 'Arm it without starting, or leave it; the capability is untouched'],
+    ['/team', 'Report the forced state, capacity, the model, and where to change it'],
+    ['-n <n> / --parts a,b', 'Fix the fan-out, or name the split (narrowing is disclosed)'],
+    ['--read-only', 'Every child refuses writes and shell, for research-only fan-outs'],
+    ['Team 4  (T4)', 'The status-bar chip - only while the session is armed'],
     ['--team / --no-team', 'Start a session with team mode on or off (also ARAGON_TEAM=0)'],
     ['team_send / team_wait', 'How subagents message each other; 6 each, one every 15s'],
     ['Ctrl+B / /agents', 'The board: every child, its full facts, its 24-event timeline'],
+    ['Settings > Team', 'Team mode, width (1-10, 8 by default), concurrency, supervisor'],
 ];
 const FAST_ROWS = [
     ['/fast', 'Status: on/off, the model, the cadence, and this session\'s totals'],

package/dist/ui/overlays/SettingsScreen.d.ts

@@ -132,6 +132,20 @@ interface SettingsScreenProps {
      * screen. Absent = omit the row entirely.
      */
     retrySummary?: string;
+    /**
+     * Whether `task` is in this SESSION's tool list, for the `Team` page's
+     * `on (next launch)` disclosure (team-command-forced-dispatch §3.9 / P1-5).
+     *
+     * WITHOUT THIS LINK THE DISCLOSURE CANNOT RENDER. The page is mounted with
+     * `{...props}`, so a prop the screen does not declare reaches it as `undefined`
+     * and `--no-team` users are silently told their saved `on` took effect. The
+     * value is a CONSTRUCTION-TIME snapshot (`--no-team` cannot be undone), which is
+     * why reading it every frame does not conflict with I-7.
+     *
+     * OPTIONAL, like `probe` / `retrySummary` above: every fixture builds this by
+     * literal, and absent honestly means "unknown, so do not disclose".
+     */
+    teamRegistered?: boolean;
 }
 /**
  * The derived, non-editable line under the five fast rows — the sibling of