@aragon-agent/cli 0.6.38 → 0.6.39

package/dist/cli.js

@@ -25,7 +25,7 @@ import { formatMigrationNotice, migrateLegacyState } from './config/migrate-lega
 import { formatHomeMigrationNotice, migrateToHome } from './config/migrate-home.js';
 import { migrateStateOutOfConfig } from './config/migrate-state-out-of-config.js';
 import { runHistoryCommand } from './config/history-commands.js';
-import { COMPACTION_CONFIG_SET_KEYS, FAST_CONFIG_SET_KEYS, LOG_CONFIG_SET_KEYS, RETRY_CONFIG_SET_KEYS, TEAM_CONFIG_SET_KEYS, JOBS_CONFIG_SET_KEYS, UPDATE_CONFIG_SET_KEYS, applyCompactionConfigSet, applyFastConfigSet, applyLogConfigSet, applyRetryConfigSet, applyTeamConfigSet, applyJobsConfigSet, applyUpdateConfigSet, runConfigEdit, runConfigGet, runConfigHome, runConfigList, warnIfRedactionDisabled, } from './config/cli-commands.js';
+import { COMPACTION_CONFIG_SET_KEYS, FAST_CONFIG_SET_KEYS, LOG_CONFIG_SET_KEYS, RETRY_CONFIG_SET_KEYS, TEAM_CONFIG_SET_KEYS, JOBS_CONFIG_SET_KEYS, TASK_SUMMARY_CONFIG_SET_KEYS, UPDATE_CONFIG_SET_KEYS, applyCompactionConfigSet, applyFastConfigSet, applyLogConfigSet, applyRetryConfigSet, applyTeamConfigSet, applyJobsConfigSet, applyTaskSummaryConfigSet, applyUpdateConfigSet, runConfigEdit, runConfigGet, runConfigHome, runConfigList, warnIfRedactionDisabled, } from './config/cli-commands.js';
 import { attachAgentEvents, attachTeamEvents, installLogging, setScreenRestore, setSignalTerminator, } from './logging/install.js';
 import { getLogger } from './logging/logger.js';
 import { runLogsCommand } from './logging/cli-commands.js';
@@ -276,15 +276,19 @@ function makeController(flags, opts = { interactive: true }) {
         version: VERSION,
         todoPanelCapable,
         confirm: (req) => confirmBridge.handler ? confirmBridge.handler(req) : Promise.resolve(true),
-        approval: opts.interactive
-            ? {
-                // Read live on every call: the App's effect cleanup nulls the handler
-                // on unmount, and a cached `true` would keep the gate open after the
-                // human channel is gone.
-                canPrompt: () => confirmBridge.handler !== null,
-                request: (req) => confirmBridge.handler ? confirmBridge.handler(req) : Promise.resolve(false),
-            }
-            : DENY_ALL_APPROVAL,
+        // THE TWO CAN NEVER BOTH BE PRESENT: `interactive: false` is the only path
+        // that supplies a bridge gate, and the interactive branch is the only one that
+        // reads the overlay bridge. `??` keeps `-p`'s deny-all default byte-identical.
+        approval: opts.approval ??
+            (opts.interactive
+                ? {
+                    // Read live on every call: the App's effect cleanup nulls the handler
+                    // on unmount, and a cached `true` would keep the gate open after the
+                    // human channel is gone.
+                    canPrompt: () => confirmBridge.handler !== null,
+                    request: (req) => confirmBridge.handler ? confirmBridge.handler(req) : Promise.resolve(false),
+                }
+                : DENY_ALL_APPROVAL),
         notify: (level, text) => {
             if (!opts.interactive)
                 process.stderr.write(`[skills] ${level}: ${text}\n`);
@@ -294,17 +298,36 @@ function makeController(flags, opts = { interactive: true }) {
         // render a question wizard or a plan card. Headless gets the fail-closed
         // gate, whose STATIC `neverPrompts` is also what stops `createPlanTools`
         // registering two tools the model could never use there.
-        humanInput: opts.interactive
-            ? {
-                // Live probe, never cached — same contract as `approval` above.
-                canPrompt: () => humanInputBridge.handler !== null,
-                request: (req, signal) => humanInputBridge.handler
-                    ? humanInputBridge.handler(req, signal)
-                    : Promise.resolve(null),
-            }
-            : DENY_ALL_HUMAN_INPUT,
+        humanInput: opts.humanInput ??
+            (opts.interactive
+                ? {
+                    // Live probe, never cached - same contract as `approval` above.
+                    canPrompt: () => humanInputBridge.handler !== null,
+                    request: (req, signal) => humanInputBridge.handler
+                        ? humanInputBridge.handler(req, signal)
+                        : Promise.resolve(null),
+                }
+                : DENY_ALL_HUMAN_INPUT),
         ...(opts.permission ? { permission: opts.permission } : {}),
         ...(opts.appendSystemPrompt ? { appendSystemPrompt: opts.appendSystemPrompt } : {}),
+        // SPREAD, never `toolGate: opts.toolGate`: with no gate the deps bag has no
+        // such key, `createBuiltinTools` never enters its mapping branch, and the tool
+        // array stays provably identical outside bridge mode (I-1).
+        ...(opts.toolGate ? { toolGate: opts.toolGate } : {}),
+        ...(opts.toolGateForChild ? { toolGateForChild: opts.toolGateForChild } : {}),
+        ...(opts.decisionBudgetMs !== undefined ? { decisionBudgetMs: opts.decisionBudgetMs } : {}),
+        // THE R3 PAIR, AND THIS LINE IS THE DIFFERENCE BETWEEN A WORKING FEATURE AND A DEAD
+        // ONE (headless-request-scope-and-typed-result section 2.6 rows 11/17). This factory
+        // takes `deps` as a bag and FORWARDS ONLY WHAT IS NAMED HERE, so a new dep that is
+        // not spread below is dropped in silence: every unit test that stubs the factory
+        // keeps passing while the real binary never registers the tool. That is the D-12
+        // defect this project has already paid for once, which is why both keys are spread
+        // conditionally and adjacent to each other.
+        ...(opts.resultTool ? { resultTool: opts.resultTool } : {}),
+        ...(opts.structuredResultBlock
+            ? { structuredResultBlock: opts.structuredResultBlock }
+            : {}),
+        ...(opts.hookRunner ? { hookRunner: opts.hookRunner } : {}),
     });
     return { controller, confirmBridge, humanInputBridge };
 }
@@ -322,15 +345,34 @@ function makeExecController(flags, deps) {
     const { controller } = makeController(flags, { interactive: false, ...deps });
     void controller.refreshModelMetadata();
     const logger = getLogger();
-    logger.info('cli', 'run_exec', {});
-    logger.onFailure((reason) => process.stderr.write(`[log] ${reason}\n`));
-    attachAgentEvents(logger, controller);
-    attachTeamEvents(logger, controller);
-    for (const dir of controller.getSkillService().untrustedDirs()) {
-        // STDERR, NEVER STDOUT. In `json` / `stream-json` mode stdout carries
-        // nothing but the schema, and a notice on it would corrupt every consumer.
-        process.stderr.write(`[skills] project skills in ${dir} skipped (untrusted). Run: aragon skills trust ${dir}\n`);
+    // PROCESS-LEVEL WORK HAPPENS ONCE, PER-CONTROLLER WORK HAPPENS EVERY TIME
+    // (headless-threads-and-lifecycle-hooks section 2.3.4, review P1-8).
+    //
+    // The four statements in this branch attach to a PROCESS-WIDE singleton - the logger's
+    // handler list, the log file, the same untrusted skill directories - so running them per
+    // thread would emit N `run_exec` lines and N `[log]` handlers for one process.
+    //
+    // `attachAgentEvents` / `attachTeamEvents` ARE NOT IN THIS BRANCH and must never be:
+    // each binds to THIS controller and returns its own disposer, so skipping them would
+    // mean seven of eight tenants' agent events never reach the log at all. That is an
+    // observability regression, not an optimisation - the opposite of what the first draft of
+    // the design said. The disposers go back to the caller (the thread runtime) and are
+    // invoked when the thread closes (I-T6).
+    // `processLevelMounts` IS EXPLICIT RATHER THAN DERIVED FROM `threadId` (review P1-8):
+    // the default thread carries `threadId: 'main'` like every other thread, so a guard on
+    // "has a thread id" would skip these four statements for ALL of them and leave a
+    // thread-mode run with no `run_exec` line and no `onFailure` handler at all.
+    if (deps.processLevelMounts !== false) {
+        logger.info('cli', 'run_exec', {});
+        logger.onFailure((reason) => process.stderr.write(`[log] ${reason}\n`));
+        for (const dir of controller.getSkillService().untrustedDirs()) {
+            // STDERR, NEVER STDOUT. In `json` / `stream-json` mode stdout carries
+            // nothing but the schema, and a notice on it would corrupt every consumer.
+            process.stderr.write(`[skills] project skills in ${dir} skipped (untrusted). Run: aragon skills trust ${dir}\n`);
+        }
     }
+    const disposers = [attachAgentEvents(logger, controller), attachTeamEvents(logger, controller)];
+    deps.onAttach?.(disposers);
     return controller;
 }
 /**
@@ -1551,6 +1593,12 @@ const CONFIG_SET_KEYS = new Set([
     // own assertion: the static guard in `config.test.ts` matches LITERAL keys in
     // this file, so a spread set is invisible to it (RV-P2-8).
     ...JOBS_CONFIG_SET_KEYS,
+    // `taskSummary.*` keys are handled by `applyTaskSummaryConfigSet`, same reasoning
+    // again (tui-shortcut-drawer-and-task-summary P0-3). WITHOUT THIS LINE the keys
+    // fall through to `Unknown config key`, and WITHOUT the matching case below the
+    // membership set accepts a write that never happens - the two halves the static
+    // guard in `config.test.ts` exists to pair up.
+    ...TASK_SUMMARY_CONFIG_SET_KEYS,
 ]);
 /**
  * `aragon config set maxTokens <n|auto|default>`.
@@ -1701,6 +1749,16 @@ function runConfigSetValue(key, value) {
         process.stdout.write(`Set ${key} = ${String(merged.jobs[field])}\n`);
         return;
     }
+    const taskSummaryPatch = applyTaskSummaryConfigSet(key, value);
+    if (taskSummaryPatch) {
+        // Echoed from the STORED value, like every section above: `config set
+        // taskSummary.enabled banana` prints `false`, which is what the read path will
+        // report and therefore the only honest answer.
+        const merged = updatePersistedConfig(taskSummaryPatch);
+        const field = key.slice('taskSummary.'.length);
+        process.stdout.write(`Set ${key} = ${String(merged.taskSummary[field])}\n`);
+        return;
+    }
     const patch = {};
     switch (key) {
         case 'provider':

package/dist/commands/builtins.js

@@ -27,6 +27,12 @@ import { registerQueueCommand } from './queue-command.js';
 import { registerPromptCommands } from '../prompts/command.js';
 import { registerKitCommand } from './kit-command.js';
 import { registerAgentsCommand } from './agents-command.js';
+// THE DRAWER AND THE HEADER LABEL (tui-shortcut-drawer-and-task-summary §4.7):
+// two single-purpose commands in their own modules, registered from here. Both are
+// UNCONDITIONAL, even with `taskSummary.enabled=false`, because they are the only
+// surfaces that can explain the switch.
+import { keysCommand } from './keys-command.js';
+import { taskCommand } from './task-command.js';
 import { perfCommand } from './perf.js';
 import { runCompactCommand } from '../compaction/command.js';
 import { runClearCommand } from './clear-command.js';
@@ -1502,6 +1508,11 @@ export function registerBuiltinCommands(registry) {
     // The read-only subagent board (tui-subagent-panel §6.4). Same shape again: the
     // body is `commands/agents-command.ts` and the registration is this one line.
     registerAgentsCommand(registry);
+    // The keyboard drawer (`Ctrl+G` / `/keys`) and the task label (`/task`). Two
+    // registrations, no new mechanism: `/keys` sets the panel's pre-filter and opens
+    // the same overlay `Ctrl+G` opens, and `/task` reports what the header cell says.
+    registry.register(keysCommand);
+    registry.register(taskCommand);
 }
 /**
  * Every built-in command name INCLUDING aliases (`quit`), for documentation and
@@ -1511,7 +1522,8 @@ export function registerBuiltinCommands(registry) {
  * `registry.get(name)` instead, because that is the only check that stays
  * correct when commands are registered dynamically (§7.1 / P1-2).
  */
-export const BUILTIN_COMMAND_NAMES = ['queue', 'prompts', 'agents', ...COMMANDS.flatMap((c) => [
+export const BUILTIN_COMMAND_NAMES = ['queue', 'prompts', 'agents', 'keys', 'task',
+    ...COMMANDS.flatMap((c) => [
         c.name,
         ...(c.aliases ?? []),
     ])].sort();

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

@@ -0,0 +1,23 @@
+/**
+ * `/keys [query]` — open the keyboard drawer (tui-shortcut-drawer-and-task-summary
+ * §4.7).
+ *
+ * ASCII ONLY: `src/commands/**` is inside the glyph scanner's scope.
+ *
+ * THE COMMAND IS THE SECOND ENTRANCE TO THE SAME ROOM, not a second room: it sets
+ * the pre-filter and opens `overlay: 'shortcuts'`, exactly as `Ctrl+G` does. That
+ * pairing (`/agents` <-> `Ctrl+B`, `/help` <-> `?`) is the established one, and it
+ * exists because a key is unreachable in a script, a paste and a screen reader.
+ *
+ * NOTE ON NAMES: `CommandRegistry.register` overwrites unconditionally while the
+ * skill loader only claims a bare `/<name>` when nothing else has it, so a user with
+ * a skill called `keys` now reaches it as `/skill:keys`. That is registered in
+ * `CHANGELOG.md`; `/keys` deliberately has NO alias, because an alias would multiply
+ * the same shadowing.
+ */
+import type { SlashCommand } from './registry.js';
+/** The pure part: what to open and with what filter. Separated so it is testable. */
+export declare function parseKeysArgs(args: string): {
+    query: string;
+};
+export declare const keysCommand: SlashCommand;

package/dist/commands/keys-command.js

@@ -0,0 +1,38 @@
+/**
+ * `/keys [query]` — open the keyboard drawer (tui-shortcut-drawer-and-task-summary
+ * §4.7).
+ *
+ * ASCII ONLY: `src/commands/**` is inside the glyph scanner's scope.
+ *
+ * THE COMMAND IS THE SECOND ENTRANCE TO THE SAME ROOM, not a second room: it sets
+ * the pre-filter and opens `overlay: 'shortcuts'`, exactly as `Ctrl+G` does. That
+ * pairing (`/agents` <-> `Ctrl+B`, `/help` <-> `?`) is the established one, and it
+ * exists because a key is unreachable in a script, a paste and a screen reader.
+ *
+ * NOTE ON NAMES: `CommandRegistry.register` overwrites unconditionally while the
+ * skill loader only claims a bare `/<name>` when nothing else has it, so a user with
+ * a skill called `keys` now reaches it as `/skill:keys`. That is registered in
+ * `CHANGELOG.md`; `/keys` deliberately has NO alias, because an alias would multiply
+ * the same shadowing.
+ */
+/** The pure part: what to open and with what filter. Separated so it is testable. */
+export function parseKeysArgs(args) {
+    // ONE TOKEN, TRIMMED: the filter matches `id` / `keys` / `keyword` / aliases, and
+    // a multi-word query would only ever match a phrase none of them contain.
+    return { query: args.trim() };
+}
+export const keysCommand = {
+    name: 'keys',
+    description: 'List every keyboard shortcut (opens the drawer)',
+    run: (ctx) => {
+        const { query } = parseKeysArgs(ctx.args);
+        // WITHOUT THE PORT THERE IS NO PANEL TO OPEN, and saying so is better than
+        // opening nothing: this is the one command whose failure mode would otherwise be
+        // a keystroke that appears to do nothing at all.
+        if (!ctx.taskSummary) {
+            ctx.notify('warn', 'The shortcut drawer is not available in this build.');
+            return;
+        }
+        ctx.taskSummary.openPanel(query);
+    },
+};

package/dist/commands/registry.d.ts

@@ -175,6 +175,45 @@ export interface CommandContext {
      * needs the SHAPE of the port, never a value at run time.
      */
     prompts?: PromptCommandPort;
+    /**
+     * The task label's three capabilities (`/keys`, `/task`; tui-shortcut-drawer-and-
+     * task-summary §6.4).
+     *
+     * OPTIONAL, and this is the sixth time this file records the same rule: every
+     * fixture in this package builds `CommandContext` by literal, so a REQUIRED field
+     * would fail to compile every one of them for a feature none of them is about.
+     * Absent means the build has no label machinery, and both commands say so instead
+     * of crashing - which matters most for `/task`, whose entire job is to explain why
+     * there is no label.
+     *
+     * TYPE-ONLY import, for the reason the `branch` note above records.
+     */
+    taskSummary?: TaskSummaryCommandPort;
+}
+/**
+ * What `/keys` and `/task` may do.
+ *
+ * THREE METHODS, NOT ONE: opening the drawer, reading the label and forcing a
+ * regeneration are three different user intentions, and `/task refresh` must not be
+ * expressible as "open the panel and press r".
+ */
+export interface TaskSummaryCommandPort {
+    /** Open the drawer, optionally pre-filtered (`/keys <query>`). */
+    openPanel(query?: string): void;
+    /** The current label, its provenance and why it is a fallback. */
+    read(): {
+        view: {
+            text: string;
+            tone: 'model' | 'fallback';
+            reason: string | null;
+            by: string;
+            at: number;
+        } | null;
+        pending: boolean;
+        enabled: boolean;
+    };
+    /** Regenerate from the last user message. Returns the anchor it used, or `''`. */
+    refresh(): string;
 }
 /** What `/mouse` can see and do. Read at command time, never captured. */
 export interface MouseCommandPort {

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

@@ -0,0 +1,39 @@
+/**
+ * `/task` and `/task refresh` (tui-shortcut-drawer-and-task-summary §4.7).
+ *
+ * ASCII ONLY: `src/commands/**` is inside the glyph scanner's scope.
+ *
+ * WHY "task summary" AND NEVER BARE "task": this package already has a TOOL named
+ * `task` (the subagent dispatcher, `team/task-tool.ts`), and `HelpOverlay`'s team
+ * table prints that name. A help line that said only "task" would make two unrelated
+ * things share one word on the same screen.
+ *
+ * WHY A NOTICE AND NOT AN OVERLAY: three lines of provenance do not deserve a
+ * frame, and the guaranteed reporting surface for "why is there no label" has to be
+ * somewhere the user can scroll back to - a toast disappears.
+ *
+ * BOTH COMMANDS ARE REGISTERED UNCONDITIONALLY, even with
+ * `taskSummary.enabled = false`: they are the only surface that can EXPLAIN the
+ * switch, and a missing command answers "unknown command" instead of "off" (the
+ * `/prompts` D-19 rule).
+ */
+import type { SlashCommand } from './registry.js';
+/** One line per fact, or a single honest line when there is no label. */
+export declare function formatTaskSummaryReport(input: {
+    view: {
+        text: string;
+        tone: 'model' | 'fallback';
+        reason: string | null;
+        by: string;
+        at: number;
+    } | null;
+    pending: boolean;
+    enabled: boolean;
+    now: number;
+}): string[];
+/** `''` for a bare `/task`, `'refresh'` for `/task refresh`, else the raw argument. */
+export declare function parseTaskArgs(args: string): {
+    action: 'show' | 'refresh' | 'unknown';
+    raw: string;
+};
+export declare const taskCommand: SlashCommand;

package/dist/commands/task-command.js

@@ -0,0 +1,102 @@
+/**
+ * `/task` and `/task refresh` (tui-shortcut-drawer-and-task-summary §4.7).
+ *
+ * ASCII ONLY: `src/commands/**` is inside the glyph scanner's scope.
+ *
+ * WHY "task summary" AND NEVER BARE "task": this package already has a TOOL named
+ * `task` (the subagent dispatcher, `team/task-tool.ts`), and `HelpOverlay`'s team
+ * table prints that name. A help line that said only "task" would make two unrelated
+ * things share one word on the same screen.
+ *
+ * WHY A NOTICE AND NOT AN OVERLAY: three lines of provenance do not deserve a
+ * frame, and the guaranteed reporting surface for "why is there no label" has to be
+ * somewhere the user can scroll back to - a toast disappears.
+ *
+ * BOTH COMMANDS ARE REGISTERED UNCONDITIONALLY, even with
+ * `taskSummary.enabled = false`: they are the only surface that can EXPLAIN the
+ * switch, and a missing command answers "unknown command" instead of "off" (the
+ * `/prompts` D-19 rule).
+ */
+/** One line per fact, or a single honest line when there is no label. */
+export function formatTaskSummaryReport(input) {
+    if (!input.enabled) {
+        return [
+            'Task summary is off (config taskSummary.enabled = false).',
+            'Turn it back on with: aragon config set taskSummary.enabled true',
+        ];
+    }
+    if (input.view === null) {
+        if (input.pending)
+            return ['Task summary: still being generated.'];
+        return [
+            'No task summary yet.',
+            'It appears after the first prompt of a task; /task refresh regenerates it.',
+        ];
+    }
+    const age = formatAge(input.now - input.view.at);
+    const source = input.view.tone === 'fallback'
+        ? `your own words (${input.view.reason ?? 'fallback'})`
+        : input.view.by;
+    return [
+        `Task summary: ${input.view.text}`,
+        `Source: ${source}${age === '' ? '' : `, ${age}`}`,
+        'Regenerate with /task refresh, or open the drawer (Ctrl+G) to see why.',
+    ];
+}
+/** `12s ago` / `3m ago` / `1h ago`, or `''` for a clock that went backwards. */
+function formatAge(ageMs) {
+    if (!Number.isFinite(ageMs) || ageMs < 0)
+        return '';
+    const seconds = Math.floor(ageMs / 1000);
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    return `${Math.floor(minutes / 60)}h ago`;
+}
+/** `''` for a bare `/task`, `'refresh'` for `/task refresh`, else the raw argument. */
+export function parseTaskArgs(args) {
+    const raw = args.trim();
+    if (raw.length === 0)
+        return { action: 'show', raw };
+    if (raw.toLowerCase() === 'refresh')
+        return { action: 'refresh', raw };
+    return { action: 'unknown', raw };
+}
+/**
+ * The command body: parse, report, or regenerate.
+ *
+ * NAMED FOR WHAT IT DOES, not for the port it touches (review fix RF-5): the old
+ * name described a variable, and this function is the whole of `/task`.
+ */
+function runTaskCommand(ctx) {
+    if (!ctx.taskSummary) {
+        ctx.notify('warn', 'The task summary is not available in this build.');
+        return;
+    }
+    const port = ctx.taskSummary;
+    const { action, raw } = parseTaskArgs(ctx.args);
+    if (action === 'unknown') {
+        ctx.notify('warn', `Unknown argument "${raw}" - use /task or /task refresh.`);
+        return;
+    }
+    if (action === 'refresh') {
+        const anchor = port.refresh();
+        if (anchor === '') {
+            ctx.notify('info', 'No prompt to summarise yet - send one first.');
+            return;
+        }
+        ctx.notify('info', 'Regenerating the task summary...');
+        return;
+    }
+    const state = port.read();
+    for (const line of formatTaskSummaryReport({ ...state, now: Date.now() })) {
+        ctx.notify('info', line);
+    }
+}
+export const taskCommand = {
+    name: 'task',
+    description: 'Show the header task summary (/task refresh regenerates it)',
+    run: runTaskCommand,
+};

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, clampAskRounds, 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, 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';
@@ -738,6 +738,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,