@aragon-agent/cli 0.6.15 → 0.6.17

package/dist/config/load.d.ts

@@ -59,6 +59,15 @@ export interface CliFlags {
      * `false` on every run that passed no flag at all.
      */
     paste?: boolean;
+    /**
+     * `--keyboard-enhancement` ⇒ true, `--no-keyboard-enhancement` ⇒ false,
+     * absent ⇒ undefined.
+     *
+     * DECLARED AS A PAIR and carried through `toFlags`, for the reason the
+     * `paste` note above records: the key is persisted and defaults to
+     * `true`, so a lone negative flag must not read as silence.
+     */
+    keyboardEnhancement?: boolean;
     /** `--no-skills` ⇒ false. Turns the whole skill subsystem off (§7.5). */
     skills?: boolean;
     /** `--skill <name>` ×N — force Level 2 injection for this run. */
@@ -184,23 +193,6 @@ export interface CliFlags {
      * to keep in step with `toFlags`.
      */
     fastReview?: string;
-    /**
-     * `--fast-delegate` ⇒ true, `--no-fast-delegate` ⇒ false, absent ⇒ undefined
-     * (web-use-tier-cooperation-and-control-closure §4.1.5).
-     *
-     * DECLARED AS A PAIR — MANDATORY, for the reason `--team`, `--todo-panel`,
-     * `--render-governor`, `--retry` and `--fast` each record in turn, and here
-     * with the SAME polarity as `--update`: `fast.delegate` is PERSISTED and
-     * defaults to `true`, so a lone `--no-fast-delegate` would make commander
-     * default `opts.fastDelegate` to `true` and silently overwrite a stored
-     * `false` on every run that passed no flag at all.
-     *
-     * It exists because it is the ONLY `fast.*` sub-switch with no channel a
-     * wrapper can reach: `--fast-review <n|off>` already covers `review` and
-     * `reviewEveryTurns`, and `enabled` / `model` / `provider` have both a flag
-     * and an environment variable.
-     */
-    fastDelegate?: boolean;
     /**
      * `--update` ⇒ true, `--no-update` ⇒ false, absent ⇒ undefined
      * (cli-auto-update §4.2).

package/dist/config/load.js

@@ -78,6 +78,19 @@ function resolvePaste(flags, env, file) {
         return file.paste;
     return DEFAULT_CONFIG.paste;
 }
+/**
+ * Keyboard enhancement: flag > env > file > default `true`. Shaped exactly
+ * like `resolvePaste` above, for the reason its own note gives.
+ */
+function resolveKeyboardEnhancement(flags, env, file) {
+    if (flags.keyboardEnhancement !== undefined)
+        return flags.keyboardEnhancement;
+    if (env.keyboardEnhancement !== undefined)
+        return env.keyboardEnhancement;
+    if (file.keyboardEnhancement !== undefined)
+        return file.keyboardEnhancement;
+    return DEFAULT_CONFIG.keyboardEnhancement;
+}
 /**
  * Idle scroll-resume delay: env › file › default 5000, clamped to [0, 120000].
  *
@@ -230,12 +243,6 @@ function resolveFastConfig(flags, env, file) {
         ...(flags.fastProvider !== undefined && flags.fastProvider !== ''
             ? { provider: flags.fastProvider }
             : {}),
-        // `!== undefined`, for the reason stated on `flags.fast` above: commander
-        // materialises a lone `--no-fast-delegate` as `opts.fastDelegate = true`
-        // when the flag is absent, and `delegate` defaults to TRUE — so a truthiness
-        // check would force it on for every run that passed no flag at all,
-        // overwriting a stored `false` with nothing to show for it.
-        ...(flags.fastDelegate !== undefined ? { delegate: flags.fastDelegate } : {}),
         ...reviewPatch,
     });
 }
@@ -585,6 +592,7 @@ export function loadConfig(flags = {}, options = {}) {
         mouse: resolveMouse(flags, env.partial, file),
         mouseSelect: resolveMouseSelect(flags, env.partial, file),
         paste: resolvePaste(flags, env.partial, file),
+        keyboardEnhancement: resolveKeyboardEnhancement(flags, env.partial, file),
         scrollResumeMs: resolveScrollResumeMs(env.partial, file),
         // From `<home>/state.json`, not the config file — see `ui-state.ts`.
         submitCount: readSubmitCount(),

package/dist/config/model-windows.d.ts

@@ -0,0 +1,91 @@
+/**
+ * User-declared context windows, read from `~/.aragon-agent/model-windows.json`
+ * (path owned by `app-paths.ts`).
+ *
+ * WHY THIS FILE EXISTS. `ModelRegistry.getContextWindow` resolves a window from
+ * API discovery, the builtin model lists and the ten-entry catalog - and for
+ * every other id (a gateway alias, a self-hosted model, a release too new for
+ * the table) it returns the explicitly-untrusted 128k `fallback`. The gauge
+ * then renders `?` forever, by design: it refuses to divide by a guessed
+ * denominator. The one number that can make the denominator real is the user's
+ * own, and `config.json`'s `contextWindow` key can only hold ONE of it. This
+ * file is the per-model form of the same assertion.
+ *
+ * THE APPLICATION NEVER WRITES IT. A file the user owns by hand cannot be
+ * clobbered by an upgrade, and its absence is the ordinary case, not an error.
+ *
+ * ASCII ONLY: `src/config/**` is inside the glyph scanner's scope
+ * (`glyphs.test.ts::inScope`).
+ */
+/** Structural bounds only; there is no policy surface to tune here. */
+export interface ModelWindowsLimits {
+    /** Entries beyond this many are dropped, in file order. */
+    readonly maxEntries: number;
+    /** Keys longer than this are dropped rather than trusted as ids. */
+    readonly maxKeyLength: number;
+    /** A window below the smallest real context (1k) is a typo, not a limit. */
+    readonly minWindow: number;
+    /** A window above 1e9 tokens is also a typo; no model ships that today. */
+    readonly maxWindow: number;
+}
+export declare const MODEL_WINDOWS_LIMITS: ModelWindowsLimits;
+/** Normalized model id -> declared window. Keys are stored ALREADY normalized. */
+export type ModelWindowTable = ReadonlyMap<string, number>;
+/**
+ * Same normalization core's `catalogModelId` applies, restated here because it
+ * is not part of Core's public surface and a second exporter would be a
+ * dependency on an internal. Keep the two in step: a date-stamped id
+ * (`kimi-k3-20260716`) and its bare form must resolve to one entry.
+ */
+export declare function normalizeModelKey(modelId: string): string;
+/** What a parse produced, and whether the FILE itself was at fault. */
+export interface ModelWindowsParse {
+    table: ModelWindowTable;
+    /**
+     * True only when the text could not be understood at all (bad JSON, wrong
+     * top-level type). A valid file with zero USABLE entries is `false`: the
+     * user wrote JSON, the values were the problem, and every dead value was
+     * already dropped rather than trusted.
+     */
+    malformed: boolean;
+}
+/**
+ * Parse already-decoded text into a table. NEVER THROWS - a hand-edited file
+ * is the rule here, not the exception, and a typo must cost the user one dead
+ * entry, not the session. Two accepted shapes:
+ *
+ *   { "version": 1, "windows": { "kimi-k3": 1048576 } }
+ *   { "kimi-k3": 1048576 }                        (bare map, same effect)
+ *
+ * The wrapper exists so the format can grow fields without a migration; the
+ * bare map is accepted because the first shape a user types is the simple one.
+ * A leading UTF-8 BOM is tolerated: `readFileSync(..., 'utf8')` does not strip
+ * it, `JSON.parse` cannot parse it, and Notepad writes it by default.
+ */
+export declare function parseModelWindowsResult(text: string): ModelWindowsParse;
+/** The table alone, for callers that do not care why it might be empty. */
+export declare function parseModelWindows(text: string): ModelWindowTable;
+/**
+ * mtime-cached lookup over the file.
+ *
+ * WHY A STAT PER LOOKUP RATHER THAN A LOAD AT STARTUP: `getModelInfoFor` is
+ * called on every measurement, and the meter's `refreshValidity` re-reads the
+ * window precisely so a moved denominator (a `/model` switch, a live config
+ * edit) re-measures without a relaunch. A user saving this file mid-session
+ * gets the same treatment - `statSync` is microseconds, and the read itself
+ * only happens when the stamp actually changes.
+ *
+ * THE STAMP IS mtimeMs+size, so a rewrite that lands in the SAME millisecond
+ * with the SAME byte count serves the previous table once. Squeezing that
+ * window shut would need a content hash per lookup, which is exactly the cost
+ * the stamp exists to avoid; the next differing write clears it regardless.
+ */
+export declare class ModelWindows {
+    private readonly path;
+    private table;
+    private stamp;
+    constructor(path?: string);
+    /** The declared window for `modelId`, or `undefined` when nobody declared one. */
+    lookup(modelId: string): number | undefined;
+    private refresh;
+}

package/dist/config/model-windows.js

@@ -0,0 +1,181 @@
+/**
+ * User-declared context windows, read from `~/.aragon-agent/model-windows.json`
+ * (path owned by `app-paths.ts`).
+ *
+ * WHY THIS FILE EXISTS. `ModelRegistry.getContextWindow` resolves a window from
+ * API discovery, the builtin model lists and the ten-entry catalog - and for
+ * every other id (a gateway alias, a self-hosted model, a release too new for
+ * the table) it returns the explicitly-untrusted 128k `fallback`. The gauge
+ * then renders `?` forever, by design: it refuses to divide by a guessed
+ * denominator. The one number that can make the denominator real is the user's
+ * own, and `config.json`'s `contextWindow` key can only hold ONE of it. This
+ * file is the per-model form of the same assertion.
+ *
+ * THE APPLICATION NEVER WRITES IT. A file the user owns by hand cannot be
+ * clobbered by an upgrade, and its absence is the ordinary case, not an error.
+ *
+ * ASCII ONLY: `src/config/**` is inside the glyph scanner's scope
+ * (`glyphs.test.ts::inScope`).
+ */
+import { readFileSync, statSync } from 'node:fs';
+import { getLogger } from '../logging/logger.js';
+import { getModelWindowsPath } from './app-paths.js';
+export const MODEL_WINDOWS_LIMITS = {
+    maxEntries: 512,
+    maxKeyLength: 200,
+    minWindow: 1_024,
+    maxWindow: 1_000_000_000,
+};
+/**
+ * Same normalization core's `catalogModelId` applies, restated here because it
+ * is not part of Core's public surface and a second exporter would be a
+ * dependency on an internal. Keep the two in step: a date-stamped id
+ * (`kimi-k3-20260716`) and its bare form must resolve to one entry.
+ */
+export function normalizeModelKey(modelId) {
+    return modelId.trim().toLowerCase()
+        .replace(/^(models|openai|anthropic|google)\//, '')
+        .replace(/-(?:\d{4}-\d{2}-\d{2}|\d{8})$/, '');
+}
+function isWindowValue(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) &&
+        value >= MODEL_WINDOWS_LIMITS.minWindow && value <= MODEL_WINDOWS_LIMITS.maxWindow;
+}
+/**
+ * Parse already-decoded text into a table. NEVER THROWS - a hand-edited file
+ * is the rule here, not the exception, and a typo must cost the user one dead
+ * entry, not the session. Two accepted shapes:
+ *
+ *   { "version": 1, "windows": { "kimi-k3": 1048576 } }
+ *   { "kimi-k3": 1048576 }                        (bare map, same effect)
+ *
+ * The wrapper exists so the format can grow fields without a migration; the
+ * bare map is accepted because the first shape a user types is the simple one.
+ * A leading UTF-8 BOM is tolerated: `readFileSync(..., 'utf8')` does not strip
+ * it, `JSON.parse` cannot parse it, and Notepad writes it by default.
+ */
+export function parseModelWindowsResult(text) {
+    const body = text.replace(/^\uFEFF/, '');
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        return { table: new Map(), malformed: true };
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        return { table: new Map(), malformed: true };
+    }
+    const record = parsed;
+    const source = record.windows !== undefined && record.windows !== null &&
+        typeof record.windows === 'object' && !Array.isArray(record.windows)
+        ? record.windows
+        : record;
+    const table = new Map();
+    for (const [rawKey, rawValue] of Object.entries(source)) {
+        const key = normalizeModelKey(rawKey);
+        if (key.length === 0 || key.length > MODEL_WINDOWS_LIMITS.maxKeyLength)
+            continue;
+        if (!isWindowValue(rawValue))
+            continue;
+        table.set(key, rawValue);
+        if (table.size >= MODEL_WINDOWS_LIMITS.maxEntries)
+            break;
+    }
+    return { table, malformed: false };
+}
+/** The table alone, for callers that do not care why it might be empty. */
+export function parseModelWindows(text) {
+    return parseModelWindowsResult(text).table;
+}
+/**
+ * Decode the raw bytes the way a Windows text editor may have saved them.
+ *
+ * `readFileSync(path, 'utf8')` alone fails THREE ways on this machine's most
+ * common editors: a UTF-8 BOM survives into the string and kills `JSON.parse`,
+ * and Notepad's "Unicode" saves are UTF-16LE (or BE), which decode as NUL-laden
+ * mojibake. All three are silent feature-death for exactly the user who just
+ * tried to configure it, so the sniff happens before any parse.
+ */
+function decodeModelWindowsFile(bytes) {
+    if (bytes.length >= 2 && bytes[0] === 0xff && bytes[1] === 0xfe) {
+        return bytes.subarray(2).toString('utf16le');
+    }
+    if (bytes.length >= 2 && bytes[0] === 0xfe && bytes[1] === 0xff) {
+        // Big-endian UTF-16: Node has no utf16be decoder, so swap pairs in place
+        // on a COPY and reuse the little-endian decoder.
+        const swapped = Buffer.from(bytes.subarray(2));
+        for (let i = 0; i + 1 < swapped.length; i += 2) {
+            const high = swapped[i];
+            swapped[i] = swapped[i + 1];
+            swapped[i + 1] = high;
+        }
+        return swapped.toString('utf16le');
+    }
+    if (bytes.length >= 3 && bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf) {
+        return bytes.subarray(3).toString('utf8');
+    }
+    return bytes.toString('utf8');
+}
+/**
+ * mtime-cached lookup over the file.
+ *
+ * WHY A STAT PER LOOKUP RATHER THAN A LOAD AT STARTUP: `getModelInfoFor` is
+ * called on every measurement, and the meter's `refreshValidity` re-reads the
+ * window precisely so a moved denominator (a `/model` switch, a live config
+ * edit) re-measures without a relaunch. A user saving this file mid-session
+ * gets the same treatment - `statSync` is microseconds, and the read itself
+ * only happens when the stamp actually changes.
+ *
+ * THE STAMP IS mtimeMs+size, so a rewrite that lands in the SAME millisecond
+ * with the SAME byte count serves the previous table once. Squeezing that
+ * window shut would need a content hash per lookup, which is exactly the cost
+ * the stamp exists to avoid; the next differing write clears it regardless.
+ */
+export class ModelWindows {
+    path;
+    table = new Map();
+    stamp = null;
+    constructor(path = getModelWindowsPath()) {
+        this.path = path;
+    }
+    /** The declared window for `modelId`, or `undefined` when nobody declared one. */
+    lookup(modelId) {
+        this.refresh();
+        return this.table.get(normalizeModelKey(modelId));
+    }
+    refresh() {
+        let stamp;
+        try {
+            const stats = statSync(this.path);
+            stamp = { mtimeMs: stats.mtimeMs, size: stats.size };
+        }
+        catch (error) {
+            // A deleted file (ENOENT) is a decision: drop the entries. Any OTHER
+            // failure (EACCES, an antivirus lock) is transient, and blanking every
+            // declared window because a scanner held the file open for 50 ms would
+            // swing the gauge to `?` for a reason the user cannot see - keep the
+            // last good table and try again on the next lookup.
+            if (error.code === 'ENOENT') {
+                this.stamp = null;
+                this.table = new Map();
+            }
+            return;
+        }
+        if (stamp.mtimeMs === this.stamp?.mtimeMs && stamp.size === this.stamp.size)
+            return;
+        let bytes;
+        try {
+            bytes = readFileSync(this.path);
+        }
+        catch {
+            return; // Appeared in the stat, gone in the read: try again next lookup.
+        }
+        const result = parseModelWindowsResult(decodeModelWindowsFile(bytes));
+        if (result.malformed) {
+            getLogger().warn('config', 'model-windows.json could not be parsed; ignoring it until it is fixed', { path: this.path });
+        }
+        this.table = result.table;
+        this.stamp = stamp;
+    }
+}

package/dist/config/schema.d.ts

@@ -303,11 +303,25 @@ export interface TeamConfig {
      * failed subagent.
      */
     maxConcurrent: number;
-    /** One child's wall clock before its own abort. */
+    /**
+     * 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
+     * the lead, whose only in-run ceiling is the event-silence idle watchdog
+     * a child already keeps. A wedged child still dies on its OWN watchdog.
+     */
     subagentTimeoutMs: number;
-    /** The whole dispatch's wall clock. Also the `task` tool-timeout override. */
+    /**
+     * The whole dispatch's wall clock, and the `task` tool-timeout override.
+     * `0` (the default) means NO ceiling: the executor override of `0` arms no
+     * timer (see Core `ToolExecutor`), so the fan-out lasts as long as its
+     * slowest child and only an Esc ends it early.
+     */
     dispatchTimeoutMs: number;
-    /** Runaway-loop cap: turns one child may take before it is stopped. */
+    /**
+     * Runaway-loop cap: turns one child may take before it is stopped.
+     * `0` (the default) means NO cap - the same exposure the lead has, and
+     * the deliberate trade of "subagents as capable as the main agent".
+     */
     maxTurnsPerSubagent: number;
 }
 /**
@@ -458,8 +472,6 @@ export interface FastConfig {
     /** Applied to fast-tier children and to the review call. Defaults to `'off'`:
      *  a "fast" model asked to think for 32 768 tokens is not fast (D-13). */
     thinkingLevel: ThinkingLevel;
-    /** Allow `model: "fast"` on `task`. */
-    delegate: boolean;
     /** Run the periodic asynchronous review. */
     review: boolean;
     /** Completed turns between reviews. */
@@ -786,6 +798,14 @@ export interface PersistedConfig {
      * asked for; a kill switch is what a bug report needs.
      */
     paste: boolean;
+    /**
+     * Ask the terminal to report modified keys distinctly so Shift+Enter can
+     * insert a newline (win32-input-mode on Windows, kitty disambiguate +
+     * modifyOtherKeys elsewhere). A KILL SWITCH in the exact sense `paste`
+     * above records: the encoding tables are structural and live in
+     * `input/win32-input-mode.ts` / `input/csiu-keys.ts`.
+     */
+    keyboardEnhancement: boolean;
     /** Idle ms before a paused viewport returns to the newest line; `0` disables. */
     scrollResumeMs: number;
     /** Start every session in PLAN mode (plan-mode §4.4). */
@@ -971,6 +991,15 @@ export interface CliConfig {
      * reach none of them.
      */
     paste: boolean;
+    /**
+     * Whether this session may push the keyboard-enhancement modes.
+     *
+     * IT MUST EXIST HERE AND NOT ONLY IN `PersistedConfig`, for the reason
+     * `paste` above records: `runInteractive` reads it -- where `config`
+     * is a `CliConfig` -- to decide the filter's `enhancedKeys` feature
+     * and the `enableKeyboardEnhancement` push.
+     */
+    keyboardEnhancement: boolean;
     /** Idle ms before a paused viewport returns to the newest line; `0` disables. */
     scrollResumeMs: number;
     /**

package/dist/config/schema.js

@@ -447,15 +447,20 @@ export const DEFAULT_TEAM_CONFIG = {
     enabled: true,
     maxSubagents: 5,
     maxConcurrent: 3,
-    subagentTimeoutMs: 300_000,
-    dispatchTimeoutMs: 900_000,
-    maxTurnsPerSubagent: 24,
+    // 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,
+    dispatchTimeoutMs: 0,
+    maxTurnsPerSubagent: 0,
 };
 const SUBAGENTS_RANGE = { min: 1, max: HARD_MAX_SUBAGENTS };
 const CONCURRENT_RANGE = { min: 1, max: HARD_MAX_SUBAGENTS };
-const SUBAGENT_TIMEOUT_RANGE = { min: 30_000, max: 1_800_000 };
-const DISPATCH_TIMEOUT_RANGE = { min: 60_000, max: 3_600_000 };
-const TURNS_RANGE = { min: 4, max: 100 };
+// `min: 0` is the documented OFF SWITCH for each bound, so these MUST use
+// `clampIntAllowingZero`: plain `clampInt` folds `0` back to the fallback
+// ("my setting won't stick"), the exact trap `scrollResumeMs` records above.
+const SUBAGENT_TIMEOUT_RANGE = { min: 0, max: 1_800_000 };
+const DISPATCH_TIMEOUT_RANGE = { min: 0, max: 3_600_000 };
+const TURNS_RANGE = { min: 0, max: 100 };
 /**
  * THE single gate for every team-config read AND write, mirroring
  * `clampSkillsConfig` / `clampLogConfig` for the reason those two record:
@@ -474,9 +479,9 @@ export function clampTeamConfig(raw) {
         enabled: bool(src.enabled, DEFAULT_TEAM_CONFIG.enabled),
         maxSubagents,
         maxConcurrent: Math.min(maxSubagents, clampInt(src.maxConcurrent, DEFAULT_TEAM_CONFIG.maxConcurrent, CONCURRENT_RANGE)),
-        subagentTimeoutMs: clampInt(src.subagentTimeoutMs, DEFAULT_TEAM_CONFIG.subagentTimeoutMs, SUBAGENT_TIMEOUT_RANGE),
-        dispatchTimeoutMs: clampInt(src.dispatchTimeoutMs, DEFAULT_TEAM_CONFIG.dispatchTimeoutMs, DISPATCH_TIMEOUT_RANGE),
-        maxTurnsPerSubagent: clampInt(src.maxTurnsPerSubagent, DEFAULT_TEAM_CONFIG.maxTurnsPerSubagent, TURNS_RANGE),
+        subagentTimeoutMs: clampIntAllowingZero(src.subagentTimeoutMs, DEFAULT_TEAM_CONFIG.subagentTimeoutMs, SUBAGENT_TIMEOUT_RANGE),
+        dispatchTimeoutMs: clampIntAllowingZero(src.dispatchTimeoutMs, DEFAULT_TEAM_CONFIG.dispatchTimeoutMs, DISPATCH_TIMEOUT_RANGE),
+        maxTurnsPerSubagent: clampIntAllowingZero(src.maxTurnsPerSubagent, DEFAULT_TEAM_CONFIG.maxTurnsPerSubagent, TURNS_RANGE),
     };
 }
 export const DEFAULT_TODO_CONFIG = {
@@ -615,7 +620,6 @@ export const DEFAULT_FAST_CONFIG = {
     model: '',
     baseUrl: '',
     thinkingLevel: 'off',
-    delegate: true,
     review: true,
     reviewEveryTurns: 5,
     reviewContextTurns: 3,
@@ -655,7 +659,6 @@ export function clampFastConfig(raw) {
         model: text(src.model, DEFAULT_FAST_CONFIG.model),
         baseUrl: text(src.baseUrl, DEFAULT_FAST_CONFIG.baseUrl),
         thinkingLevel: clampThinkingLevel(src.thinkingLevel, DEFAULT_FAST_CONFIG.thinkingLevel),
-        delegate: bool(src.delegate, DEFAULT_FAST_CONFIG.delegate),
         review: bool(src.review, DEFAULT_FAST_CONFIG.review),
         reviewEveryTurns: clampInt(src.reviewEveryTurns, DEFAULT_FAST_CONFIG.reviewEveryTurns, REVIEW_EVERY_RANGE),
         reviewContextTurns: clampInt(src.reviewContextTurns, DEFAULT_FAST_CONFIG.reviewContextTurns, REVIEW_CONTEXT_RANGE),
@@ -896,6 +899,7 @@ export const DEFAULT_CONFIG = {
     mouse: true,
     mouseSelect: DEFAULT_MOUSE_SELECT,
     paste: true,
+    keyboardEnhancement: true,
     scrollResumeMs: DEFAULT_SCROLL_RESUME_MS,
     planModeDefault: false,
     planModeMaxAskRounds: DEFAULT_PLAN_MAX_ASK_ROUNDS,

package/dist/exec/events.d.ts

@@ -219,11 +219,11 @@ export interface ExecFastReviewEvent {
  * not know is unaffected.
  *
  * THE PROBLEM IT SOLVES. `fast_review` only fires when a review produced TEXT,
- * so every other outcome — a review that failed, a tier that switched itself off
- * after three failures, a budget that ran out, a delegation that did or did not
- * happen — was invisible to a wrapper. The single most likely and least
- * self-diagnosable failure ("it runs but not one review card ever arrives") had
- * no signal at all on this stream.
+ * so every other outcome — a review that failed, a tier that switched itself
+ * off after three failures, or a budget that ran out — was invisible to a
+ * wrapper. The single most likely and least self-diagnosable failure ("it
+ * runs but not one review card ever arrives") had no signal at all on this
+ * stream.
  *
  * IT IS A STATE EVENT, NOT A LOG LINE. It fires on `tier_changed` and on every
  * `review_end`, which in a session with reviews is a handful per hundred turns.
@@ -249,7 +249,11 @@ export interface ExecFastTierEvent {
     reviews: number;
     reviewBudget: number;
     budgetReached: boolean;
-    /** Fast-tier children dispatched — the only evidence delegation is working. */
+    /**
+     * DEPRECATED, ALWAYS `0`. Fast-tier children no longer exist (every `task`
+     * child runs the lead's model); the field is kept so schema-v1 consumers
+     * keep parsing. Do not build new readers on it.
+     */
     delegated: number;
     inFlight: boolean;
     /** Present only on the `review_end` branch. */
@@ -399,8 +403,8 @@ export interface ExecInitParams {
  *
  *  · `'interrupt'`         — `{"type":"interrupt"}` on stdin settles the turn
  *                            without killing the process.
- *  · `'fast-policy'`       — this build understands `--fast-delegate` and
- *                            `--fast-review`. FOR AFTER-THE-FACT DISPLAY ONLY:
+ *  · `'fast-policy'`       — this build understands `--fast-review`.
+ *                            FOR AFTER-THE-FACT DISPLAY ONLY:
  *                            argv is fixed before `system/init` arrives, so it
  *                            cannot gate whether the flags are passed.
  *  · `'fast-tier-events'`  — this build emits `fast_tier`. Its ABSENCE is what

package/dist/exec/events.js

@@ -34,8 +34,8 @@ export const EXEC_SCHEMA_VERSION = 1;
  *
  *  · `'interrupt'`         — `{"type":"interrupt"}` on stdin settles the turn
  *                            without killing the process.
- *  · `'fast-policy'`       — this build understands `--fast-delegate` and
- *                            `--fast-review`. FOR AFTER-THE-FACT DISPLAY ONLY:
+ *  · `'fast-policy'`       — this build understands `--fast-review`.
+ *                            FOR AFTER-THE-FACT DISPLAY ONLY:
  *                            argv is fixed before `system/init` arrives, so it
  *                            cannot gate whether the flags are passed.
  *  · `'fast-tier-events'`  — this build emits `fast_tier`. Its ABSENCE is what

package/dist/exec/runner.js

@@ -153,7 +153,10 @@ export class ExecRunner {
                 reviews: snapshot.reviews,
                 reviewBudget: snapshot.reviewBudget,
                 budgetReached: snapshot.budgetReached,
-                delegated: snapshot.delegated,
+                // Deprecated in schema v1: always 0 since fast-tier children were
+                // removed (every task child runs the lead's model). Emitted so
+                // schema-v1 consumers keep parsing.
+                delegated: 0,
                 inFlight: snapshot.inFlight,
                 ...(event.type === 'review_end'
                     ? {

package/dist/fast/limits.d.ts

@@ -76,7 +76,7 @@ export declare const FAST_LIMITS: {
      * A critique waiting for its injection window goes stale (RV-12).
      *
      * The window is not guaranteed to be prompt: one `task` dispatch is a single
-     * tool call that can run for `team.dispatchTimeoutMs`, so a critique triggered
+     * tool call that can run for as long as its children need, so a critique triggered
      * just before one arrives at the far side describing a state five children
      * have since rewritten. Advice that is merely late is worse than no advice,
      * because the lead cannot tell that it is late.
@@ -95,4 +95,4 @@ export declare const FAST_LIMITS: {
  * changes, so a behaviour report can be tied to a block revision with one grep -
  * exactly what `TEAM_BLOCK_VERSION` and `TODO_BLOCK_VERSION` are for.
  */
-export declare const FAST_BLOCK_VERSION = "v1-2026-07";
+export declare const FAST_BLOCK_VERSION = "v2-2026-10";

package/dist/fast/limits.js

@@ -76,7 +76,7 @@ export const FAST_LIMITS = {
      * A critique waiting for its injection window goes stale (RV-12).
      *
      * The window is not guaranteed to be prompt: one `task` dispatch is a single
-     * tool call that can run for `team.dispatchTimeoutMs`, so a critique triggered
+     * tool call that can run for as long as its children need, so a critique triggered
      * just before one arrives at the far side describing a state five children
      * have since rewritten. Advice that is merely late is worse than no advice,
      * because the lead cannot tell that it is late.
@@ -95,4 +95,4 @@ export const FAST_LIMITS = {
  * changes, so a behaviour report can be tied to a block revision with one grep -
  * exactly what `TEAM_BLOCK_VERSION` and `TODO_BLOCK_VERSION` are for.
  */
-export const FAST_BLOCK_VERSION = 'v1-2026-07';
+export const FAST_BLOCK_VERSION = 'v2-2026-10';

package/dist/fast/prompt.d.ts

@@ -19,23 +19,22 @@ export interface FastBlockParams {
     /** The resolved fast model id, interpolated so the prompt never names a model
      *  the tier will not actually use (§3.9 / RV-3). */
     model: string;
-    /** `fast.delegate` — whether `model: "fast"` is honoured on `task`. */
-    delegate: boolean;
     /** `fast.review` — whether `<fast_review>` blocks can appear at all. */
     review: boolean;
 }
 /**
- * The lead's `<fast_tier>` block. Under 1100 characters on purpose: it is paid
- * for on EVERY turn of every fast-enabled session, so anything that does not
- * change a delegation decision does not belong in it (R-11).
+ * The `<fast_tier>` block, spliced for the lead AND for task children running
+ * under a per-child reviewer. Under 1100 characters on purpose: it is paid for
+ * on EVERY turn of every fast-enabled session, so anything that does not change
+ * a decision does not belong in it (R-11).
  *
- * EACH PARAGRAPH IS PRESENT ONLY WHEN ITS CAPABILITY IS. `fast.delegate: false,
- * fast.review: true` advertises only the review, because telling a model about a
- * `model: "fast"` field that the normalizer will downgrade every time is how you
- * get a model that keeps asking for something it can never have.
+ * REVIEW-ONLY SIN MAIN-AGENT PARITY: every `task` child runs the lead's own
+ * model, so the block no longer advertises a per-child `model:"fast"`. Telling
+ * a model about a field that no longer exists is how you get a model that keeps
+ * asking for something it can never have.
  *
- * Returns `''` when neither capability is live, which the splice treats as "no
- * block" and which keeps the byte-identity branch intact.
+ * Returns `''` when the review is off, which the splice treats as "no block"
+ * and which keeps the byte-identity branch intact.
  */
 export declare function buildFastBlock(params: FastBlockParams): string;
 export interface ReviewSystemPromptParams {