@aragon-agent/cli 0.5.2 → 0.5.4

package/dist/cli.js

@@ -21,11 +21,13 @@ import { loadConfig } from './config/load.js';
 import { getConfigPath, readConfigFile, updatePersistedConfig } from './config/store.js';
 import { formatMigrationNotice, migrateLegacyState } from './config/migrate-legacy-state.js';
 import { formatHomeMigrationNotice, migrateToHome } from './config/migrate-home.js';
-import { LOG_CONFIG_SET_KEYS, applyLogConfigSet, runConfigEdit, runConfigGet, runConfigHome, runConfigList, warnIfRedactionDisabled, } from './config/cli-commands.js';
-import { attachAgentEvents, installLogging, setScreenRestore, setSignalTerminator, } from './logging/install.js';
+import { migrateStateOutOfConfig } from './config/migrate-state-out-of-config.js';
+import { runHistoryCommand } from './config/history-commands.js';
+import { LOG_CONFIG_SET_KEYS, TEAM_CONFIG_SET_KEYS, applyLogConfigSet, applyTeamConfigSet, 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';
-import { ADAPTER_PROVIDERS, clampDensity, clampTheme, clampThinkingLevel, clampAskRounds, clampHumanTimeout, clampSkillsIntegrity, clampSkillsToolPolicy, clampTranscriptWindow, coerceMaxTokens, coercePositiveInt, isAdapterProvider, DEFAULT_PLAN_HUMAN_TIMEOUT_MS, DEFAULT_PLAN_MAX_ASK_ROUNDS, DEFAULT_SKILLS_CONFIG, } from './config/schema.js';
+import { ADAPTER_PROVIDERS, clampDensity, clampTheme, clampThinkingLevel, clampAskRounds, clampHumanTimeout, clampSkillsIntegrity, clampSkillsToolPolicy, clampTranscriptWindow, coercePositiveInt, isAdapterProvider, parseMaxTokensInput, DEFAULT_MAX_TOKENS, DEFAULT_PLAN_HUMAN_TIMEOUT_MS, DEFAULT_PLAN_MAX_ASK_ROUNDS, DEFAULT_SKILLS_CONFIG, } from './config/schema.js';
 import { makeGetApiKey } from './config/load.js';
 import { AgentController, DENY_ALL_APPROVAL } from './agent/controller.js';
 import { runSkillsCommand } from './skills/cli-commands.js';
@@ -79,6 +81,11 @@ function toFlags(opts) {
         skillsYes: opts.skillsYes,
         skillToolPolicy: opts.skillToolPolicy,
         plan: opts.plan,
+        // These two lines are the same failure the `mouse` note above records, one
+        // feature later (P1-4): without them `--no-team` and `--team-max` never
+        // reach `CliFlags` and are inert, with no compile error and no runtime error.
+        team: opts.team,
+        teamMax: opts.teamMax,
         // `--verbose` is just a shorthand for `--log-level debug`; an explicit
         // `--log-level` still wins, so the two can be combined without surprise.
         logLevel: opts.logLevel ?? (opts.verbose ? 'debug' : undefined),
@@ -166,6 +173,11 @@ function runInteractive(flags, extras = {}) {
     const logger = getLogger();
     logger.info('cli', 'run_interactive', { mode, provider: config.provider, model: config.model });
     attachAgentEvents(logger, controller);
+    // The team stream is CLI-local (D-10), so `attachAgentEvents` cannot see it.
+    // Without this a dispatch leaves NO trace in the log file at all — the wrong
+    // outcome for the one feature here that runs five agents the user cannot
+    // watch (§3.13 / P1-2 / R-19).
+    attachTeamEvents(logger, controller);
     let screen = null;
     let replayed = false;
     // --- Mouse wheel region routing (mouse-wheel-region-routing §4.2). -------
@@ -264,11 +276,16 @@ function runInteractive(flags, extras = {}) {
         .then(() => {
         screen?.restore();
         disposeMouse();
+        // Orphaned subagents survive `Ctrl+C` otherwise, and a live child holds
+        // the event loop open so `aragon` never returns to the shell (R-15). The
+        // App's unmount cleanup also calls this; `dispose()` is idempotent.
+        controller.dispose();
         replayTranscript();
     })
         .catch(() => {
         screen?.restore();
         disposeMouse();
+        controller.dispose();
     });
 }
 async function runOneShot(flags, prompt, quiet) {
@@ -282,6 +299,11 @@ async function runOneShot(flags, prompt, quiet) {
     // toast channel `App.tsx` uses does not exist here.
     logger.onFailure((reason) => process.stderr.write(`[log] ${reason}\n`));
     attachAgentEvents(logger, controller);
+    // The team stream is CLI-local (D-10), so `attachAgentEvents` cannot see it.
+    // Without this a dispatch leaves NO trace in the log file at all — the wrong
+    // outcome for the one feature here that runs five agents the user cannot
+    // watch (§3.13 / P1-2 / R-19).
+    attachTeamEvents(logger, controller);
     const untrusted = controller.getSkillService().untrustedDirs();
     for (const dir of untrusted) {
         process.stderr.write(`[skills] project skills in ${dir} skipped (untrusted). Run: aragon skills trust ${dir}\n`);
@@ -354,6 +376,7 @@ const CONFIG_SET_KEYS = new Set([
     // falls through every case, writes nothing, and still prints
     // `Set mouse = false` (P1-2) -- exactly what happened to `density`/`hints`.
     'mouse',
+    'historyEnabled',
     'planModeDefault',
     'planModeMaxAskRounds',
     'planModeHumanTimeoutMs',
@@ -368,7 +391,35 @@ const CONFIG_SET_KEYS = new Set([
     // `log.*` keys are handled by `applyLogConfigSet` below, NOT by the switch:
     // that switch is already past this package's complexity ceiling.
     ...LOG_CONFIG_SET_KEYS,
+    // `team.*` keys are handled by `applyTeamConfigSet`, for the same reason
+    // `log.*` are: the switch below is already past this package's complexity
+    // ceiling, and a key listed here but forgotten there writes nothing while
+    // still printing `Set team.enabled = false`.
+    ...TEAM_CONFIG_SET_KEYS,
 ]);
+/**
+ * `aragon config set maxTokens <n|auto|default>`.
+ *
+ * REJECTS nonsense rather than clamping it, unlike `theme` and `thinkingLevel`.
+ * Those two clamp because their bad values are out-of-VOCABULARY; here a
+ * non-numeric argument is almost always a typo for a number the user meant, and
+ * storing 64000 for `3200O` would quietly discard their intent. An out-of-RANGE
+ * number is still clamped, in both directions, by the store's single gate.
+ */
+function runConfigSetMaxTokens(value) {
+    const raw = value.trim().toLowerCase();
+    const parsed = raw === 'default'
+        ? { kind: 'value', value: DEFAULT_MAX_TOKENS, clamped: false }
+        : parseMaxTokensInput(value);
+    if (parsed.kind === 'invalid') {
+        process.stderr.write(`Invalid maxTokens "${value}". Use a number, "auto", or "default".\n`);
+        process.exitCode = 2;
+        return;
+    }
+    const stored = parsed.kind === 'auto' ? null : parsed.value;
+    const merged = updatePersistedConfig({ maxTokens: stored });
+    process.stdout.write(`Set maxTokens = ${merged.maxTokens ?? 'auto'}\n`);
+}
 function runConfigSet(key, value) {
     if (!CONFIG_SET_KEYS.has(key)) {
         process.stderr.write(`Unknown config key "${key}". Known keys: ${[...CONFIG_SET_KEYS].join(', ')}.\n`);
@@ -382,6 +433,23 @@ function runConfigSet(key, value) {
         process.stdout.write(`Set ${key} = ${value}\n`);
         return;
     }
+    // Handled ahead of the switch because it needs to echo the STORED value, not
+    // the typed one: `config set maxTokens 900000` must not report a number that
+    // was never written. Same reason `team.*` has its own branch.
+    if (key === 'maxTokens') {
+        runConfigSetMaxTokens(value);
+        return;
+    }
+    const teamPatch = applyTeamConfigSet(key, value);
+    if (teamPatch) {
+        // The written value is echoed from the CLAMPED result rather than from the
+        // input, so `config set team.maxSubagents 40` says 10 instead of silently
+        // reporting a number that was never stored (R-g).
+        const merged = updatePersistedConfig(teamPatch);
+        const field = key.slice('team.'.length);
+        process.stdout.write(`Set ${key} = ${String(merged.team[field])}\n`);
+        return;
+    }
     const patch = {};
     switch (key) {
         case 'provider':
@@ -396,9 +464,6 @@ function runConfigSet(key, value) {
         case 'thinkingLevel':
             patch.thinkingLevel = clampThinkingLevel(value, 'off');
             break;
-        case 'maxTokens':
-            patch.maxTokens = coerceMaxTokens(value) ?? null;
-            break;
         case 'theme':
             patch.theme = clampTheme(value, 'auto');
             break;
@@ -429,6 +494,11 @@ function runConfigSet(key, value) {
         case 'mouse':
             patch.mouse = value === 'true' || value === '1';
             break;
+        // Turning this off stops new prompts being recorded; it does NOT delete
+        // what is already in `prompt-history.jsonl` (that is `aragon history clear`).
+        case 'historyEnabled':
+            patch.historyEnabled = value === 'true' || value === '1';
+            break;
         // Clamped rather than rejected, for the same reason as `theme` and
         // `skills.integrity`: hardening only the READ path leaves a bad value on
         // disk that reverts to the default on every launch, which presents as
@@ -497,7 +567,7 @@ function buildProgram() {
         .option('--base-url <url>', 'Override the provider base URL')
         .option('--api-key <key>', 'One-shot API key override (not persisted)')
         .option('--thinking <level>', 'off|minimal|low|medium|high|xhigh')
-        .option('--max-tokens <n>', 'Output token cap')
+        .option('--max-tokens <n|auto>', 'Output token cap: a number, or "auto" for the model ceiling (default 64000)')
         .option('--cwd <dir>', 'Working directory for tools')
         .option('--confirm', 'Confirm each mutating tool call')
         .option('--tool-timeout <ms>', 'Per-tool executor ceiling (default 180000)')
@@ -525,6 +595,13 @@ function buildProgram() {
         // config layer win when neither flag was given.
         .option('--plan', 'Start the session in PLAN mode (read-only research + review)')
         .option('--no-plan', 'Start the session in BUILD mode (overrides planModeDefault)')
+        // BOTH FORMS, positive first, and the pair is mandatory (team-subagents
+        // §4.4 / P1-4). Declaring only `--no-team` would make commander default
+        // `opts.team` to `true`, at which point the flag is indistinguishable from
+        // its own default and silently overrides `config.json` on every run.
+        .option('--team', 'Enable team subagents for this session (the default)')
+        .option('--no-team', 'Disable team subagents (the task tool is not registered at all)')
+        .option('--team-max <n>', 'Max subagents per dispatch for this run (1-10)')
         .option('--no-skills', 'Disable the skill system entirely (no catalog, no skill tools)')
         .option('--skill <name>', 'Force-load a skill at Level 2 for this run (repeatable)', (value, previous = []) => [...previous, value])
         .option('--skills-yes', 'Approve skill installs for this run (CI / headless)')
@@ -618,6 +695,16 @@ function buildProgram() {
         .action(async (subcommand, opts) => {
         process.exitCode = await runLogsCommand(subcommand ?? 'path', opts, toFlags(program.opts()));
     });
+    // aragon history <sub> [-n N] [--json] [--yes]
+    program
+        .command('history [subcommand]')
+        .description('Inspect the prompt history: path | list | clear')
+        .option('-n, --lines <n>', 'Entries for `history list` (default 20)')
+        .option('--json', 'Print raw entries instead of rendered lines')
+        .option('--yes', 'Confirm destructive actions (required by `history clear`)')
+        .action((subcommand, opts) => {
+        process.exitCode = runHistoryCommand(subcommand ?? 'path', opts);
+    });
     // aragon skills <sub> [arg] [--scope] [--name] [--description] [--yes] [--json]
     program
         .command('skills [subcommand] [argument]')
@@ -666,6 +753,10 @@ async function main() {
     // may just have created. What ① and ② did is replayed from `pending` rather
     // than lost.
     installLogging({ pending: migrationNotes(legacy, home) });
+    // ③.5 — after ③ because it writes a log record, and before anything that
+    // resolves config because every `loadConfig()` from here on must already see
+    // the post-migration world. Never throws, never prints (D-8).
+    migrateStateOutOfConfig();
     // An unparseable config.json still falls back to defaults — the CLI has to
     // start — but it must not do so in silence, or a stray comma presents as
     // "every setting I ever chose is gone". stderr, never stdout, so

package/dist/commands/builtins.d.ts

@@ -1,7 +1,7 @@
 /**
  * Built-in slash commands (spec §5.2):
- * /help /model /settings /thinking /tools /clear /reset /cwd /save /resume
- * /copy /exit (/quit).
+ * /help /model /settings /thinking /max-tokens /tools /clear /reset /cwd /save
+ * /resume /copy /exit (/quit).
  */
 import { CommandRegistry } from './registry.js';
 export declare function registerBuiltinCommands(registry: CommandRegistry): void;

package/dist/commands/builtins.js

@@ -1,13 +1,14 @@
 /**
  * Built-in slash commands (spec §5.2):
- * /help /model /settings /thinking /tools /clear /reset /cwd /save /resume
- * /copy /exit (/quit).
+ * /help /model /settings /thinking /max-tokens /tools /clear /reset /cwd /save
+ * /resume /copy /exit (/quit).
  */
 import { spawn } from 'node:child_process';
 import { existsSync, statSync } from 'node:fs';
 import { isAbsolute, resolve } from 'node:path';
 import process from 'node:process';
-import { clampThinkingLevel, clampTheme, isThemeName, LEGACY_DARK_THEME, THEME_NAMES, THINKING_LEVELS, } from '../config/schema.js';
+import { resolveOutputTokens } from '@aragon-agent/core';
+import { clampThinkingLevel, clampTheme, isThemeName, parseMaxTokensInput, DEFAULT_MAX_TOKENS, LEGACY_DARK_THEME, THEME_NAMES, THINKING_LEVELS, } from '../config/schema.js';
 import { MODE_LABEL, nextMode } from '../agent/agent-mode.js';
 import { loadConfig } from '../config/load.js';
 import { loadSession, resolveSessionPath, saveSession } from '../session/persist.js';
@@ -43,6 +44,53 @@ const COMMANDS = [
             ctx.toast('info', `Thinking level set to "${clamped}".`);
         },
     },
+    {
+        name: 'max-tokens',
+        description: 'Show or set the output token cap (<n> | auto | default)',
+        /**
+         * Exists next to the settings screen for the reason `/theme` and `/plan` do:
+         * the slash palette is the discoverable surface, and this is one keystroke
+         * instead of five arrow presses.
+         *
+         * The no-argument branch reports the EFFECTIVE cap, not just the setting.
+         * "I set 64000" and "this model will produce 8192" are different facts, and
+         * only the second one explains a truncated answer.
+         */
+        run: (ctx) => {
+            const arg = ctx.args.trim();
+            const cfg = ctx.controller.getConfig();
+            if (!arg) {
+                const resolution = resolveOutputTokens({
+                    providerId: cfg.provider,
+                    modelId: cfg.model,
+                    ...(cfg.maxTokens !== undefined ? { requested: cfg.maxTokens } : {}),
+                });
+                const setting = cfg.maxTokens === undefined ? 'auto' : String(cfg.maxTokens);
+                const why = resolution.clampedBy === 'ceiling' ? ` (${cfg.model} ceiling)` : '';
+                ctx.notify('info', `Max tokens: ${setting}. Effective for ${cfg.provider}:${cfg.model}: ` +
+                    `${resolution.value}${why}.\nUse /max-tokens <n|auto|default>.`);
+                return;
+            }
+            const parsed = arg.toLowerCase() === 'default'
+                ? { kind: 'value', value: DEFAULT_MAX_TOKENS, clamped: false }
+                : parseMaxTokensInput(arg);
+            if (parsed.kind === 'invalid') {
+                // Change NOTHING on a typo: silently resolving it to a default would
+                // discard the number the user meant to type.
+                ctx.notify('warn', `Invalid value "${arg}" - use /max-tokens <n|auto|default>.`);
+                return;
+            }
+            if (parsed.kind === 'auto') {
+                ctx.controller.setMaxTokens(undefined);
+                ctx.persistConfig({ maxTokens: null });
+                ctx.toast('success', 'Max tokens: auto (per-model ceiling).');
+                return;
+            }
+            ctx.controller.setMaxTokens(parsed.value);
+            ctx.persistConfig({ maxTokens: parsed.value });
+            ctx.toast('success', `Max tokens set to ${parsed.value}.`);
+        },
+    },
     {
         name: 'theme',
         description: 'Switch the color theme (auto|warm|cool|light)',
@@ -90,6 +138,88 @@ const COMMANDS = [
             ctx.applyAgentMode(target);
         },
     },
+    {
+        name: 'team',
+        description: 'Team subagents: status | on | off | max <n>',
+        /**
+         * `/team on` CANNOT turn team mode on in a session that started without it,
+         * and this command must not pretend otherwise (§4.5 / D-17 / P0-2).
+         *
+         * `controller.ts` builds the tool array ONCE and its own comment forbids
+         * rebuilding it: `Agent.setTools()` mutates the live `ToolRegistry`, and
+         * `submit_plan` flips the session mode from INSIDE a tool execution, so a
+         * rebuild at that moment would mutate the registry mid-iteration. But
+         * `rebuildSystemPrompt()` IS a live path — so the naive reading of `/team on`
+         * (flip a flag, re-splice `<team_mode>`) produces a session where the model
+         * is told it has a `task` tool that was never registered. Every call comes
+         * back "unknown tool", and the model has no way to discover why.
+         *
+         * So the answer splits by what was decided at construction, and the honest
+         * branch — persist it, say the session is unchanged — is the whole point.
+         */
+        run: (ctx) => {
+            const arg = ctx.args.trim().toLowerCase();
+            const [verb, value] = arg.split(/\s+/, 2);
+            const controller = ctx.controller;
+            // Refused mid-dispatch for the reason `/reload` already records: half a
+            // dispatch under one ceiling and half under another produces a result
+            // nothing can afterwards explain.
+            if (verb && verb !== 'status' && controller.isTeamBusy()) {
+                ctx.notify('warn', 'Cannot change team settings mid-dispatch.');
+                return;
+            }
+            if (!verb || verb === 'status') {
+                const cfg = controller.getTeamConfig();
+                const state = !controller.isTeamRegistered()
+                    ? 'off for this session (started with --no-team)'
+                    : controller.isTeamEnabled()
+                        ? 'on'
+                        : 'off';
+                const snapshot = controller.getTeamSnapshot();
+                const roster = snapshot
+                    ? `\nRunning: ${snapshot.runs.map((r) => `${r.label} (${r.phase})`).join(', ')}`
+                    : '';
+                ctx.notify('info', `Team mode: ${state}. Max subagents: ${cfg.maxSubagents}, ` +
+                    `concurrent: ${cfg.maxConcurrent}.${roster}`);
+                return;
+            }
+            if (verb === 'on' || verb === 'off') {
+                const enabled = verb === 'on';
+                // A PARTIAL `team` section, safe only because `updatePersistedConfig`
+                // deep-merges it — the same contract `/skills disable` relies on.
+                ctx.persistConfig({ team: { enabled } });
+                if (!controller.isTeamRegistered()) {
+                    // The bottom-right cell of §4.5's table. It is honest, it is one
+                    // sentence, and it keeps AC-11 intact: a `--no-team` session never
+                    // grows a wrapper or an entry, whatever the user types afterwards.
+                    ctx.notify('info', enabled
+                        ? 'Team mode is off for this session (started with --no-team). Saved for next launch.'
+                        : 'Team mode is already off for this session. Saved for next launch.');
+                    return;
+                }
+                controller.setTeamEnabled(enabled);
+                ctx.toast('success', `Team mode ${enabled ? 'on' : 'off'}.`);
+                return;
+            }
+            if (verb === 'max') {
+                const n = Number.parseInt(value ?? '', 10);
+                if (!Number.isFinite(n) || n <= 0) {
+                    ctx.notify('warn', 'Usage: /team max <n>');
+                    return;
+                }
+                // Clamped by `setTeamConfig` and again on the persist path, so a value
+                // above the requirement's ceiling can reach neither the runtime nor the
+                // file (R-g).
+                const applied = controller.setTeamConfig({ maxSubagents: n });
+                ctx.persistConfig({
+                    team: { maxSubagents: applied.maxSubagents },
+                });
+                ctx.toast('success', `Max subagents set to ${applied.maxSubagents}.`);
+                return;
+            }
+            ctx.notify('warn', `Unknown argument "${verb}" - use /team [status|on|off|max <n>].`);
+        },
+    },
     {
         name: 'expand',
         description: 'Expand / collapse a recent tool card (default: last)',

package/dist/config/app-paths.d.ts

@@ -12,11 +12,18 @@
  *   ~/.aragon-agent/
  *   ├── config.json            persisted config (0600 on POSIX)
  *   ├── config.json.bak        `aragon config edit` pre-edit backup
+ *   ├── prompt-history.jsonl   submitted prompts, append-only (0600 on POSIX)
+ *   ├── state.json             UI bookkeeping scalars (0600 on POSIX)
  *   ├── logs/                  JSONL logs (0700 on POSIX)
  *   ├── sessions/              /save · /resume
  *   ├── skills/                `aragon skills install` target
  *   └── skill-usage.json
  *
+ * The two files added by config-state-separation are DIRECT CHILDREN of the
+ * root, siblings of `skill-usage.json` rather than children of any directory
+ * here: `logs/`, `sessions/` and `skills/` are all scan roots, and every extra
+ * file inside one is another thing each walk has to recognise and skip.
+ *
  * The same path on all three platforms, deliberately. Claude Code, git and npm
  * all put their dot-directory in the user's home; one path means documentation,
  * support scripts and community answers have exactly one thing to say. A user
@@ -62,6 +69,16 @@ export declare function getHomeRoot(): string;
 export declare function getConfigPath(): string;
 /** Written by `aragon config edit` before spawning the editor. */
 export declare function getConfigBackupPath(): string;
+/**
+ * `<home>/prompt-history.jsonl` — the prompts the user submitted, one JSON
+ * object per line. Deliberately NOT under `logs/`: that directory is governed
+ * by `log.toFile`, `log.maxFiles` and `aragon logs clear`, and turning
+ * diagnostics off or reclaiming disk must not also delete the user's `↑`
+ * recall (config-state-separation D-1).
+ */
+export declare function getPromptHistoryPath(): string;
+/** `<home>/state.json` — UI bookkeeping scalars only; see `ui-state.ts`. */
+export declare function getUiStatePath(): string;
 export declare function getLogsDir(): string;
 export declare function getSessionsDir(): string;
 /** `<home>` — parent of `skills/`, and where sidecar state such as usage lives. */

package/dist/config/app-paths.js

@@ -12,11 +12,18 @@
  *   ~/.aragon-agent/
  *   ├── config.json            persisted config (0600 on POSIX)
  *   ├── config.json.bak        `aragon config edit` pre-edit backup
+ *   ├── prompt-history.jsonl   submitted prompts, append-only (0600 on POSIX)
+ *   ├── state.json             UI bookkeeping scalars (0600 on POSIX)
  *   ├── logs/                  JSONL logs (0700 on POSIX)
  *   ├── sessions/              /save · /resume
  *   ├── skills/                `aragon skills install` target
  *   └── skill-usage.json
  *
+ * The two files added by config-state-separation are DIRECT CHILDREN of the
+ * root, siblings of `skill-usage.json` rather than children of any directory
+ * here: `logs/`, `sessions/` and `skills/` are all scan roots, and every extra
+ * file inside one is another thing each walk has to recognise and skip.
+ *
  * The same path on all three platforms, deliberately. Claude Code, git and npm
  * all put their dot-directory in the user's home; one path means documentation,
  * support scripts and community answers have exactly one thing to say. A user
@@ -119,6 +126,20 @@ export function getConfigPath() {
 export function getConfigBackupPath() {
     return join(resolution.root, 'config.json.bak');
 }
+/**
+ * `<home>/prompt-history.jsonl` — the prompts the user submitted, one JSON
+ * object per line. Deliberately NOT under `logs/`: that directory is governed
+ * by `log.toFile`, `log.maxFiles` and `aragon logs clear`, and turning
+ * diagnostics off or reclaiming disk must not also delete the user's `↑`
+ * recall (config-state-separation D-1).
+ */
+export function getPromptHistoryPath() {
+    return join(resolution.root, 'prompt-history.jsonl');
+}
+/** `<home>/state.json` — UI bookkeeping scalars only; see `ui-state.ts`. */
+export function getUiStatePath() {
+    return join(resolution.root, 'state.json');
+}
 export function getLogsDir() {
     return join(resolution.root, 'logs');
 }

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

@@ -1,6 +1,6 @@
 /**
- * `aragon config get | list | edit | home`, plus the `log.*` branch of
- * `config set`.
+ * `aragon config get | list | edit | home`, plus the `log.*` and `team.*`
+ * branches of `config set`.
  *
  * These live here rather than in `cli.tsx` because `runConfigSet` is already a
  * 21-case switch — well past the complexity ceiling this package writes down —
@@ -10,6 +10,17 @@
 import { type PersistedConfig } from './schema.js';
 /** Config keys under `log.` that `aragon config set` accepts. */
 export declare const LOG_CONFIG_SET_KEYS: readonly ["log.level", "log.toFile", "log.dir", "log.maxFileBytes", "log.maxFiles", "log.redactSecrets", "log.previewChars"];
+/**
+ * Config keys under `team.` that `aragon config set` accepts (team-subagents
+ * §4.3).
+ *
+ * Handled here rather than in `cli.tsx`'s switch for the reason this module's
+ * header already gives about `log.*`: that switch is past this package's
+ * complexity ceiling, and a key added to the membership set but forgotten in the
+ * switch falls through every case, writes nothing, and still prints
+ * `Set team.enabled = false`.
+ */
+export declare const TEAM_CONFIG_SET_KEYS: readonly ["team.enabled", "team.maxSubagents", "team.maxConcurrent", "team.subagentTimeoutMs", "team.dispatchTimeoutMs", "team.maxTurnsPerSubagent"];
 /**
  * Translate a `log.*` dotted key into a patch, or `null` for anything else.
  *
@@ -19,6 +30,19 @@ export declare const LOG_CONFIG_SET_KEYS: readonly ["log.level", "log.toFile", "
  * included.
  */
 export declare function applyLogConfigSet(key: string, value: string): Partial<PersistedConfig> | null;
+/**
+ * Translate a `team.*` dotted key into a patch, or `null` for anything else.
+ *
+ * The patch is a PARTIAL `team` section, safe only because
+ * `updatePersistedConfig` deep-merges that section — with a shallow merge,
+ * setting the fan-out width would silently reset every timeout in the section.
+ *
+ * Values are CLAMPED rather than rejected, exactly like `theme` and
+ * `skills.integrity`: hardening only the read path leaves a bad value on disk
+ * that reverts to the default on every launch, which presents as "my setting
+ * won't stick". `clampTeamConfig` is the one gate both directions pass through.
+ */
+export declare function applyTeamConfigSet(key: string, value: string): Partial<PersistedConfig> | null;
 /**
  * `log.redactSecrets false` is the one setting that lets credentials reach the
  * disk. It is command-line-only (there is no settings-screen entry) and it says

package/dist/config/cli-commands.js

@@ -1,6 +1,6 @@
 /**
- * `aragon config get | list | edit | home`, plus the `log.*` branch of
- * `config set`.
+ * `aragon config get | list | edit | home`, plus the `log.*` and `team.*`
+ * branches of `config set`.
  *
  * These live here rather than in `cli.tsx` because `runConfigSet` is already a
  * 21-case switch — well past the complexity ceiling this package writes down —
@@ -10,10 +10,10 @@
 import { spawnSync } from 'node:child_process';
 import { copyFileSync, existsSync, readFileSync } from 'node:fs';
 import process from 'node:process';
-import { getConfigBackupPath, getConfigPath, getHomeRoot, getLogsDir, isHomeOverridden, } from './app-paths.js';
+import { getConfigBackupPath, getConfigPath, getHomeRoot, getLogsDir, getPromptHistoryPath, getUiStatePath, isHomeOverridden, } from './app-paths.js';
 import { getHomeMigrationBreadcrumbPath } from './migrate-home.js';
 import { loadPersistedConfig, updatePersistedConfig } from './store.js';
-import { coercePositiveInt, maskSecret, } from './schema.js';
+import { coercePositiveInt, maskSecret, DEFAULT_TEAM_CONFIG, } from './schema.js';
 import { clampLogLevel } from '../logging/levels.js';
 /** Config keys under `log.` that `aragon config set` accepts. */
 export const LOG_CONFIG_SET_KEYS = [
@@ -25,6 +25,24 @@ export const LOG_CONFIG_SET_KEYS = [
     'log.redactSecrets',
     'log.previewChars',
 ];
+/**
+ * Config keys under `team.` that `aragon config set` accepts (team-subagents
+ * §4.3).
+ *
+ * Handled here rather than in `cli.tsx`'s switch for the reason this module's
+ * header already gives about `log.*`: that switch is past this package's
+ * complexity ceiling, and a key added to the membership set but forgotten in the
+ * switch falls through every case, writes nothing, and still prints
+ * `Set team.enabled = false`.
+ */
+export const TEAM_CONFIG_SET_KEYS = [
+    'team.enabled',
+    'team.maxSubagents',
+    'team.maxConcurrent',
+    'team.subagentTimeoutMs',
+    'team.dispatchTimeoutMs',
+    'team.maxTurnsPerSubagent',
+];
 function isTrue(value) {
     return value === 'true' || value === '1';
 }
@@ -57,6 +75,43 @@ export function applyLogConfigSet(key, value) {
             return null;
     }
 }
+/**
+ * Translate a `team.*` dotted key into a patch, or `null` for anything else.
+ *
+ * The patch is a PARTIAL `team` section, safe only because
+ * `updatePersistedConfig` deep-merges that section — with a shallow merge,
+ * setting the fan-out width would silently reset every timeout in the section.
+ *
+ * Values are CLAMPED rather than rejected, exactly like `theme` and
+ * `skills.integrity`: hardening only the read path leaves a bad value on disk
+ * that reverts to the default on every launch, which presents as "my setting
+ * won't stick". `clampTeamConfig` is the one gate both directions pass through.
+ */
+export function applyTeamConfigSet(key, value) {
+    const patch = (team) => ({ team });
+    switch (key) {
+        case 'team.enabled':
+            return patch({ enabled: isTrue(value) });
+        case 'team.maxSubagents':
+            return patch({ maxSubagents: coercePositiveInt(value, DEFAULT_TEAM_CONFIG.maxSubagents) });
+        case 'team.maxConcurrent':
+            return patch({ maxConcurrent: coercePositiveInt(value, DEFAULT_TEAM_CONFIG.maxConcurrent) });
+        case 'team.subagentTimeoutMs':
+            return patch({
+                subagentTimeoutMs: coercePositiveInt(value, DEFAULT_TEAM_CONFIG.subagentTimeoutMs),
+            });
+        case 'team.dispatchTimeoutMs':
+            return patch({
+                dispatchTimeoutMs: coercePositiveInt(value, DEFAULT_TEAM_CONFIG.dispatchTimeoutMs),
+            });
+        case 'team.maxTurnsPerSubagent':
+            return patch({
+                maxTurnsPerSubagent: coercePositiveInt(value, DEFAULT_TEAM_CONFIG.maxTurnsPerSubagent),
+            });
+        default:
+            return null;
+    }
+}
 /**
  * `log.redactSecrets false` is the one setting that lets credentials reach the
  * disk. It is command-line-only (there is no settings-screen entry) and it says
@@ -80,6 +135,20 @@ function maskConfig(config) {
     }
     return { ...config, apiKeys };
 }
+/**
+ * The human-readable label for a value whose raw form would mislead, or
+ * `undefined` to leave the caller's own formatting alone.
+ *
+ * `maxTokens: null` is AUTO, not "unset". Printing a bare `null` reads as a
+ * missing setting and sends the user looking for a bug that is not there.
+ * `get` and `list` format everything else differently (unquoted vs. JSON), so
+ * this deliberately overrides one case rather than replacing both renderers.
+ */
+function displayOverride(key, value) {
+    if (key === 'maxTokens' && value === null)
+        return 'auto';
+    return undefined;
+}
 /** Resolve a flat or one-level-dotted key against the persisted config. */
 function readKey(config, key) {
     const [head, tail] = key.split('.', 2);
@@ -98,10 +167,14 @@ export function runConfigGet(key) {
         process.exitCode = 2;
         return;
     }
-    process.stdout.write(`${typeof value === 'string' ? value : JSON.stringify(value)}\n`);
+    const shown = displayOverride(key, value)
+        ?? (typeof value === 'string' ? value : JSON.stringify(value));
+    process.stdout.write(`${shown}\n`);
 }
 export function runConfigList(opts = {}) {
     const masked = maskConfig(loadPersistedConfig());
+    // `--json` stays RAW on purpose: it mirrors the file, and a consumer parsing
+    // it must see the `null` that is actually on disk.
     if (opts.json) {
         process.stdout.write(`${JSON.stringify(masked, null, 2)}\n`);
         return;
@@ -113,7 +186,7 @@ export function runConfigList(opts = {}) {
             }
             continue;
         }
-        process.stdout.write(`${key} = ${JSON.stringify(value)}\n`);
+        process.stdout.write(`${key} = ${displayOverride(key, value) ?? JSON.stringify(value)}\n`);
     }
 }
 // ---------------------------------------------------------------------------
@@ -177,6 +250,10 @@ export function runConfigHome() {
     process.stdout.write(`${getHomeRoot()}\n`);
     if (isHomeOverridden())
         process.stdout.write('  (overridden by ARAGON_HOME)\n');
+    // Named here because config.json no longer holds either of them, and a user
+    // looking for "where did my prompt history go" has to land somewhere.
+    process.stdout.write(`  prompt history: ${getPromptHistoryPath()}\n`);
+    process.stdout.write(`  ui state: ${getUiStatePath()}\n`);
     const breadcrumb = getHomeMigrationBreadcrumbPath();
     if (!existsSync(breadcrumb))
         return;

package/dist/config/env.d.ts

@@ -5,8 +5,9 @@
  *   - Provider secrets: ANTHROPIC_API_KEY, OPENAI_API_KEY, GOOGLE_API_KEY /
  *     GEMINI_API_KEY.
  *   - Overrides: ARAGON_PROVIDER, ARAGON_MODEL, ARAGON_BASE_URL, ARAGON_THINKING,
- *     ARAGON_MAX_TOKENS, ARAGON_THEME, ARAGON_MOUSE, ARAGON_PLAN,
- *     ARAGON_LOG_LEVEL, ARAGON_LOG_FILE, ARAGON_LOG_DIR.
+ *     ARAGON_MAX_TOKENS (a number, or `auto` / `0` for the per-model ceiling),
+ *     ARAGON_THEME, ARAGON_MOUSE, ARAGON_PLAN, ARAGON_TEAM,
+ *     ARAGON_TEAM_MAX, ARAGON_LOG_LEVEL, ARAGON_LOG_FILE, ARAGON_LOG_DIR.
  *
  * NOT here: `ARAGON_HOME`. It is read when `config/app-paths.ts` is first
  * evaluated, which is long before `loadDotenv()` runs, so a `.env` can never