@aragon-agent/cli 0.5.1 → 0.5.3

package/dist/cli.js

@@ -21,8 +21,10 @@ 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';
@@ -32,6 +34,7 @@ import { runSkillsCommand } from './skills/cli-commands.js';
 import { runHeadless } from './agent/headless.js';
 import { App } from './ui/App.js';
 import { decideRenderMode } from './ui/layout/frame.js';
+import { tryCreateMouseFilter } from './input/stdin-mouse-filter.js';
 import { enterAltScreen, writeExitTranscript } from './ui/screen.js';
 import { readExitSnapshot } from './ui/exit-snapshot.js';
 import { renderTranscriptText } from './ui/transcript-text.js';
@@ -70,11 +73,19 @@ function toFlags(opts) {
         exitTranscript: opts.exitTranscript,
         compact: opts.compact,
         hints: opts.hints,
+        // Without this line the flag never reaches `CliFlags` and `--no-mouse` is
+        // inert — a failure with no compile error and no runtime error (P1-2).
+        mouse: opts.mouse,
         skills: opts.skills,
         skill: opts.skill,
         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),
@@ -162,8 +173,38 @@ 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). -------
+    //
+    // BUILD THE FILTER FIRST, THEN ENABLE REPORTING. The order is invariant I-8
+    // and it is not negotiable: `\x1b[?1000h` tells the terminal to send SGR
+    // reports, and Ink 5.2.1 has no mouse branch at all, so any report that
+    // reaches its key parser is INSERTED INTO THE USER'S MESSAGE (`[` is 0x5B, so
+    // `PromptInput`'s `isControlSeq` guard passes it). A window in which
+    // reporting is on and Ink holds the raw stream is not a degraded feature — it
+    // is every click typing `[<0;12;5M` into the composer, strictly worse than
+    // the bug being fixed.
+    //
+    // `tryCreateMouseFilter` returns `null` rather than throwing, so a
+    // construction failure degrades to "the wheel is inert" (rung 3 of the
+    // fail-safe ladder), never to "reporting on, no filter".
+    // BOTH streams have to be terminals. `stdout.isTTY` is what decides whether
+    // `enterAltScreen` writes anything at all, but the reports come back on
+    // STDIN, so a TTY stdout with a piped stdin (`aragon config < file`, which
+    // reaches `runInteractive` without the stdin check the default action makes)
+    // would wrap a stream no report can ever arrive on and ask the terminal to
+    // start reporting anyway. §4.2's "non-TTY ⇒ no filter" covers both ends.
+    const wantMouse = mode === 'fullscreen' && config.mouse && !!process.stdout.isTTY && !!process.stdin.isTTY;
+    const mouseFilter = wantMouse
+        ? tryCreateMouseFilter(process.stdin, (reason) => logger.warn('cli', 'mouse_filter_failed', { reason }))
+        : null;
+    const disposeMouse = () => mouseFilter?.dispose();
     const replayTranscript = () => {
         if (replayed || mode !== 'fullscreen' || !config.exitTranscript)
             return;
@@ -181,7 +222,10 @@ function runInteractive(flags, extras = {}) {
         }));
     };
     if (mode === 'fullscreen') {
-        screen = enterAltScreen(process.stdout);
+        // `mouse` here means "a filter is installed", NOT "the user wants mouse
+        // support" — see `AltScreenOptions`. `screen.ts` must never derive it for
+        // itself, or a later refactor re-opens the gap I-8 closes.
+        screen = enterAltScreen(process.stdout, { mouse: mouseFilter !== null });
         const restore = () => screen?.restore();
         // Four idempotent restore paths (§4.4). The signal hook is NOT redundant:
         //   - `waitUntilExit().then()` is a microtask and may never be reached when
@@ -205,20 +249,43 @@ function runInteractive(flags, extras = {}) {
             process.exit(128 + signo);
         });
     }
-    const instance = render(_jsx(App, { controller: controller, version: VERSION, mode: mode, confirmBridge: confirmBridge, humanInputBridge: humanInputBridge, initialPrompt: extras.initialPrompt, initialOverlay: extras.initialOverlay }), 
+    const instance = render(_jsx(App, { controller: controller, version: VERSION, mode: mode, confirmBridge: confirmBridge, humanInputBridge: humanInputBridge, initialPrompt: extras.initialPrompt, initialOverlay: extras.initialOverlay, mouseSource: mouseFilter?.source }), 
     // Full-screen owns console.* itself (I-4): Ink's patchConsole writes
     // straight to stdout and permanently shifts the fixed frame's accounting.
-    { exitOnCtrlC: false, patchConsole: mode === 'inline' });
+    {
+        exitOnCtrlC: false,
+        patchConsole: mode === 'inline',
+        // I-5: with mouse support off the REAL stdin is handed over unwrapped, so
+        // every existing path is provably unchanged.
+        stdin: mouseFilter?.stdin ?? process.stdin,
+    });
     // The return value MUST be captured — `waitUntilExit()` is the normal-exit
-    // restore path and it cannot be registered otherwise.
+    // restore path and it cannot be registered otherwise. `dispose()` runs on
+    // BOTH branches (I-7): a live `'data'` listener on stdin keeps the event loop
+    // alive and `aragon` would never return to the shell. The signal path does
+    // not need it — it calls `process.exit()`.
+    //
+    // RESTORE BEFORE DISPOSE. `restore()` writes `?1000l`, so the terminal stops
+    // reporting first and anything already in flight is still consumed by a live
+    // filter. Disposing first leaves a window — narrow, but real — in which the
+    // terminal is still reporting and nothing is draining stdin, so a notch taken
+    // in that instant survives in the OS buffer and is handed to the shell as
+    // `[<64;12;5M` on exit. That is the I-2 failure mode, just smaller.
     void instance
         .waitUntilExit()
         .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) {
@@ -232,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`);
@@ -299,6 +371,12 @@ const CONFIG_SET_KEYS = new Set([
     // flags and never persist -- inconsistent with every other config field.
     'density',
     'hints',
+    // MEMBERSHIP HERE ONLY DECIDES THAT THE KEY IS NOT REJECTED. The `switch`
+    // below is what builds the patch, and a key present here but absent there
+    // 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',
@@ -313,6 +391,11 @@ 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,
 ]);
 function runConfigSet(key, value) {
     if (!CONFIG_SET_KEYS.has(key)) {
@@ -327,6 +410,16 @@ function runConfigSet(key, value) {
         process.stdout.write(`Set ${key} = ${value}\n`);
         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':
@@ -371,6 +464,14 @@ function runConfigSet(key, value) {
         case 'hints':
             patch.hints = value === 'true' || value === '1';
             break;
+        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
@@ -452,6 +553,9 @@ function buildProgram() {
         .option('--no-compact', 'Comfortable transcript density')
         .option('--hints', 'Always show the composer hint row')
         .option('--no-hints', 'Hide the composer hint row')
+        // Positive form first, same tri-state reason as `--fullscreen` above.
+        .option('--mouse', 'Wheel scrolls the region under the pointer (full-screen mode)')
+        .option('--no-mouse', 'Leave the mouse to the terminal (the wheel does nothing)')
         // Declaring `--fullscreen` BEFORE `--no-fullscreen` keeps the default
         // `undefined` instead of `true`, which is what makes the tri-state work:
         // "no opinion" must stay distinguishable from "force it".
@@ -464,6 +568,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)')
@@ -557,6 +668,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]')
@@ -605,6 +726,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.js

@@ -90,6 +90,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
@@ -177,6 +232,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,8 @@
  *   - 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_PLAN, ARAGON_LOG_LEVEL,
- *     ARAGON_LOG_FILE, ARAGON_LOG_DIR.
+ *     ARAGON_MAX_TOKENS, 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

package/dist/config/env.js

@@ -5,8 +5,8 @@
  *   - 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_PLAN, ARAGON_LOG_LEVEL,
- *     ARAGON_LOG_FILE, ARAGON_LOG_DIR.
+ *     ARAGON_MAX_TOKENS, 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
@@ -71,6 +71,14 @@ export function readEnvConfig() {
     if (fullscreen !== undefined && fullscreen.length > 0) {
         partial.fullscreen = fullscreen === '1' || fullscreen === 'true' || fullscreen === 'on' || fullscreen === 'yes';
     }
+    // ARAGON_MOUSE=0 turns off wheel region routing. Parsed by the POSITIVE list
+    // above, exactly as ARAGON_FULLSCREEN is — NOT by `envBool` below, which uses
+    // a negative list. The two disagree on `ARAGON_MOUSE=disable`, and `mouse` is
+    // modelled on `--fullscreen`, so it uses the reader `--fullscreen` uses.
+    const mouse = process.env.ARAGON_MOUSE?.trim().toLowerCase();
+    if (mouse !== undefined && mouse.length > 0) {
+        partial.mouse = mouse === '1' || mouse === 'true' || mouse === 'on' || mouse === 'yes';
+    }
     // ARAGON_PLAN=1 starts the session in PLAN mode — the same channel story as
     // ARAGON_FULLSCREEN, for terminals reached through a wrapper that owns argv.
     const plan = process.env.ARAGON_PLAN?.trim().toLowerCase();
@@ -88,6 +96,32 @@ export function readEnvConfig() {
             enabled: !(skills === '0' || skills === 'false' || skills === 'off' || skills === 'no'),
         };
     }
+    // ARAGON_TEAM=0 turns team mode off; ARAGON_TEAM_MAX=<n> overrides the fan-out
+    // width. Parsed by the POSITIVE list, exactly as ARAGON_FULLSCREEN /
+    // ARAGON_MOUSE / ARAGON_PLAN are — NOT by `envBool` below, which uses a
+    // negative list. The two readers disagree on `ARAGON_TEAM=disable`, and the
+    // documented-but-dead outcome of copying the wrong one is what `load.ts`
+    // records for `ARAGON_MOUSE`.
+    const team = process.env.ARAGON_TEAM?.trim().toLowerCase();
+    const teamMax = process.env.ARAGON_TEAM_MAX?.trim();
+    if ((team !== undefined && team.length > 0) || (teamMax !== undefined && teamMax.length > 0)) {
+        const section = {};
+        if (team !== undefined && team.length > 0) {
+            section.enabled = team === '1' || team === 'true' || team === 'on' || team === 'yes';
+        }
+        if (teamMax !== undefined && teamMax.length > 0) {
+            const parsed = Number.parseInt(teamMax, 10);
+            // Left ABSENT when unparseable rather than written as a default, so the
+            // config file can still win. A resolved default here would make the env
+            // var look permanently supplied.
+            if (Number.isFinite(parsed) && parsed > 0)
+                section.maxSubagents = parsed;
+        }
+        // A PARTIAL section, safe only because every consumer deep-merges it — the
+        // same contract `partial.skills` and `partial.log` rely on.
+        if (Object.keys(section).length > 0)
+            partial.team = section;
+    }
     const log = readEnvLogConfig();
     if (log)
         partial.log = log;