@aragon-agent/cli 0.6.38 → 0.6.40

package/dist/compaction/types.d.ts

@@ -55,6 +55,23 @@ export type CompactionMode = 'summarized' | 'truncated' | 'relieved' | 'none';
  * thing a CLI-local type is for.
  */
 export type CompactionUiTrigger = 'pressure' | 'overflow' | 'manual';
+/**
+ * Where one attempt currently is, so "compacting context" can also say WHAT it is
+ * doing for the forty-five seconds it is on screen.
+ *
+ * IT EXISTS BECAUSE THE GATES WERE INVISIBLE (context-compaction-never-fires
+ * RC-3). Planning and digesting both run BEFORE any model call, and both used to
+ * be able to reject while the only surface said `Context 95%` and nothing else.
+ * A phase is the CLI's answer to "is this stuck, or merely slow", and it is
+ * CLI-LOCAL for the reason the whole stream is: the engine has no phases, only a
+ * splice.
+ *
+ * THERE IS NO `settled` MEMBER, deliberately: the settle is already the
+ * `compaction_end` record. A phase restating it would give the card two ways to
+ * learn one fact, and the extra phase would race the record whenever the engine's
+ * verdict comes back first.
+ */
+export type CompactionPhase = 'planning' | 'digesting' | 'summarizing' | 'validating' | 'applying';
 /** Whether a figure was measured by the provider or estimated by us. */
 export type PressureSource = 'usage' | 'estimate';
 /** The exact occupancy evidence at the compaction checkpoint. */
@@ -183,6 +200,36 @@ export interface CompactionRecord {
     usage?: TokenUsage;
     /** Set when an overflow attempt halved `keepRecentTurns` for itself (D-24). */
     keepRecentTurnsUsed?: number;
+    /**
+     * Set when `planCompaction` had to relax `keepRecentTurns` to find a cut
+     * (context-compaction-never-fires B).
+     *
+     * DISCLOSED ON THE CARD, never silent: the relaxation trades "the last N turns
+     * are verbatim" for "compaction happens at all", and a user who is not told
+     * which side they got cannot tell a lossless compaction from a lossy one.
+     * `retainedTurns` and `retainedMessages` are what actually survived, so the card
+     * can state all three numbers instead of implying one.
+     */
+    keepRelaxed?: boolean;
+    retainedTurns?: number;
+    /**
+     * How many MESSAGES the relaxed cut left verbatim.
+     *
+     * `retainedTurns` COUNTS USER TURNS, and in the sessions this fix exists for - one
+     * prompt followed by a hundred tool calls - that number is zero even though forty
+     * messages survived word for word. A card reading "kept 0 recent turns" at that
+     * moment says the opposite of what happened, so both numbers are recorded.
+     */
+    retainedMessages?: number;
+    /**
+     * Messages left OUT of the digest text and therefore not quotable by the
+     * summarizer (context-compaction-never-fires A1).
+     *
+     * The elision is LOUD in three places: the digest text itself carries an
+     * `[elided ...]` marker, this field puts the count on the card, and the elided
+     * ids never enter the source map, so a delta citing one is rejected.
+     */
+    elidedMessages?: number;
     /**
      * Present ONLY when tail relief fired (hardening §3.3.4 / W2).
      *
@@ -221,14 +268,24 @@ export interface CompactionSnapshot {
     /** The summarizer's model id, or `''`. */
     model: string;
     /**
-     * How many compactions ANNOUNCED themselves (quiet-noop §6.2 / D-5).
+     * How many compactions ANNOUNCED themselves, i.e. how many cards the user saw.
      *
-     * COMPACTIONS THAT RAN, NOT CHECKPOINTS THAT FIRED. A `pressure` compaction
-     * that declines before calling a model or changing the history never advances
-     * this, which is what keeps the card's `#N` contiguous. `declined` below is
-     * the other half of the same total.
+     * IT COUNTS ATTEMPTS, NOT SPLICES (context-compaction-never-fires C). Before
+     * this change only attempts that committed to work announced, so this was
+     * "compactions that ran"; now every attempt opens a card - including the ones
+     * that decline at the planner or the digest - because a silent decline is
+     * indistinguishable from a dead feature, which is the bug this feature shipped
+     * with. `applied` below is the other half, and `/compact status` prints both.
      */
     compactions: number;
+    /**
+     * How many of those attempts actually replaced the history.
+     *
+     * OPTIONAL SO EVERY EXISTING CONSTRUCTION SITE STAYS UNTOUCHED. Absent means
+     * "not reported", which `/compact status` renders exactly as the pre-change
+     * wording did.
+     */
+    applied?: number;
     /**
      * How many `pressure` checkpoints declined BEFORE committing to any work
      * (quiet-noop D-9 / P1-2).
@@ -260,19 +317,26 @@ export interface CompactionSnapshot {
 /**
  * THE COMPACTION EVENT STREAM.
  *
- * `compaction_start` and `compaction_end` are emitted ONLY for compactions that
- * COMMITTED TO WORK (quiet-noop §3.1): a `pressure` compaction that declines
- * before calling a model or changing the history emits NEITHER, and is
- * deliberately indistinguishable from a turn at which `shouldCompact` returned
- * false. `manual` and `overflow` always emit both.
+ * EVERY ATTEMPT ANNOUNCES ITSELF (context-compaction-never-fires C, which
+ * REVERSES quiet-noop §3.1). A `pressure` compaction used to reach
+ * `compaction_start` only after it committed to paid work, so an attempt that
+ * declined at the planner (`nothing_to_drop`) or at the digest budget produced
+ * no card at all - and a user sitting at 95 % with a dead auto-compaction had no
+ * way to learn that the feature was trying and failing 96 times. The card is now
+ * opened at the entry of `compact()` and ALWAYS settled, so `#N` counts attempts
+ * and the transcript carries one line per attempt, applied or not.
+ *
+ * WHY THE OLD DESIGN WAS DEFENSIBLE AND IS STILL WRONG. Its stated worry was a
+ * red `context not compacted` card every two turns flooding the transcript. The
+ * guards bound that to `stuckLimit` declines per run (`limits.ts`), and after
+ * them the auto path self-disables and says so once - so the flood never
+ * happens, while the silence happened every time.
  *
  * The pair is still BALANCED: every `compaction_start` is followed by exactly
  * one `compaction_end` (a `finally` in the engine guarantees the verdict, and
  * `settlePending` synthesizes a skeleton record when the compactor's own has not
- * arrived). Consumers that count PAIRS are unaffected; consumers that counted
- * ATTEMPTS must read `/compact status` or the JSONL diagnostic log instead -
- * CORE's own `compaction_start` / `compaction_end` pair still fires for every
- * attempt, declined or not, and that is the stream the log subscribes to.
+ * arrived). `phase` events land BETWEEN them, in order, and only for the live
+ * card.
  */
 export type CompactionEvent = {
     type: 'compaction_start';
@@ -282,6 +346,10 @@ export type CompactionEvent = {
 } | {
     type: 'compaction_end';
     record: CompactionRecord;
+} | {
+    type: 'phase';
+    index: number;
+    phase: CompactionPhase;
 } | ({
     type: 'usage';
     usage: TokenUsage;

package/dist/compaction/wiring.d.ts

@@ -27,14 +27,19 @@ import type { CompactionIdentity } from './memory-identity.js';
  * `/compact off`, `/compact threshold 0.8` and a settings-screen save take effect
  * mid-session without touching the `Agent`.
  *
- * DECLINED COMPACTIONS PRODUCE NO CLI EVENTS (quiet-noop §3.6). A `pressure`
- * compaction that changed nothing, called nothing and spent nothing never emits
- * `compaction_start`, so `onCompactorEvent` never opens a card and `settlePending`
- * finds neither a held record nor a skeleton to synthesize. CORE still emits its
- * own pair for every attempt, which is why `settlePending` still runs - it just
- * refreshes the snapshot and returns. `onCompactorEvent`'s `if (!this.open)`
- * guard is now unreachable for declines and stays for the abort race it was
- * written for.
+ * DECLINED COMPACTIONS ARE VISIBLE (context-compaction-never-fires C, which
+ * REVERSES quiet-noop §3.6). A `pressure` compaction that changes nothing used to
+ * emit no `compaction_start`, so `onCompactorEvent` never opened a card and the
+ * only trace of an attempt was a counter in `/compact status`. The compactor now
+ * announces at the entry of `compact()` and always settles, so this class holds a
+ * record for every attempt and `settlePending` emits it - declined attempts
+ * included, with the reason on the card.
+ *
+ * WHAT THE OLD RULE PROTECTED IS STILL PROTECTED, by a different mechanism: the
+ * transcript cannot flood, because `maxPerRun` (5) and `stuckLimit` (2) bound the
+ * attempts and the auto path self-disables and says so once. `onCompactorEvent`'s
+ * `if (!this.open)` guard is still load-bearing: it is what stops a late record
+ * from re-opening a card the engine's verdict already closed.
  */
 import type { ModelRole } from '../config/model-profiles.js';
 import { type AgentEvent, type ContextManager, type Message, type ModelInfo, type ModelRef, type ProviderRegistry, type ProviderRegistryOptions, type TokenUsage } from '@aragon-agent/core';

package/dist/compaction/wiring.js

@@ -368,6 +368,7 @@ export class CompactionWiring {
             live: this.enabled && summarizer !== null,
             model: summarizer?.ref.modelId ?? '',
             compactions: totals.compactions,
+            applied: totals.applied,
             // OMITTED WHEN ZERO (quiet-noop D-9), so a healthy session's snapshot is
             // shaped exactly as it was before this feature and `/compact status` has
             // nothing extra to render.

package/dist/config/cli-commands.d.ts

@@ -34,6 +34,17 @@ export declare const TEAM_CONFIG_SET_KEYS: readonly ["team.enabled", "team.maxSu
  * so `jobs.waitSeconds` resolves and `jobs.mirror.enabled` would not.
  */
 export declare const JOBS_CONFIG_SET_KEYS: readonly ["jobs.enabled", "jobs.waitSeconds", "jobs.stallSeconds", "jobs.persistLog", "jobs.noticeSteer"];
+/**
+ * Config keys under `taskSummary.` that `aragon config set` accepts
+ * (tui-shortcut-drawer-and-task-summary §4.8).
+ *
+ * BOTH SWITCHES ARE WRITABLE, which is why this section needs the same pair every
+ * other writable section has: a membership set here AND a case in `cli.tsx`'s
+ * `runConfigSet`. Only the second makes the key actually write; only the first
+ * makes it pass the `Unknown config key` gate. `config.test.ts`'s static guard is
+ * what catches a half-done pair, and `jobs` is the precedent it was written for.
+ */
+export declare const TASK_SUMMARY_CONFIG_SET_KEYS: readonly ["taskSummary.enabled", "taskSummary.fallback"];
 /**
  * Config keys under `retry.` that `aragon config set` accepts
  * (llm-api-retry-backoff §8.2).
@@ -108,6 +119,18 @@ export declare function applyLogConfigSet(key: string, value: string): Partial<P
  * recorded in `store.ts`.
  */
 export declare function applyJobsConfigSet(key: string, value: string): Partial<PersistedConfig> | null;
+/**
+ * Translate a `taskSummary.*` dotted key into a patch, or `null` for anything else.
+ *
+ * THE PATCH IS A PARTIAL SECTION, safe only because `updatePersistedConfig`
+ * deep-merges `taskSummary` - the eighth time that trap is recorded in `store.ts`.
+ * Both values are booleans, so `isTrue` is the whole parser. It accepts `1` and
+ * `true` only, which is NARROWER than the env layer's `on`/`yes` on purpose: an
+ * environment switch is typed by a human at a shell prompt, while `config set` is
+ * also driven by scripts, and `config set taskSummary.enabled on` should fail loudly
+ * rather than silently mean `false`.
+ */
+export declare function applyTaskSummaryConfigSet(key: string, value: string): Partial<PersistedConfig> | null;
 /**
  * Translate a `team.*` dotted key into a patch, or `null` for anything else.
  *

package/dist/config/cli-commands.js

@@ -67,6 +67,20 @@ export const JOBS_CONFIG_SET_KEYS = [
     'jobs.persistLog',
     'jobs.noticeSteer',
 ];
+/**
+ * Config keys under `taskSummary.` that `aragon config set` accepts
+ * (tui-shortcut-drawer-and-task-summary §4.8).
+ *
+ * BOTH SWITCHES ARE WRITABLE, which is why this section needs the same pair every
+ * other writable section has: a membership set here AND a case in `cli.tsx`'s
+ * `runConfigSet`. Only the second makes the key actually write; only the first
+ * makes it pass the `Unknown config key` gate. `config.test.ts`'s static guard is
+ * what catches a half-done pair, and `jobs` is the precedent it was written for.
+ */
+export const TASK_SUMMARY_CONFIG_SET_KEYS = [
+    'taskSummary.enabled',
+    'taskSummary.fallback',
+];
 /**
  * Config keys under `retry.` that `aragon config set` accepts
  * (llm-api-retry-backoff §8.2).
@@ -219,6 +233,28 @@ export function applyJobsConfigSet(key, value) {
             return null;
     }
 }
+/**
+ * Translate a `taskSummary.*` dotted key into a patch, or `null` for anything else.
+ *
+ * THE PATCH IS A PARTIAL SECTION, safe only because `updatePersistedConfig`
+ * deep-merges `taskSummary` - the eighth time that trap is recorded in `store.ts`.
+ * Both values are booleans, so `isTrue` is the whole parser. It accepts `1` and
+ * `true` only, which is NARROWER than the env layer's `on`/`yes` on purpose: an
+ * environment switch is typed by a human at a shell prompt, while `config set` is
+ * also driven by scripts, and `config set taskSummary.enabled on` should fail loudly
+ * rather than silently mean `false`.
+ */
+export function applyTaskSummaryConfigSet(key, value) {
+    const patch = (taskSummary) => ({ taskSummary });
+    switch (key) {
+        case 'taskSummary.enabled':
+            return patch({ enabled: isTrue(value) });
+        case 'taskSummary.fallback':
+            return patch({ fallback: isTrue(value) });
+        default:
+            return null;
+    }
+}
 /**
  * Translate a `team.*` dotted key into a patch, or `null` for anything else.
  *

package/dist/config/env.js

@@ -308,16 +308,29 @@ export function readEnvConfig() {
             partial.jobs = section;
     }
     // ARAGON_PROMPTS=0 is the kill switch for the whole quick-prompt surface: no
-    // `Ctrl+P`, no header hint, and `/prompts` reports that the feature is off
-    // (D-19 / AC-31). ONLY `enabled` IS REACHABLE HERE. `insertMode` and `hint` are
-    // preferences a human sets once, and an environment variable that could silently
-    // flip a fill into "overwrite what you had typed" is not a kill switch.
+    // `Ctrl+P` and `/prompts` reports that the feature is off (D-19 / AC-31). ONLY
+    // `enabled` IS REACHABLE HERE. `insertMode` is a preference a human sets once, and
+    // an environment variable that could silently flip a fill into "overwrite what you
+    // had typed" is not a kill switch.
     const prompts = process.env.ARAGON_PROMPTS?.trim().toLowerCase();
     if (prompts !== undefined && prompts.length > 0) {
         partial.prompts = {
             enabled: prompts === '1' || prompts === 'true' || prompts === 'on' || prompts === 'yes',
         };
     }
+    // ARAGON_TASK_SUMMARY is the header label's kill switch
+    // (tui-shortcut-drawer-and-task-summary §4.8 / P2-7), and it maps `enabled` and
+    // NOTHING ELSE - the same wording and the same reason as the block above. A
+    // variable that could also flip `fallback` would let an environment decide
+    // whether a FAILED call shows the user's own words or an empty cell, which is a
+    // silent change to what the header claims to know.
+    const taskSummary = process.env.ARAGON_TASK_SUMMARY?.trim().toLowerCase();
+    if (taskSummary !== undefined && taskSummary.length > 0) {
+        partial.taskSummary = {
+            enabled: taskSummary === '1' || taskSummary === 'true'
+                || taskSummary === 'on' || taskSummary === 'yes',
+        };
+    }
     const retry = process.env.ARAGON_RETRY?.trim().toLowerCase();
     const retryMax = process.env.ARAGON_RETRY_MAX?.trim();
     if ((retry !== undefined && retry.length > 0) || (retryMax !== undefined && retryMax.length > 0)) {

package/dist/config/load.js

@@ -7,7 +7,7 @@
  */
 import process from 'node:process';
 import { JOB_WAIT_MARGIN_MS } from '../proc/limits.js';
-import { DEFAULT_CONFIG, DEFAULT_SCROLL_MODE, IDLE_TIMEOUT_MARGIN_MS, clampAskRounds, clampDensity, clampHumanTimeout, clampCompactionConfig, clampLogConfig, clampFastConfig, clampRetryConfig, clampSkillsConfig, clampTeamConfig, clampTodoConfig, clampBashConfig, clampJobsConfig, clampPromptsConfig, clampUpdateConfig, clampTheme, clampThinkingLevel, clampContextWindow, clampMaxTokens, clampMaxRenderInterval, clampScrollMode, clampScrollResumeMs, clampTranscriptRetain, clampTranscriptWindow, coercePositiveInt, isAutoToken, isSkillsToolPolicyMode, legacyTeamCeilingPatch, parseThresholdInput, } from './schema.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';
 import { projectModelProfiles, resolveModelProfileState, resolveModelRoleKey, } from './model-profile-resolution.js';
@@ -517,6 +517,49 @@ function migrateLegacyTeamCeilings(raw) {
         keys: Object.keys(patch).join(','),
     });
 }
+/**
+ * Rewrite the cli<=0.6.x persisted fan-out defaults (5 / 3) to the new ones
+ * (8 / 8) and persist the change (subagent-fanout D-3 / D-4).
+ *
+ * ONE-SHOT and IDEMPOTENT, and the FILE LAYER ONLY, for the reasons
+ * `migrateLegacyTeamCeilings` records one block above: env (`ARAGON_TEAM_MAX`)
+ * and `--team-max` are THIS launch's intent and are never rewritten, the raw
+ * file object is patched IN PLACE so the `file` layer resolved below already
+ * reads 8/8, and a failed write leaves the marker absent so the next launch
+ * retries the whole migration.
+ *
+ * WHY A MARKER AND NOT JUST THE NUMBERS: `fanoutMigrated` is what keeps a user
+ * who deliberately returns to 5/3 from being migrated again on every launch
+ * (`legacyTeamFanoutPatch` returns `null` once it is set). The price of
+ * exact-equality is that one deliberate 5/3 is widened once; the marker bounds
+ * that to at most once.
+ */
+function migrateLegacyTeamFanout(raw) {
+    const patch = legacyTeamFanoutPatch(raw?.team);
+    if (patch === null)
+        return;
+    // READ THE STARTING POINT BEFORE THE IN-PLACE PATCH, and never hardcode
+    // `5/3`: rule 4 of the matcher accepts an ABSENT `maxConcurrent`, in which
+    // case the honest starting point is "unset" - a log line the user cannot find
+    // on disk is worse than no log line.
+    const from = `${LEGACY_TEAM_FANOUT_DEFAULTS.maxSubagents}/${raw?.team?.maxConcurrent ?? 'unset'}`;
+    // THE FULL SECTION, not the bare patch: the write port types `team` as a
+    // whole `TeamConfig`, and the section the file already carries plus the three
+    // keys IS the section we want on disk.
+    const migratedTeam = { ...raw.team, ...patch };
+    Object.assign(raw.team, patch);
+    try {
+        updatePersistedConfig({ team: migratedTeam });
+    }
+    catch {
+        // Unwritable config dir: in-memory values are already migrated; retry next
+        // launch (idempotent, because the marker never made it to disk).
+    }
+    getLogger().warn('config', 'team_fanout_migrated', {
+        from,
+        to: `${patch.maxSubagents}/${patch.maxConcurrent}`,
+    });
+}
 /**
  * Resolve the effective config by merging all layers, then derive the runtime
  * (non-persisted) fields and enforce the timeout invariant.
@@ -527,6 +570,12 @@ export function loadConfig(flags = {}, options = {}) {
     loadDotenv(cwd);
     const read = readConfigFile();
     migrateLegacyTeamCeilings(read.config);
+    // THE NEXT LINE, not a shared pass: the two migrations are independent, and
+    // keeping them as two statements keeps each one's "returns null when nothing
+    // matches" contract visible. Both run BEFORE `projectModelProfiles` for the
+    // same reason - the `file` layer resolved below must already read the migrated
+    // numbers, and neither migration needs a second projection path.
+    migrateLegacyTeamFanout(read.config);
     const projection = projectModelProfiles(read.config ?? {});
     const file = projection.file;
     const env = readEnvConfig();
@@ -570,7 +619,6 @@ export function loadConfig(flags = {}, options = {}) {
     // a config file that turned plan mode on.
     const startInPlanMode = pick(flags.plan, env.partial.planModeDefault, file.planModeDefault) ??
         DEFAULT_CONFIG.planModeDefault;
-    const planModeMaxAskRounds = clampAskRounds(file.planModeMaxAskRounds, DEFAULT_CONFIG.planModeMaxAskRounds);
     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
@@ -706,7 +754,6 @@ export function loadConfig(flags = {}, options = {}) {
         // From `<home>/state.json`, not the config file — see `ui-state.ts`.
         submitCount: readSubmitCount(),
         startInPlanMode,
-        planModeMaxAskRounds,
         planModeHumanTimeoutMs,
         skills,
         skillsRuntime: {
@@ -738,6 +785,11 @@ export function loadConfig(flags = {}, options = {}) {
         // two different shapes on `CliConfig`.
         prompts: clampPromptsConfig({ ...DEFAULT_CONFIG.prompts, ...(env.partial.prompts ?? {}),
             ...(file.prompts ?? {}) }),
+        // The header task label's two switches, composed EXACTLY like `prompts` above:
+        // env + file + clamp, so an `ARAGON_TASK_SUMMARY=0` and a file-only
+        // `taskSummary.enabled: false` cannot arrive as two different shapes.
+        taskSummary: clampTaskSummaryConfig({ ...DEFAULT_CONFIG.taskSummary,
+            ...(env.partial.taskSummary ?? {}), ...(file.taskSummary ?? {}) }),
         cwd,
         color,
         colorLevel,

package/dist/config/schema.d.ts

@@ -206,15 +206,15 @@ export declare const DEFAULT_SCROLL_RESUME_MS = 5000;
  * Exactly the trap `retry.maxRetries` needed this helper for.
  */
 export declare function clampScrollResumeMs(v: unknown, fallback: number): number;
-/** `ask_user` calls allowed per user turn. */
-export declare const DEFAULT_PLAN_MAX_ASK_ROUNDS = 4;
 /**
  * Ceiling on ONE human wait, in ms. Thirty minutes is far outside "the user
  * went to get coffee", but a ceiling has to exist: an unattended terminal must
  * not wedge a CI job or a stale ssh session forever.
+ *
+ * THIS IS NOT A ROUND LIMIT and the distinction matters. It bounds a single wait
+ * (liveness); it says nothing about how many times the model may ask.
  */
 export declare const DEFAULT_PLAN_HUMAN_TIMEOUT_MS = 1800000;
-export declare function clampAskRounds(v: unknown, fallback: number): number;
 export declare function clampHumanTimeout(v: unknown, fallback: number): number;
 export interface SkillsConfig {
     enabled: boolean;
@@ -259,6 +259,18 @@ export interface SkillsConfig {
      * just be a second decorative field.
      */
     toolPolicy: SkillsToolPolicyMode;
+    /**
+     * Automatic skill triage (skill-triage-and-unbounded-ask §4.2.9): compute a
+     * short candidate list for each new task and put it in the system prompt, so
+     * "is a skill applicable?" becomes a question the protocol forces the model to
+     * answer rather than one it has to remember to ask.
+     *
+     * DEFAULT ON, and OFF must be byte-identical to the pre-feature prompt. That is
+     * what the block's conditional splice in `buildSystemPrompt` guarantees
+     * (invariant I-T1) — a permanently-on block would be a prompt change nobody
+     * could turn off.
+     */
+    triage: boolean;
 }
 export declare const SKILLS_INTEGRITY_MODES: readonly ["off", "warn", "strict"];
 export type SkillsIntegrityMode = (typeof SKILLS_INTEGRITY_MODES)[number];
@@ -343,6 +355,16 @@ export interface TeamConfig {
      * failed subagent.
      */
     maxConcurrent: number;
+    /**
+     * The one-shot marker `migrateLegacyTeamFanout` writes (subagent-fanout
+     * D-3), and NOTHING else may ever write it.
+     *
+     * It exists because the fan-out default moved 5/3 -> 8/8 while every save
+     * materializes the whole section: without a marker, a user who deliberately
+     * returns to 5/3 is migrated back to 8/8 on the next launch, for ever. Absent
+     * means "not yet migrated"; it is never written as `false`.
+     */
+    fanoutMigrated?: boolean;
     /**
      * One child's wall clock before its own abort. `0` (the default) means NO
      * ceiling: a subagent runs until it finishes or is aborted, exactly like
@@ -465,6 +487,40 @@ export declare const LEGACY_TEAM_CEILING_DEFAULTS: Readonly<{
  * equality test lives beside the constants it reads.
  */
 export declare function legacyTeamCeilingPatch(raw: unknown): Partial<TeamConfig> | null;
+/**
+ * The fan-out defaults cli <= 0.6.x persisted as its OWN defaults
+ * (subagent-fanout F-2 / R-1).
+ *
+ * THE SAME TRAP AS THE CEILINGS ABOVE, ONE SECTION OVER. `mergePersistedConfig`
+ * writes the WHOLE `team` section on every save, so a user who has ever touched
+ * any setting carries this exact pair in `config.json` - changing
+ * `DEFAULT_TEAM_CONFIG` alone would never reach them, and they would keep
+ * seeing "only 3 subagents at once" for ever.
+ */
+export declare const LEGACY_TEAM_FANOUT_DEFAULTS: {
+    readonly maxSubagents: 5;
+    readonly maxConcurrent: 3;
+};
+/**
+ * The `{ maxSubagents, maxConcurrent, fanoutMigrated }` patch for the legacy
+ * default pair, or `null` when nothing matches (subagent-fanout D-3).
+ *
+ * EXACT-EQUALITY ONLY, the rule `legacyTeamCeilingPatch` records: a value that
+ * differs was a deliberate user choice and survives untouched. Two differences
+ * from that function, both deliberate:
+ *
+ *  - `fanoutMigrated: true` short-circuits to `null`. That is what makes "the
+ *    user changed their mind and went back to 5/3" stick: without it the next
+ *    launch would migrate them again, every launch, for ever.
+ *  - `maxConcurrent` is allowed to be ABSENT as well as 3, because a
+ *    hand-written section may name only one key and a half-written pair is
+ *    still the legacy intent, not a user decision.
+ *
+ * Pure on purpose: `loadConfig` decides WHERE the patch is applied and
+ * persisted; this function only answers WHICH keys match, so the equality test
+ * lives beside the constants it reads.
+ */
+export declare function legacyTeamFanoutPatch(raw: unknown): Partial<TeamConfig> | null;
 export interface TodoConfig {
     /** Register `todo_write` at all. Default TRUE. */
     enabled: boolean;
@@ -886,8 +942,6 @@ export interface PromptsConfig {
      * `insert` keeps the user's words; `replace` overwrites them.
      */
     insertMode: 'insert' | 'replace';
-    /** Whether the header's right-hand column may teach `^P prompts`. */
-    hint: boolean;
 }
 export declare const DEFAULT_PROMPTS_CONFIG: PromptsConfig;
 /**
@@ -899,6 +953,35 @@ export declare const DEFAULT_PROMPTS_CONFIG: PromptsConfig;
  * what the user has already typed into the composer.
  */
 export declare function clampPromptsConfig(raw: unknown): PromptsConfig;
+/**
+ * The task label's two switches (tui-shortcut-drawer-and-task-summary §4.8).
+ *
+ * ONE LEVEL DEEP, like every section beside it: `runConfigGet` splits on a single
+ * dot, so `taskSummary.enabled` resolves and a nested key would not (F-18).
+ *
+ * NEITHER KEY IS ABOUT THE LABEL'S CONTENT. `enabled` is the kill switch: off
+ * means no call is made and no cell is drawn. `fallback` decides what happens when
+ * the call cannot produce a label - the deterministic verbatim-prefix floor, or
+ * nothing at all. Both are BEHAVIOUR, which is why they are here rather than in
+ * `fast/limits.ts` (F-13).
+ */
+export interface TaskSummaryConfig {
+    /** The kill switch. `false` removes the header cell and the automatic call. */
+    enabled: boolean;
+    /** The deterministic verbatim-prefix floor (D-9). `false` = show nothing instead. */
+    fallback: boolean;
+}
+export declare const DEFAULT_TASK_SUMMARY_CONFIG: TaskSummaryConfig;
+/**
+ * THE single gate for every `taskSummary` read AND write, like the twelve sections
+ * above it.
+ *
+ * BOTH DEFAULTS ARE `true`, AND THE DIRECTION MATTERS: a corrupt or hand-edited
+ * section must not silently switch off a feature the user asked for, and - more
+ * importantly - it must not switch off the FLOOR, which is the only thing standing
+ * between a failed call and an empty header cell.
+ */
+export declare function clampTaskSummaryConfig(raw: unknown): TaskSummaryConfig;
 /**
  * Parse `0.9`, `90%` or `90` into a ratio, or `null` when it is neither.
  *
@@ -1037,8 +1120,6 @@ export interface PersistedConfig {
     scrollResumeMs: number;
     /** Start every session in PLAN mode (plan-mode §4.4). */
     planModeDefault: boolean;
-    /** `ask_user` rounds allowed per user turn; clamped to [1, 10]. */
-    planModeMaxAskRounds: number;
     /** Ceiling on a single human wait in ms; clamped to [60_000, 7_200_000]. */
     planModeHumanTimeoutMs: number;
     /** Skill system settings. The SECOND nested object in this file after apiKeys. */
@@ -1061,8 +1142,10 @@ export interface PersistedConfig {
     bash: BashConfig;
     /** Background jobs and bounded waiting. The ELEVENTH; scalars only (see JobsConfig). */
     jobs: JobsConfig;
-    /** Quick prompts. The TWELFTH; three scalars (see PromptsConfig). */
+    /** Quick prompts. The TWELFTH; two scalars (see PromptsConfig). */
     prompts: PromptsConfig;
+    /** The header task label. The THIRTEENTH; two scalars (see TaskSummaryConfig). */
+    taskSummary: TaskSummaryConfig;
 }
 export declare const DEFAULT_CONFIG: PersistedConfig;
 /**
@@ -1089,6 +1172,29 @@ export declare const LEGACY_STATE_KEYS: readonly ["promptHistory", "submitCount"
  * one door for both directions.
  */
 export declare function stripLegacyStateKeys<T extends object>(raw: T): T;
+/**
+ * Config keys whose MEANING was removed, mapped to the explanation a user gets if
+ * they still try to set one.
+ *
+ * SEPARATE FROM `LEGACY_STATE_KEYS`, because the disposition differs: those keys'
+ * values were MOVED somewhere else, while these have nowhere to go — the feature
+ * they configured no longer exists. Merging the two lists would erase that
+ * difference at exactly the moment someone is reading the file to find out what
+ * happened to their setting.
+ *
+ * Stripped on the READ side for the same reason `stripLegacyStateKeys` is:
+ * `loadPersistedConfig()` merges `{ ...DEFAULT_CONFIG, ...partial }`, so a key
+ * left on disk rides that spread into memory and `updatePersistedConfig` writes it
+ * straight back. The user deletes the line, launches once, and watches it return.
+ */
+export declare const RETIRED_CONFIG_KEYS: Readonly<Record<string, string>>;
+/**
+ * THE single gate that keeps retired keys out of `config.json`. Applied on the
+ * read side, so it is self-healing: every write is read-strip-merge-write, and a
+ * hand-edited file, a downgrade to an older CLI and back, or a half-finished
+ * migration all converge on a clean file at the next write.
+ */
+export declare function stripRetiredConfigKeys<T extends object>(raw: T): T;
 export interface CliConfig {
     /** A committed model snapshot failed to apply; no further requests may start. */
     modelSettingsRestartRequired?: boolean;
@@ -1283,7 +1389,6 @@ export interface CliConfig {
      * live mode from here on belongs to the controller.
      */
     startInPlanMode: boolean;
-    planModeMaxAskRounds: number;
     planModeHumanTimeoutMs: number;
     skills: SkillsConfig;
     /** Flag/env-only skill switches for this run (§7.5). Never persisted. */
@@ -1406,7 +1511,7 @@ export interface CliConfig {
      * scalars, one level deep.
      *
      * ON `CliConfig` AS WELL AS `PersistedConfig`, for the reason every section above
-     * records: `App` reads `cfg.prompts?.enabled` / `.hint` / `.insertMode` from a
+     * records: `App` reads `cfg.prompts?.enabled` / `.insertMode` from a
      * `CliConfig`, so a key added to the persisted shape alone would round-trip
      * through the `config` commands, appear in `config list`, and change nothing.
      *
@@ -1419,6 +1524,16 @@ export interface CliConfig {
      * disabled or destructive one.
      */
     prompts?: PromptsConfig;
+    /**
+     * The header task label (tui-shortcut-drawer-and-task-summary §4.8). The
+     * THIRTEENTH nested object; two scalars, one level deep.
+     *
+     * OPTIONAL HERE FOR THE SAME REASON AS `prompts` ABOVE: `CliConfig` is built by
+     * hand in many fixtures, and every reader uses `!== false`, so a missing section
+     * behaves exactly like a default session (label on, floor on) rather than like a
+     * switched-off feature.
+     */
+    taskSummary?: TaskSummaryConfig;
     /**
      * Lifetime submit count driving the composer hint fade (`HINT_FADE_AFTER`).
      *