@aragon-agent/cli 0.6.38 → 0.6.40

package/dist/cli.js

@@ -25,11 +25,11 @@ 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';
-import { ADAPTER_PROVIDERS, clampDensity, clampTheme, clampThinkingLevel, clampAskRounds, clampHumanTimeout, clampSkillsIntegrity, clampSkillsToolPolicy, clampContextWindow, clampMaxRenderInterval, clampScrollMode, clampScrollResumeMs, clampTranscriptRetain, clampTranscriptWindow, coercePositiveInt, isAdapterProvider, isAutoToken, parseMaxTokensInput, DEFAULT_MAX_RENDER_INTERVAL_MS, DEFAULT_MAX_TOKENS, DEFAULT_PLAN_HUMAN_TIMEOUT_MS, DEFAULT_PLAN_MAX_ASK_ROUNDS, DEFAULT_SCROLL_MODE, DEFAULT_SCROLL_RESUME_MS, DEFAULT_SKILLS_CONFIG, DEFAULT_TRANSCRIPT_RETAIN, DEFAULT_TRANSCRIPT_WINDOW, } from './config/schema.js';
+import { ADAPTER_PROVIDERS, clampDensity, clampTheme, clampThinkingLevel, clampHumanTimeout, clampSkillsIntegrity, clampSkillsToolPolicy, clampContextWindow, clampMaxRenderInterval, clampScrollMode, clampScrollResumeMs, clampTranscriptRetain, clampTranscriptWindow, coercePositiveInt, isAdapterProvider, isAutoToken, parseMaxTokensInput, RETIRED_CONFIG_KEYS, DEFAULT_MAX_RENDER_INTERVAL_MS, DEFAULT_MAX_TOKENS, DEFAULT_PLAN_HUMAN_TIMEOUT_MS, DEFAULT_SCROLL_MODE, DEFAULT_SCROLL_RESUME_MS, DEFAULT_SKILLS_CONFIG, DEFAULT_TRANSCRIPT_RETAIN, DEFAULT_TRANSCRIPT_WINDOW, } 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';
@@ -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;
 }
 /**
@@ -1517,7 +1559,6 @@ const CONFIG_SET_KEYS = new Set([
     'scrollResumeMs',
     'historyEnabled',
     'planModeDefault',
-    'planModeMaxAskRounds',
     'planModeHumanTimeoutMs',
     // Dotted keys route into the nested `skills` object; see the switch below.
     'skills.enabled',
@@ -1527,6 +1568,7 @@ const CONFIG_SET_KEYS = new Set([
     'skills.integrity',
     'skills.usageTracking',
     'skills.toolPolicy',
+    'skills.triage',
     // `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,
@@ -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>`.
@@ -1612,6 +1660,18 @@ function runConfigSet(key, value) {
     }
 }
 function runConfigSetValue(key, value) {
+    // RETIRED KEYS ARE REFUSED BY NAME, BEFORE THE UNKNOWN-KEY CHECK. Falling
+    // through to `Unknown config key` would be technically true and practically
+    // useless: a script that has run `config set planModeMaxAskRounds 5` for months
+    // needs to be told what happened to it, not that it never existed. Exit 2 for
+    // the same reason a bad value is 2 — the caller's argument is wrong, the file
+    // is not.
+    const retired = RETIRED_CONFIG_KEYS[key];
+    if (retired !== undefined) {
+        process.stderr.write(`"${key}" was removed: ${retired}\n`);
+        process.exitCode = 2;
+        return;
+    }
     if (!CONFIG_SET_KEYS.has(key)) {
         process.stderr.write(`Unknown config key "${key}". Known keys: ${[...CONFIG_SET_KEYS].join(', ')}.\n`);
         process.exitCode = 2;
@@ -1701,6 +1761,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':
@@ -1794,9 +1864,6 @@ function runConfigSetValue(key, value) {
         case 'planModeDefault':
             patch.planModeDefault = value === 'true' || value === '1';
             break;
-        case 'planModeMaxAskRounds':
-            patch.planModeMaxAskRounds = clampAskRounds(value, DEFAULT_PLAN_MAX_ASK_ROUNDS);
-            break;
         case 'planModeHumanTimeoutMs':
             patch.planModeHumanTimeoutMs = clampHumanTimeout(value, DEFAULT_PLAN_HUMAN_TIMEOUT_MS);
             break;
@@ -1835,6 +1902,13 @@ function runConfigSetValue(key, value) {
                 toolPolicy: clampSkillsToolPolicy(value, DEFAULT_SKILLS_CONFIG.toolPolicy),
             };
             break;
+        // The triage master switch. `false` restores the pre-feature prompt BYTE FOR
+        // BYTE (invariant I-T1), which is the reason it is a key rather than a flag.
+        case 'skills.triage':
+            patch.skills = {
+                triage: value === 'true' || value === '1',
+            };
+            break;
     }
     updatePersistedConfig(patch);
     process.stdout.write(`Set ${key} = ${value}\n`);

package/dist/commands/builtins.js

@@ -27,6 +27,13 @@ import { registerQueueCommand } from './queue-command.js';
 import { registerPromptCommands } from '../prompts/command.js';
 import { registerKitCommand } from './kit-command.js';
 import { registerAgentsCommand } from './agents-command.js';
+import { registerSubagentCommand } from './subagent-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';
@@ -406,8 +413,10 @@ const COMMANDS = [
             if (arg === 'status') {
                 const s = ctx.controller.getPlanStatus();
                 const pending = s.pending ? ` (pending ${MODE_LABEL[s.pending]} after this run)` : '';
-                ctx.notify('info', `Mode: ${MODE_LABEL[s.effective]}${pending}. ` +
-                    `Ask rounds used: ${s.askRoundsUsed}/${s.maxAskRounds}.`);
+                // NO ROUND COUNT. The old line ended with `Ask rounds used: 3/4.`, which
+                // told the user their agent was rationing questions - a limit that no
+                // longer exists. Nothing replaced it: "0 of unlimited" is noise.
+                ctx.notify('info', `Mode: ${MODE_LABEL[s.effective]}${pending}.`);
                 return;
             }
             if (arg.length > 0 && arg !== 'on' && arg !== 'off') {
@@ -1502,6 +1511,16 @@ 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);
+    // `/subagent` (subagent-fanout 3.5). REGISTERED UNCONDITIONALLY, like `/prompts`
+    // and for the same reason: a `--no-team` session must still be able to ask the
+    // command why it cannot force anything (I-7 / AC-15) - so registering it may
+    // not read config, build a connection or send a request.
+    registerSubagentCommand(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 +1530,9 @@ 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', 'subagent',
+    '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/skills.js

@@ -12,6 +12,7 @@ import { checkManifest } from '../skills/manifest.js';
 import { updateAllSkills, updateSkill, isHardFailure } from '../skills/updater.js';
 import { currentPlatform } from '../skills/node-host.js';
 import { listUsage, resetUsage, getUsagePath } from '../skills/usage.js';
+import { SKILL_TRIAGE_LIMITS } from '../skills/triage.js';
 import { HOST_TOOL_NAMES, SKILL_TOOL_FLOOR } from '../tools/index.js';
 import { SKILLS_TOOL_POLICY_MODES, isSkillsToolPolicyMode } from '../config/schema.js';
 import { pickGlyphs } from '../ui/glyphs.js';
@@ -92,12 +93,96 @@ async function runSkills(ctx, service, version) {
             return unloadFrames(ctx, service);
         case 'usage':
             return usageFromCommand(ctx, service, argument);
+        case 'triage':
+            return triageFromCommand(ctx, service, argument);
+        case 'route':
+            return routeFromCommand(ctx, service, argument);
         default:
             ctx.notify('warn', `Unknown subcommand "/skills ${sub}". Try: list, info, install, update, remove, enable, ` +
-                'disable, reload, create, trust, untrust, policy, unload, usage.');
+                'disable, reload, create, trust, untrust, policy, unload, usage, triage, route.');
     }
 }
 // ---------------------------------------------------------------------------
+// /skills triage · route  (skill-triage-and-unbounded-ask §4.2.8)
+// ---------------------------------------------------------------------------
+/**
+ * `/skills triage [on|off]`.
+ *
+ * The report names the switch AND the last turn's result, because "on" alone does
+ * not answer the question a user actually has, which is "is it finding anything?".
+ * `lastSkillRouting` comes from the controller — it is per-turn session state, not
+ * skill-service state, and the service must not start owning a copy of it.
+ */
+function triageFromCommand(ctx, service, argument) {
+    const requested = argument.trim().toLowerCase();
+    if (requested.length === 0) {
+        const on = service.getConfig().triage === true;
+        const last = ctx.controller.getSkillRouting();
+        const summary = last === null
+            ? 'No turn has been triaged yet.'
+            : last.candidates.length === 0
+                ? `Last turn: no candidate (${last.eligible} eligible skill(s) scored).`
+                : `Last turn: ${last.candidates.length} candidate(s), best ${last.candidates[0].name} (${last.candidates[0].score}).`;
+        ctx.notify('info', `Skill triage: ${on ? 'on' : 'off'}. ${summary}`);
+        return;
+    }
+    if (requested !== 'on' && requested !== 'off') {
+        ctx.notify('warn', `Unknown argument "${argument}" - use /skills triage [on|off].`);
+        return;
+    }
+    const enabled = requested === 'on';
+    // `setTriageEnabled` persists AND fires `onChange`, which rebuilds the prompt in
+    // this session. Without that second half the switch would look applied and take
+    // effect only after a restart (AC-T23).
+    service.setTriageEnabled(enabled);
+    // A toast, not a transcript notice: flipping a switch is an acknowledgement, and
+    // `toast` is this package's channel for exactly that (see `toggleSkill`). The
+    // level still differs by direction, so "off" does not read as a win.
+    ctx.toast(enabled ? 'success' : 'info', `Skill triage: ${enabled ? 'on' : 'off'}. ` +
+        (enabled
+            ? 'Each new task gets a short candidate list.'
+            : 'The system prompt no longer carries the triage block.'));
+}
+/**
+ * `/skills route [text]`.
+ *
+ * Two modes, one output shape. With text it routes that text; without text it
+ * replays the previous turn's real routing, which is the case a user is most often
+ * in — they just watched the model ignore a suggestion. The "never triaged" text
+ * names the form that works instead of leaving them to guess.
+ */
+function routeFromCommand(ctx, service, argument) {
+    const task = argument.trim();
+    if (task.length === 0) {
+        const last = ctx.controller.getSkillRouting();
+        if (last === null) {
+            ctx.notify('info', 'No turn has been triaged yet. Run /skills route <text> to try one.');
+            return;
+        }
+        ctx.notify('info', renderRoutingReport(last));
+        return;
+    }
+    // A fresh computation, NOT the cached one: `/skills route <text>` is how a user
+    // tests whether a phrasing would have matched.
+    ctx.notify('info', renderRoutingReport(service.route(task)));
+}
+/** One `info` notification, one line per candidate, ASCII only (`commands/`). */
+function renderRoutingReport(report) {
+    if (report.candidates.length === 0) {
+        const close = report.topUnqualified === null
+            ? ''
+            : ` Closest was ${report.topUnqualified.name} (${report.topUnqualified.score}); ` +
+                `the threshold is ${SKILL_TRIAGE_LIMITS.minScore}.`;
+        return (`No skill matched "${report.task}". The catalog has ${report.eligible} eligible skills.` +
+            close);
+    }
+    const lines = report.candidates.map((candidate) => {
+        const reasons = candidate.reasons.length > 0 ? candidate.reasons.join('+') : 'none';
+        return `${candidate.name} (${candidate.scope}) score ${candidate.score} [${reasons}]`;
+    });
+    return [`Routed "${report.task}" (${report.tokenCount} token(s)):`, ...lines].join('\n');
+}
+// ---------------------------------------------------------------------------
 // /skills policy · unload · usage  (§5.5 / §9)
 // ---------------------------------------------------------------------------
 /**

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

@@ -0,0 +1,25 @@
+/**
+ * `/subagent` — force the next turn to fan out into a parallel team
+ * (subagent-fanout 3.5 / 5.2).
+ *
+ * ASCII ONLY: `src/commands/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * WHAT THIS COMMAND IS AND IS NOT (D-8 / D-9 / D-10). It does not dispatch: it
+ * parses the user's intent, refuses honestly when forcing cannot work, prints
+ * ONE line saying what will happen next, and submits a normal user turn. The
+ * lead then calls `task` on the one dispatch path that already exists, so Esc,
+ * the watchdog pause, the report, spend accounting and the concurrency lock all
+ * keep working without a second implementation. The consequence the user must
+ * be told about is that forcing is INSTRUCTION-LEVEL: the notice says "the next
+ * turn dispatches them", never "N subagents started".
+ *
+ * THE GUARD ORDER IS A CONTRACT (R-P1-10 / R-P1-11): status -> capability ->
+ * parse. A `--no-team` session typing `/subagent -n x` is told the session has
+ * no team capability, because a syntax hint would send them to fix the one thing
+ * that is not wrong.
+ */
+import type { CommandContext, CommandRegistry } from './registry.js';
+/** The command body; `registerSubagentCommand` is the only registration site. */
+export declare function runSubagentCommand(ctx: CommandContext): void;
+/** Registered from `builtins.ts` with one line, next to every other subsystem. */
+export declare function registerSubagentCommand(registry: CommandRegistry): void;