@aragon-agent/cli 0.6.39 → 0.6.40

package/dist/config/schema.d.ts

@@ -206,15 +206,15 @@ export declare const DEFAULT_SCROLL_RESUME_MS = 5000;
  * Exactly the trap `retry.maxRetries` needed this helper for.
  */
 export declare function clampScrollResumeMs(v: unknown, fallback: number): number;
-/** `ask_user` calls allowed per user turn. */
-export declare const DEFAULT_PLAN_MAX_ASK_ROUNDS = 4;
 /**
  * Ceiling on ONE human wait, in ms. Thirty minutes is far outside "the user
  * went to get coffee", but a ceiling has to exist: an unattended terminal must
  * not wedge a CI job or a stale ssh session forever.
+ *
+ * THIS IS NOT A ROUND LIMIT and the distinction matters. It bounds a single wait
+ * (liveness); it says nothing about how many times the model may ask.
  */
 export declare const DEFAULT_PLAN_HUMAN_TIMEOUT_MS = 1800000;
-export declare function clampAskRounds(v: unknown, fallback: number): number;
 export declare function clampHumanTimeout(v: unknown, fallback: number): number;
 export interface SkillsConfig {
     enabled: boolean;
@@ -259,6 +259,18 @@ export interface SkillsConfig {
      * just be a second decorative field.
      */
     toolPolicy: SkillsToolPolicyMode;
+    /**
+     * Automatic skill triage (skill-triage-and-unbounded-ask §4.2.9): compute a
+     * short candidate list for each new task and put it in the system prompt, so
+     * "is a skill applicable?" becomes a question the protocol forces the model to
+     * answer rather than one it has to remember to ask.
+     *
+     * DEFAULT ON, and OFF must be byte-identical to the pre-feature prompt. That is
+     * what the block's conditional splice in `buildSystemPrompt` guarantees
+     * (invariant I-T1) — a permanently-on block would be a prompt change nobody
+     * could turn off.
+     */
+    triage: boolean;
 }
 export declare const SKILLS_INTEGRITY_MODES: readonly ["off", "warn", "strict"];
 export type SkillsIntegrityMode = (typeof SKILLS_INTEGRITY_MODES)[number];
@@ -343,6 +355,16 @@ export interface TeamConfig {
      * failed subagent.
      */
     maxConcurrent: number;
+    /**
+     * The one-shot marker `migrateLegacyTeamFanout` writes (subagent-fanout
+     * D-3), and NOTHING else may ever write it.
+     *
+     * It exists because the fan-out default moved 5/3 -> 8/8 while every save
+     * materializes the whole section: without a marker, a user who deliberately
+     * returns to 5/3 is migrated back to 8/8 on the next launch, for ever. Absent
+     * means "not yet migrated"; it is never written as `false`.
+     */
+    fanoutMigrated?: boolean;
     /**
      * One child's wall clock before its own abort. `0` (the default) means NO
      * ceiling: a subagent runs until it finishes or is aborted, exactly like
@@ -465,6 +487,40 @@ export declare const LEGACY_TEAM_CEILING_DEFAULTS: Readonly<{
  * equality test lives beside the constants it reads.
  */
 export declare function legacyTeamCeilingPatch(raw: unknown): Partial<TeamConfig> | null;
+/**
+ * The fan-out defaults cli <= 0.6.x persisted as its OWN defaults
+ * (subagent-fanout F-2 / R-1).
+ *
+ * THE SAME TRAP AS THE CEILINGS ABOVE, ONE SECTION OVER. `mergePersistedConfig`
+ * writes the WHOLE `team` section on every save, so a user who has ever touched
+ * any setting carries this exact pair in `config.json` - changing
+ * `DEFAULT_TEAM_CONFIG` alone would never reach them, and they would keep
+ * seeing "only 3 subagents at once" for ever.
+ */
+export declare const LEGACY_TEAM_FANOUT_DEFAULTS: {
+    readonly maxSubagents: 5;
+    readonly maxConcurrent: 3;
+};
+/**
+ * The `{ maxSubagents, maxConcurrent, fanoutMigrated }` patch for the legacy
+ * default pair, or `null` when nothing matches (subagent-fanout D-3).
+ *
+ * EXACT-EQUALITY ONLY, the rule `legacyTeamCeilingPatch` records: a value that
+ * differs was a deliberate user choice and survives untouched. Two differences
+ * from that function, both deliberate:
+ *
+ *  - `fanoutMigrated: true` short-circuits to `null`. That is what makes "the
+ *    user changed their mind and went back to 5/3" stick: without it the next
+ *    launch would migrate them again, every launch, for ever.
+ *  - `maxConcurrent` is allowed to be ABSENT as well as 3, because a
+ *    hand-written section may name only one key and a half-written pair is
+ *    still the legacy intent, not a user decision.
+ *
+ * Pure on purpose: `loadConfig` decides WHERE the patch is applied and
+ * persisted; this function only answers WHICH keys match, so the equality test
+ * lives beside the constants it reads.
+ */
+export declare function legacyTeamFanoutPatch(raw: unknown): Partial<TeamConfig> | null;
 export interface TodoConfig {
     /** Register `todo_write` at all. Default TRUE. */
     enabled: boolean;
@@ -1064,8 +1120,6 @@ export interface PersistedConfig {
     scrollResumeMs: number;
     /** Start every session in PLAN mode (plan-mode §4.4). */
     planModeDefault: boolean;
-    /** `ask_user` rounds allowed per user turn; clamped to [1, 10]. */
-    planModeMaxAskRounds: number;
     /** Ceiling on a single human wait in ms; clamped to [60_000, 7_200_000]. */
     planModeHumanTimeoutMs: number;
     /** Skill system settings. The SECOND nested object in this file after apiKeys. */
@@ -1118,6 +1172,29 @@ export declare const LEGACY_STATE_KEYS: readonly ["promptHistory", "submitCount"
  * one door for both directions.
  */
 export declare function stripLegacyStateKeys<T extends object>(raw: T): T;
+/**
+ * Config keys whose MEANING was removed, mapped to the explanation a user gets if
+ * they still try to set one.
+ *
+ * SEPARATE FROM `LEGACY_STATE_KEYS`, because the disposition differs: those keys'
+ * values were MOVED somewhere else, while these have nowhere to go — the feature
+ * they configured no longer exists. Merging the two lists would erase that
+ * difference at exactly the moment someone is reading the file to find out what
+ * happened to their setting.
+ *
+ * Stripped on the READ side for the same reason `stripLegacyStateKeys` is:
+ * `loadPersistedConfig()` merges `{ ...DEFAULT_CONFIG, ...partial }`, so a key
+ * left on disk rides that spread into memory and `updatePersistedConfig` writes it
+ * straight back. The user deletes the line, launches once, and watches it return.
+ */
+export declare const RETIRED_CONFIG_KEYS: Readonly<Record<string, string>>;
+/**
+ * THE single gate that keeps retired keys out of `config.json`. Applied on the
+ * read side, so it is self-healing: every write is read-strip-merge-write, and a
+ * hand-edited file, a downgrade to an older CLI and back, or a half-finished
+ * migration all converge on a clean file at the next write.
+ */
+export declare function stripRetiredConfigKeys<T extends object>(raw: T): T;
 export interface CliConfig {
     /** A committed model snapshot failed to apply; no further requests may start. */
     modelSettingsRestartRequired?: boolean;
@@ -1312,7 +1389,6 @@ export interface CliConfig {
      * live mode from here on belongs to the controller.
      */
     startInPlanMode: boolean;
-    planModeMaxAskRounds: number;
     planModeHumanTimeoutMs: number;
     skills: SkillsConfig;
     /** Flag/env-only skill switches for this run (§7.5). Never persisted. */

package/dist/config/schema.js

@@ -273,20 +273,23 @@ export function clampScrollResumeMs(v, fallback) {
 // nested-object merge is hand-written and capped at one level; three scalars do
 // not justify a second `clampXConfig` gate plus two more merge sites, and flat
 // keys mean `store.ts` needs ZERO changes.
+//
+// ONE OF THOSE KEYS IS GONE: `planModeMaxAskRounds` capped `ask_user` at four
+// rounds per turn. There is no cap any more, so there is no number to store, no
+// range to clamp and nothing to configure. It is retired through
+// `RETIRED_CONFIG_KEYS` below rather than defaulted to a large number — a
+// ninety-nine in the config file is the same second source of truth as a four.
 // ---------------------------------------------------------------------------
-/** `ask_user` calls allowed per user turn. */
-export const DEFAULT_PLAN_MAX_ASK_ROUNDS = 4;
-const ASK_ROUNDS_RANGE = { min: 1, max: 10 };
 /**
  * Ceiling on ONE human wait, in ms. Thirty minutes is far outside "the user
  * went to get coffee", but a ceiling has to exist: an unattended terminal must
  * not wedge a CI job or a stale ssh session forever.
+ *
+ * THIS IS NOT A ROUND LIMIT and the distinction matters. It bounds a single wait
+ * (liveness); it says nothing about how many times the model may ask.
  */
 export const DEFAULT_PLAN_HUMAN_TIMEOUT_MS = 1_800_000;
 const HUMAN_TIMEOUT_RANGE = { min: 60_000, max: 7_200_000 };
-export function clampAskRounds(v, fallback) {
-    return clampInt(v, fallback, ASK_ROUNDS_RANGE);
-}
 export function clampHumanTimeout(v, fallback) {
     return clampInt(v, fallback, HUMAN_TIMEOUT_RANGE);
 }
@@ -322,6 +325,9 @@ export const DEFAULT_SKILLS_CONFIG = {
     integrity: 'warn',
     usageTracking: true,
     toolPolicy: 'enforce',
+    // ON by default: the capability this key controls is the feature's whole point,
+    // and it costs zero model calls (local matching over in-memory records).
+    triage: true,
 };
 const CATALOG_BYTES_RANGE = { min: 500, max: 40_000 };
 /**
@@ -406,6 +412,7 @@ export function clampSkillsConfig(raw) {
         integrity: clampSkillsIntegrity(src.integrity, DEFAULT_SKILLS_CONFIG.integrity),
         usageTracking: bool(src.usageTracking, DEFAULT_SKILLS_CONFIG.usageTracking),
         toolPolicy: clampSkillsToolPolicy(src.toolPolicy, DEFAULT_SKILLS_CONFIG.toolPolicy),
+        triage: bool(src.triage, DEFAULT_SKILLS_CONFIG.triage),
     };
 }
 export const DEFAULT_SKILLS_RUNTIME = { forcedSkills: [], approveAll: false };
@@ -474,8 +481,12 @@ export function clampLogConfig(raw) {
 export const HARD_MAX_SUBAGENTS = TEAM_LIMITS.hardMaxSubagents;
 export const DEFAULT_TEAM_CONFIG = {
     enabled: true,
-    maxSubagents: 5,
-    maxConcurrent: 3,
+    // 8 IS THE DEFAULT, 10 IS THE CEILING, and they are not the same number
+    // (subagent-fanout D-1 / D-2). `maxConcurrent` moves WITH `maxSubagents`
+    // because a wider population behind a 3-wide pool shows the user nothing:
+    // children 4..8 simply queue (`team-bus.test.ts` records the queued phase).
+    maxSubagents: 8,
+    maxConcurrent: 8,
     // 0 = NO LIMIT. Subagents run under the same regime as the lead: no
     // wall clock, no turn cap; only the idle watchdog and the user's Esc.
     subagentTimeoutMs: 0,
@@ -534,6 +545,13 @@ export function clampTeamConfig(raw) {
             && [...src.modelProfileId].length <= 128
             ? src.modelProfileId
             : null,
+        // TRANSPARENT, and only ever `true` (subagent-fanout D-3 / R-6). The flag is
+        // not a setting: it is the one-shot marker the migration leaves behind, so a
+        // clamp that dropped it would re-migrate the user on every launch. Written
+        // as a spread rather than `=== true ? true : undefined` so the key stays
+        // ABSENT (not `undefined`) in the clamped result - `toEqual(DEFAULT_TEAM_CONFIG)`
+        // and the on-disk shape both depend on that.
+        ...(src.fanoutMigrated === true ? { fanoutMigrated: true } : {}),
     };
 }
 /**
@@ -574,6 +592,56 @@ export function legacyTeamCeilingPatch(raw) {
     }
     return matched ? patch : null;
 }
+/**
+ * The fan-out defaults cli <= 0.6.x persisted as its OWN defaults
+ * (subagent-fanout F-2 / R-1).
+ *
+ * THE SAME TRAP AS THE CEILINGS ABOVE, ONE SECTION OVER. `mergePersistedConfig`
+ * writes the WHOLE `team` section on every save, so a user who has ever touched
+ * any setting carries this exact pair in `config.json` - changing
+ * `DEFAULT_TEAM_CONFIG` alone would never reach them, and they would keep
+ * seeing "only 3 subagents at once" for ever.
+ */
+export const LEGACY_TEAM_FANOUT_DEFAULTS = {
+    maxSubagents: 5,
+    maxConcurrent: 3,
+};
+/**
+ * The `{ maxSubagents, maxConcurrent, fanoutMigrated }` patch for the legacy
+ * default pair, or `null` when nothing matches (subagent-fanout D-3).
+ *
+ * EXACT-EQUALITY ONLY, the rule `legacyTeamCeilingPatch` records: a value that
+ * differs was a deliberate user choice and survives untouched. Two differences
+ * from that function, both deliberate:
+ *
+ *  - `fanoutMigrated: true` short-circuits to `null`. That is what makes "the
+ *    user changed their mind and went back to 5/3" stick: without it the next
+ *    launch would migrate them again, every launch, for ever.
+ *  - `maxConcurrent` is allowed to be ABSENT as well as 3, because a
+ *    hand-written section may name only one key and a half-written pair is
+ *    still the legacy intent, not a user decision.
+ *
+ * Pure on purpose: `loadConfig` decides WHERE the patch is applied and
+ * persisted; this function only answers WHICH keys match, so the equality test
+ * lives beside the constants it reads.
+ */
+export function legacyTeamFanoutPatch(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const src = raw;
+    if (src.fanoutMigrated === true)
+        return null;
+    if (src.maxSubagents !== LEGACY_TEAM_FANOUT_DEFAULTS.maxSubagents)
+        return null;
+    if (src.maxConcurrent !== undefined
+        && src.maxConcurrent !== LEGACY_TEAM_FANOUT_DEFAULTS.maxConcurrent)
+        return null;
+    return {
+        maxSubagents: DEFAULT_TEAM_CONFIG.maxSubagents,
+        maxConcurrent: DEFAULT_TEAM_CONFIG.maxConcurrent,
+        fanoutMigrated: true,
+    };
+}
 export const DEFAULT_TODO_CONFIG = {
     enabled: true,
     panel: true,
@@ -1069,7 +1137,6 @@ export const DEFAULT_CONFIG = {
     keyboardEnhancement: true,
     scrollResumeMs: DEFAULT_SCROLL_RESUME_MS,
     planModeDefault: false,
-    planModeMaxAskRounds: DEFAULT_PLAN_MAX_ASK_ROUNDS,
     planModeHumanTimeoutMs: DEFAULT_PLAN_HUMAN_TIMEOUT_MS,
     skills: DEFAULT_SKILLS_CONFIG,
     log: DEFAULT_LOG_CONFIG,
@@ -1162,6 +1229,37 @@ export function stripLegacyStateKeys(raw) {
         delete out[key];
     return out;
 }
+/**
+ * Config keys whose MEANING was removed, mapped to the explanation a user gets if
+ * they still try to set one.
+ *
+ * SEPARATE FROM `LEGACY_STATE_KEYS`, because the disposition differs: those keys'
+ * values were MOVED somewhere else, while these have nowhere to go — the feature
+ * they configured no longer exists. Merging the two lists would erase that
+ * difference at exactly the moment someone is reading the file to find out what
+ * happened to their setting.
+ *
+ * Stripped on the READ side for the same reason `stripLegacyStateKeys` is:
+ * `loadPersistedConfig()` merges `{ ...DEFAULT_CONFIG, ...partial }`, so a key
+ * left on disk rides that spread into memory and `updatePersistedConfig` writes it
+ * straight back. The user deletes the line, launches once, and watches it return.
+ */
+export const RETIRED_CONFIG_KEYS = {
+    planModeMaxAskRounds: 'ask_user has no round limit any more, so this key is gone. Nothing to set; ' +
+        'the next config write removes it from config.json.',
+};
+/**
+ * THE single gate that keeps retired keys out of `config.json`. Applied on the
+ * read side, so it is self-healing: every write is read-strip-merge-write, and a
+ * hand-edited file, a downgrade to an older CLI and back, or a half-finished
+ * migration all converge on a clean file at the next write.
+ */
+export function stripRetiredConfigKeys(raw) {
+    const out = { ...raw };
+    for (const key of Object.keys(RETIRED_CONFIG_KEYS))
+        delete out[key];
+    return out;
+}
 // ---------------------------------------------------------------------------
 // Coercion / validation helpers
 // ---------------------------------------------------------------------------

package/dist/config/store.js

@@ -17,7 +17,7 @@ import { getConfigPath, getSessionsDir } from './app-paths.js';
 import { registerProfileSecrets, registerSecretsFrom } from '../logging/secret-registry.js';
 import { adaptLegacyConnectionPatch, ModelProfileConfigError, readModelSettingsDisk } from './model-profile-store.js';
 import { normalizeModelProfiles } from './model-profiles.js';
-import { clampBashConfig, clampJobsConfig, clampPromptsConfig, clampTaskSummaryConfig, CONFIG_VERSION, DEFAULT_CONFIG, clampCompactionConfig, clampFastConfig, clampLogConfig, clampMaxTokens, clampRetryConfig, clampSkillsConfig, clampTeamConfig, clampTodoConfig, clampContextWindow, clampUpdateConfig, isAutoToken, stripLegacyStateKeys, } from './schema.js';
+import { clampBashConfig, clampJobsConfig, clampPromptsConfig, clampTaskSummaryConfig, CONFIG_VERSION, DEFAULT_CONFIG, clampCompactionConfig, clampFastConfig, clampLogConfig, clampMaxTokens, clampRetryConfig, clampSkillsConfig, clampTeamConfig, clampTodoConfig, clampContextWindow, clampUpdateConfig, isAutoToken, stripLegacyStateKeys, stripRetiredConfigKeys, } from './schema.js';
 /**
  * Normalize `maxTokens` for both directions of the config file.
  *
@@ -124,7 +124,12 @@ export function normalizePersistedConfig(input) {
     // on disk would otherwise ride the spread into `merged` and be written back
     // out by `updatePersistedConfig` — the "I deleted it and it grew back" bug
     // that `stripLegacyStateKeys` exists to make impossible (§4.5).
-    const partial = stripLegacyStateKeys(input);
+    //
+    // TWO PASSES, DELIBERATELY: `stripLegacyStateKeys` handles keys whose value
+    // MOVED, `stripRetiredConfigKeys` handles keys whose FEATURE was removed
+    // (`planModeMaxAskRounds`). Same door, different reasons, and each list keeps
+    // growing on its own schedule.
+    const partial = stripRetiredConfigKeys(stripLegacyStateKeys(input));
     delete partial.fullscreen;
     return {
         ...DEFAULT_CONFIG,

package/dist/proc/log-mirror.d.ts

@@ -9,7 +9,7 @@
  * `read_file` and `grep`): it is the full log on disk plus the PATH in the
  * truncation note.
  *
- * THREE RULES, each of which is about not becoming a new failure mode:
+ * THREE RULES PLUS A SCOPE, each of which is about not becoming a new failure mode:
  *
  *  - ASYNC AND COALESCED. `appendFile` with a <=4 writes/second buffer, so a
  *    webpack build emitting thousands of lines cannot turn logging into the
@@ -19,19 +19,36 @@
  *  - FAILURES ARE DEBUG LOGS, NEVER THROWS. A full disk must not kill a training
  *    run; the ring, the tools and the job state machine do not depend on this
  *    module at all.
+ *  - SCOPED TO ITS OWN ROOT. The retention sweep deletes session directories under
+ *    the jobs root the CALLER names, never under a parent derived from it: a
+ *    derived parent is other people's directory the moment the mirror is handed a
+ *    scratch path.
  */
 export interface JobLogMirrorOptions {
     /** `${aragonHome}/jobs/${sessionTag}`. A closure so a test can hand in a temp dir. */
     root: () => string;
+    /**
+     * THE DIRECTORY WHOSE SESSION SUBDIRECTORIES MAY BE SWEPT - passed, never derived.
+     *
+     * `dirname(root())` used to stand in for this, and it was wrong in the only way that
+     * matters: for any caller whose `root()` does not sit exactly one level below the jobs
+     * directory (a scratch dir in a test is the OS temp root's child) it handed the sweep a
+     * directory full of OTHER people's data and deleted everything but the newest few
+     * entries. A release run paid 40 s for that sweep and lost the temp directories of the
+     * test files running beside it. Omitted means NO sweep at all: growth is bounded only
+     * for callers that name the root they own.
+     */
+    jobsRoot?: () => string;
     maxBytes?: number;
     flushMs?: number;
 }
 /**
  * Delete all but the newest `PROC_LIMITS.mirrorRetainDirs` session directories.
  *
- * BEST EFFORT AND SILENT. This runs once per process at first use, and its whole
- * job is to stop `~/.aragon-agent/jobs/` from growing without bound; a directory
- * that cannot be read is not a reason to refuse to start.
+ * BEST EFFORT AND SILENT. This runs once per mirror at first use, and its whole job is to
+ * stop `~/.aragon-agent/jobs/` from growing without bound; a directory that cannot be read
+ * is not a reason to refuse to start. `jobsRoot` MUST be the directory this module owns -
+ * see `JobLogMirrorOptions.jobsRoot` for what deriving it cost.
  */
 export declare function pruneJobLogSessions(jobsRoot: string): void;
 export declare class JobLogMirror {

package/dist/proc/log-mirror.js

@@ -9,7 +9,7 @@
  * `read_file` and `grep`): it is the full log on disk plus the PATH in the
  * truncation note.
  *
- * THREE RULES, each of which is about not becoming a new failure mode:
+ * THREE RULES PLUS A SCOPE, each of which is about not becoming a new failure mode:
  *
  *  - ASYNC AND COALESCED. `appendFile` with a <=4 writes/second buffer, so a
  *    webpack build emitting thousands of lines cannot turn logging into the
@@ -19,18 +19,34 @@
  *  - FAILURES ARE DEBUG LOGS, NEVER THROWS. A full disk must not kill a training
  *    run; the ring, the tools and the job state machine do not depend on this
  *    module at all.
+ *  - SCOPED TO ITS OWN ROOT. The retention sweep deletes session directories under
+ *    the jobs root the CALLER names, never under a parent derived from it: a
+ *    derived parent is other people's directory the moment the mirror is handed a
+ *    scratch path.
  */
 import { appendFile, appendFileSync, mkdirSync, readdirSync, rmSync, statSync } from 'node:fs';
 import { existsSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { getLogger } from '../logging/logger.js';
 import { PROC_LIMITS } from './limits.js';
+/**
+ * True when `path` holds nothing but `<jobId>.log` files, or nothing at all.
+ *
+ * DEFENSE IN DEPTH, NOT THE PRIMARY GUARD. The primary guard is that the caller names
+ * the jobs root instead of having it derived. This one means a sweep handed a directory
+ * that is not a mirror root is a no-op rather than a data loss - an empty directory and a
+ * directory of job logs are the only two shapes this module ever creates.
+ */
+function isMirrorDirectory(path) {
+    return readdirSync(path, { withFileTypes: true }).every((entry) => entry.isFile() && entry.name.endsWith('.log'));
+}
 /**
  * Delete all but the newest `PROC_LIMITS.mirrorRetainDirs` session directories.
  *
- * BEST EFFORT AND SILENT. This runs once per process at first use, and its whole
- * job is to stop `~/.aragon-agent/jobs/` from growing without bound; a directory
- * that cannot be read is not a reason to refuse to start.
+ * BEST EFFORT AND SILENT. This runs once per mirror at first use, and its whole job is to
+ * stop `~/.aragon-agent/jobs/` from growing without bound; a directory that cannot be read
+ * is not a reason to refuse to start. `jobsRoot` MUST be the directory this module owns -
+ * see `JobLogMirrorOptions.jobsRoot` for what deriving it cost.
  */
 export function pruneJobLogSessions(jobsRoot) {
     try {
@@ -41,14 +57,16 @@ export function pruneJobLogSessions(jobsRoot) {
             .map((entry) => {
             const path = join(jobsRoot, entry.name);
             try {
-                return { path, mtime: statSync(path).mtimeMs };
+                return { path, mtime: statSync(path).mtimeMs, prunable: isMirrorDirectory(path) };
             }
             catch {
-                return { path, mtime: 0 };
+                return { path, mtime: 0, prunable: false };
             }
         })
             .sort((a, b) => b.mtime - a.mtime);
         for (const stale of dirs.slice(PROC_LIMITS.mirrorRetainDirs)) {
+            if (!stale.prunable)
+                continue;
             try {
                 rmSync(stale.path, { recursive: true, force: true });
             }
@@ -107,7 +125,11 @@ export class JobLogMirror {
             this.files.set(jobId, { path, bytes, capped: bytes >= this.maxBytes() });
             if (!this.pruned) {
                 this.pruned = true;
-                pruneJobLogSessions(dirname(this.opts.root()));
+                // ONLY THE ROOT THE CALLER NAMED. See `JobLogMirrorOptions.jobsRoot` for why
+                // `dirname(root())` is not a substitute for it.
+                const jobsRoot = this.opts.jobsRoot?.();
+                if (jobsRoot !== undefined)
+                    pruneJobLogSessions(jobsRoot);
             }
         }
         catch (err) {

package/dist/skills/service.d.ts

@@ -9,6 +9,7 @@ import { SkillRegistry, type SkillFileRef, type SkillHost, type SkillPlatform, t
 import type { NoticeLevel } from '../agent/reducer.js';
 import type { SkillsConfig, SkillsRuntimeOptions, SkillsToolPolicyMode } from '../config/schema.js';
 import { type ConfirmRequest } from '../tools/index.js';
+import { type SkillRoutingReport } from './triage.js';
 /**
  * Capability-probing approval gate (D17 / §8.3.1).
  *
@@ -229,6 +230,46 @@ export declare class SkillService {
     /** Warn once about `--skill <name>` values that match nothing (§7.5). */
     reportUnknownForcedSkills(): void;
     setDisabled(name: string, disabled: boolean): void;
+    /**
+     * Route one task against the installed skills — PURE COMPUTATION (I-T2).
+     *
+     * Reads in-memory records only: no file, no body, no network, no model call. The
+     * whole "which skills could apply here" question therefore costs zero context
+     * bytes, which is what makes the disclosure ladder honest — Level 2 is paid for
+     * only when the model actually opens a skill.
+     *
+     * Returns `null` when triage is switched off, so every caller has one shape to
+     * check rather than an empty report that looks like "no match".
+     *
+     * Writes NO usage counter. An automatic proposal is not a user's choice, which
+     * is the same reason `loadBody({ countUse: false })` exists for always-on
+     * skills: counting it would pin an auto-suggested skill to the top of the
+     * ranking forever and destroy the signal the ranking is there to carry.
+     */
+    triage(task: string): SkillRoutingReport | null;
+    /**
+     * `/skills route <text>` — the same computation, WITHOUT the on/off gate.
+     *
+     * The gate exists to keep the block out of the prompt; it must not make the
+     * explanation unreachable, because "why did nothing match" is the question a user
+     * asks precisely when they suspect the switch is off.
+     */
+    route(task: string): SkillRoutingReport;
+    /**
+     * `/skills triage on|off` — persist the switch AND rebuild the prompt now.
+     *
+     * `updateConfig` deliberately only replaces this object's config and calls
+     * `persist`; it does NOT call `deps.onChange`. Every other mutator supplies that
+     * call itself (`setDisabled` above, the directory-trust path below), and `onChange`
+     * is the sole route to `controller.refreshSkills()` → `rebuildSystemPrompt()`.
+     * Without it the setting would be written to disk and the running session would
+     * keep the old prompt until the next launch — which reads as a broken switch.
+     *
+     * The early return is not an optimization: `updateConfig` persists, so flipping a
+     * switch to the value it already has would produce a pointless disk write and a
+     * pointless prompt rebuild on every keystroke.
+     */
+    setTriageEnabled(enabled: boolean): void;
     getConfig(): SkillsConfig;
     /** Local use counters backing `--sort=recent`; empty when tracking is off. */
     getUsage(): SkillUsageMap;

package/dist/skills/service.js

@@ -14,6 +14,7 @@ import { currentPlatform } from './node-host.js';
 import { MANIFEST_FILENAME, readManifest, sha256Buffer, sha256File } from './manifest.js';
 import { isDirectory, normalizeTrustPath, resolveSkillRoots, getStagingDir, } from './paths.js';
 import { USAGE_MAX_ENTRIES, loadUsage, pruneUsage, recordUse } from './usage.js';
+import { buildRoutingReport } from './triage.js';
 const ENTRY_FILE = 'SKILL.md';
 /**
  * Re-exported from `manifest.ts` rather than spelled out again. The two copies
@@ -615,6 +616,67 @@ export class SkillService {
         this.updateConfig({ disabled: [...next] });
         this.deps.onChange?.();
     }
+    /**
+     * Route one task against the installed skills — PURE COMPUTATION (I-T2).
+     *
+     * Reads in-memory records only: no file, no body, no network, no model call. The
+     * whole "which skills could apply here" question therefore costs zero context
+     * bytes, which is what makes the disclosure ladder honest — Level 2 is paid for
+     * only when the model actually opens a skill.
+     *
+     * Returns `null` when triage is switched off, so every caller has one shape to
+     * check rather than an empty report that looks like "no match".
+     *
+     * Writes NO usage counter. An automatic proposal is not a user's choice, which
+     * is the same reason `loadBody({ countUse: false })` exists for always-on
+     * skills: counting it would pin an auto-suggested skill to the top of the
+     * ranking forever and destroy the signal the ranking is there to carry.
+     */
+    triage(task) {
+        if (!this.config.enabled || !this.config.triage)
+            return null;
+        return buildRoutingReport({
+            task,
+            records: this.registry.list(),
+            activeNames: this.registry.activeNames,
+            now: Date.now(),
+        });
+    }
+    /**
+     * `/skills route <text>` — the same computation, WITHOUT the on/off gate.
+     *
+     * The gate exists to keep the block out of the prompt; it must not make the
+     * explanation unreachable, because "why did nothing match" is the question a user
+     * asks precisely when they suspect the switch is off.
+     */
+    route(task) {
+        return buildRoutingReport({
+            task,
+            records: this.registry.list(),
+            activeNames: this.registry.activeNames,
+            now: Date.now(),
+        });
+    }
+    /**
+     * `/skills triage on|off` — persist the switch AND rebuild the prompt now.
+     *
+     * `updateConfig` deliberately only replaces this object's config and calls
+     * `persist`; it does NOT call `deps.onChange`. Every other mutator supplies that
+     * call itself (`setDisabled` above, the directory-trust path below), and `onChange`
+     * is the sole route to `controller.refreshSkills()` → `rebuildSystemPrompt()`.
+     * Without it the setting would be written to disk and the running session would
+     * keep the old prompt until the next launch — which reads as a broken switch.
+     *
+     * The early return is not an optimization: `updateConfig` persists, so flipping a
+     * switch to the value it already has would produce a pointless disk write and a
+     * pointless prompt rebuild on every keystroke.
+     */
+    setTriageEnabled(enabled) {
+        if (this.config.triage === enabled)
+            return;
+        this.updateConfig({ triage: enabled });
+        this.deps.onChange?.();
+    }
     getConfig() {
         return this.config;
     }