@aragon-agent/cli 0.6.22 → 0.6.23

package/dist/agent/controller.js

@@ -634,7 +634,15 @@ export class AgentController {
                     // `dispatchTimeoutMs: 0` (the default) reaches the executor as an
                     // override of `0` = NO TIMER AT ALL: the dispatch lasts as long as its
                     // slowest child, and only an Esc ends it early (main-agent parity).
-                    ...(this.teamRegistered ? { task: config.team.dispatchTimeoutMs } : {}),
+                    // D-4, THE SECOND ARMING SITE: the runtime arms its own dispatch
+                    // timer under the same gate, because the executor timeout being
+                    // cooperative means this override must never be the ONLY ceiling.
+                    // With the supervisor gate open the ceiling disarms HERE too, so
+                    // team.overseer can never leave two kill paths alive behind one
+                    // config. Read once at construction, exactly as before.
+                    ...(this.teamRegistered
+                        ? { task: config.team.overseer ? 0 : config.team.dispatchTimeoutMs }
+                        : {}),
                 },
             },
         });

package/dist/agent/reducer.js

@@ -183,18 +183,20 @@ export function reduceEvent(event, cost, patches) {
 }
 /**
  * Tools that render their own transcript entry, so the generic tool card would
- * be a duplicate. EXACTLY ONE MEMBER; read todo-plan-execution §3.8 before
- * adding a second.
+ * be a duplicate. `task` is the second member (F-8 A'3): every dispatch opens
+ * a TeamCard immediately after, so the pair read as TWO dispatches - the first
+ * failed, the second succeeded - when there was only ever one. `todo_write`'s
+ * reasons (todo-plan-execution §3.8 / D-10) carry over unchanged.
  *
  * SUPPRESSING ONLY `tool_call_start` IS SUFFICIENT, AND THAT IS THE WHOLE REASON
  * THIS IS SAFE (D-10). Every later handler — `toolCallDelta` / `toolCallEnd` /
  * `toolExecStart` / `toolExecEnd` — resolves its target through
  * `findToolEntryId`, which returns `undefined` when no entry was created, and
- * every one of them already early-returns on that. There is no fifth handler. A
- * second suppression rule would be four more places to get the id matching
- * wrong, for nothing.
+ * every one of them already early-returns on that. There is no fifth handler.
+ * Blast radius verified: headless and `exec` writers key on EVENTS, not tool
+ * names, and `transcript-text` renders `kind:'team'` on its own.
  */
-const SELF_RENDERING_TOOLS = new Set(['todo_write']);
+const SELF_RENDERING_TOOLS = new Set(['todo_write', 'task']);
 function reduceStreamEvent(se) {
     switch (se.type) {
         case 'thinking_start':

package/dist/config/load.js

@@ -6,10 +6,10 @@
  * legitimately long single tool run can never be watchdog-killed.
  */
 import process from 'node:process';
-import { DEFAULT_CONFIG, IDLE_TIMEOUT_MARGIN_MS, clampAskRounds, clampDensity, clampHumanTimeout, clampCompactionConfig, clampLogConfig, clampFastConfig, clampRetryConfig, clampSkillsConfig, clampTeamConfig, clampTodoConfig, clampBashConfig, clampUpdateConfig, clampTheme, clampThinkingLevel, clampContextWindow, clampMaxTokens, clampMaxRenderInterval, clampScrollResumeMs, clampTranscriptRetain, clampTranscriptWindow, coercePositiveInt, isAutoToken, isSkillsToolPolicyMode, parseThresholdInput, } from './schema.js';
+import { DEFAULT_CONFIG, IDLE_TIMEOUT_MARGIN_MS, clampAskRounds, clampDensity, clampHumanTimeout, clampCompactionConfig, clampLogConfig, clampFastConfig, clampRetryConfig, clampSkillsConfig, clampTeamConfig, clampTodoConfig, clampBashConfig, clampUpdateConfig, clampTheme, clampThinkingLevel, clampContextWindow, clampMaxTokens, clampMaxRenderInterval, clampScrollResumeMs, clampTranscriptRetain, clampTranscriptWindow, coercePositiveInt, isAutoToken, isSkillsToolPolicyMode, legacyTeamCeilingPatch, parseThresholdInput, } from './schema.js';
 import { loadDotenv, readEnvConfig, readEnvDisabledSkills } from './env.js';
-import { readConfigFile } from './store.js';
-import { projectModelProfiles, resolveModelProfileState, resolveModelRoleKey } from './model-profile-resolution.js';
+import { readConfigFile, updatePersistedConfig } from './store.js';
+import { projectModelProfiles, resolveModelProfileState, resolveModelRoleKey, } from './model-profile-resolution.js';
 import { getConfigPath } from './app-paths.js';
 import { setHistoryEnabled } from './prompt-history.js';
 import { setEntryRetain } from '../agent/entry-limits.js';
@@ -439,6 +439,44 @@ function resolveContextWindow(env, file) {
     }
     return DEFAULT_CONFIG.contextWindow;
 }
+/**
+ * Rewrite the cli<=0.6.16 persisted team ceiling defaults to 0 and persist the
+ * change (F-8 A'4). ONE-SHOT and IDEMPOTENT: after the first rewrite the file
+ * carries 0, which matches nothing, so nothing is written again.
+ *
+ * THE FILE LAYER ONLY, deliberately: env and flags are this-launch intent and
+ * survive untouched, and with the D-4 semantics a positive surviving value is
+ * a supervisor cadence hint, never a kill. The raw file object is patched IN
+ * PLACE (the same precedent `readConfigFile` sets with `fullscreen`) so the
+ * `file` layer this function's caller resolves from already reads 0; the
+ * write goes through `updatePersistedConfig`, the one atomic write path every
+ * other settings change uses.
+ *
+ * A FAILED WRITE MUST NOT BLOCK STARTUP: the values are already neutralized
+ * in memory, and the next launch retries — which is why the catch is empty
+ * and the migration is logged instead of surfaced.
+ */
+function migrateLegacyTeamCeilings(raw) {
+    const patch = legacyTeamCeilingPatch(raw?.team);
+    if (patch === null)
+        return;
+    // THE FULL SECTION, not the bare patch: the write port types `team` as a
+    // whole `TeamConfig` (its merge then deep-merges over what is on disk), and
+    // the section the file already carries plus the zeroed keys IS the section
+    // we want on disk.
+    const migratedTeam = { ...raw.team, ...patch };
+    Object.assign(raw.team, patch);
+    try {
+        updatePersistedConfig({ team: migratedTeam });
+    }
+    catch {
+        // Unwritable config dir: in-memory values are already migrated; retry
+        // next launch (idempotent).
+    }
+    getLogger().warn('config', 'team_legacy_ceilings_migrated', {
+        keys: Object.keys(patch).join(','),
+    });
+}
 /**
  * Resolve the effective config by merging all layers, then derive the runtime
  * (non-persisted) fields and enforce the timeout invariant.
@@ -448,6 +486,7 @@ export function loadConfig(flags = {}, options = {}) {
     // `.env` must be loaded before reading env overrides.
     loadDotenv(cwd);
     const read = readConfigFile();
+    migrateLegacyTeamCeilings(read.config);
     const projection = projectModelProfiles(read.config ?? {});
     const file = projection.file;
     const env = readEnvConfig();

package/dist/config/schema.d.ts

@@ -380,6 +380,31 @@ export declare const DEFAULT_TEAM_CONFIG: TeamConfig;
  * the two disagree would make the panel's `n/m` readout confusing for no gain.
  */
 export declare function clampTeamConfig(raw: unknown): TeamConfig;
+/**
+ * The team ceilings cli <= 0.6.16 (7a6bf5630) persisted as its OWN defaults:
+ * every user who touched team mode back then still carries this exact triple
+ * in config.json, because `resolveTeamConfig` merges file values verbatim and
+ * no migration ever rewrote them. They are the kill ceilings behind F-8's
+ * "first block all failed" dispatches, so loading rewrites them to 0 (= no
+ * ceiling, the shipped default since 2ff15a9c3).
+ *
+ * EXACT-EQUALITY ONLY: a value that differs was a deliberate user choice and
+ * survives untouched. The price of that test is that a user who hand-types
+ * 300000 today is migrated to 0 too - the accepted trade, and the safe
+ * direction (no ceiling, not a cliff).
+ */
+export declare const LEGACY_TEAM_CEILING_DEFAULTS: Readonly<{
+    subagentTimeoutMs: number;
+    dispatchTimeoutMs: number;
+    maxTurnsPerSubagent: number;
+}>;
+/**
+ * The `{ key: 0 }` patch for legacy-default-equal ceilings, or `null` when
+ * nothing matches. 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 legacyTeamCeilingPatch(raw: unknown): Partial<TeamConfig> | null;
 export interface TodoConfig {
     /** Register `todo_write` at all. Default TRUE. */
     enabled: boolean;

package/dist/config/schema.js

@@ -492,6 +492,44 @@ export function clampTeamConfig(raw) {
         overseerIntervalMs: clampIntAllowingZero(src.overseerIntervalMs, DEFAULT_TEAM_CONFIG.overseerIntervalMs, OVERSEER_INTERVAL_RANGE),
     };
 }
+/**
+ * The team ceilings cli <= 0.6.16 (7a6bf5630) persisted as its OWN defaults:
+ * every user who touched team mode back then still carries this exact triple
+ * in config.json, because `resolveTeamConfig` merges file values verbatim and
+ * no migration ever rewrote them. They are the kill ceilings behind F-8's
+ * "first block all failed" dispatches, so loading rewrites them to 0 (= no
+ * ceiling, the shipped default since 2ff15a9c3).
+ *
+ * EXACT-EQUALITY ONLY: a value that differs was a deliberate user choice and
+ * survives untouched. The price of that test is that a user who hand-types
+ * 300000 today is migrated to 0 too - the accepted trade, and the safe
+ * direction (no ceiling, not a cliff).
+ */
+export const LEGACY_TEAM_CEILING_DEFAULTS = {
+    subagentTimeoutMs: 300_000,
+    dispatchTimeoutMs: 900_000,
+    maxTurnsPerSubagent: 24,
+};
+/**
+ * The `{ key: 0 }` patch for legacy-default-equal ceilings, or `null` when
+ * nothing matches. 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 legacyTeamCeilingPatch(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const src = raw;
+    const patch = {};
+    let matched = false;
+    for (const key of Object.keys(LEGACY_TEAM_CEILING_DEFAULTS)) {
+        if (src[key] === LEGACY_TEAM_CEILING_DEFAULTS[key]) {
+            patch[key] = 0;
+            matched = true;
+        }
+    }
+    return matched ? patch : null;
+}
 export const DEFAULT_TODO_CONFIG = {
     enabled: true,
     panel: true,

package/dist/team/overseer.d.ts

@@ -49,8 +49,10 @@ import type { OverseerAction, OverseerDecision, SubagentRun, SubagentSpec } from
  * Bumped whenever either supervisor protocol prompt changes (D-9), so a
  * behaviour report can be tied to a prompt revision with one grep.
  * `TEAM_BLOCK_VERSION` covers only the LEAD's `<team>` block, not these.
+ *
+ * v3 adds the turn-cap trigger to the single-inspection prompt (F-8 A'2).
  */
-export declare const OVERSEER_PROMPT_VERSION = "v2-2026-10";
+export declare const OVERSEER_PROMPT_VERSION = "v3-2026-10";
 /** One remembered decision, so the second look knows the first happened. */
 export interface OverseerMemoryEntry {
     /** Seconds into the dispatch. */
@@ -63,7 +65,7 @@ export interface ChildDigestInput {
     run: SubagentRun;
     /** False only in the post-mortem inspection, after the child settled. */
     childAlive: boolean;
-    trigger: 'silence' | 'clock' | 'postmortem';
+    trigger: 'silence' | 'clock' | 'turncap' | 'postmortem';
     /** The child's LIVE history (`SubagentAgentLike.state.messages`). */
     messages: readonly Message[];
     memory: readonly OverseerMemoryEntry[];
@@ -203,7 +205,7 @@ export declare function createFastOverseerProvider(deps: FastOverseerDeps): Over
 export interface OverseerInspectRequest {
     run: SubagentRun;
     messages: readonly Message[];
-    trigger: 'silence' | 'clock' | 'postmortem';
+    trigger: 'silence' | 'clock' | 'turncap' | 'postmortem';
     childAlive: boolean;
 }
 export interface TeamOverseerOptions {

package/dist/team/overseer.js

@@ -50,8 +50,10 @@ import { TEAM_LIMITS } from './limits.js';
  * Bumped whenever either supervisor protocol prompt changes (D-9), so a
  * behaviour report can be tied to a prompt revision with one grep.
  * `TEAM_BLOCK_VERSION` covers only the LEAD's `<team>` block, not these.
+ *
+ * v3 adds the turn-cap trigger to the single-inspection prompt (F-8 A'2).
  */
-export const OVERSEER_PROMPT_VERSION = 'v2-2026-10';
+export const OVERSEER_PROMPT_VERSION = 'v3-2026-10';
 /** How many trailing history messages the digest carries. */
 const DIGEST_TAIL_MESSAGES = 8;
 /** Per-message text clamp inside the digest. */
@@ -78,6 +80,13 @@ function messageText(message) {
 function clampChars(text, max) {
     return text.length <= max ? text : `${text.slice(0, Math.max(0, max - 3))}...`;
 }
+/** One line per trigger, as the digest names it (a union VALUE, never prose). */
+const TRIGGER_LABELS = {
+    silence: 'event silence (suspected stall)',
+    clock: 'wall-clock check',
+    turncap: 'turn cap reached (inspection trigger, not a stop)',
+    postmortem: 'post-mortem (child already ended)',
+};
 /**
  * Build the bounded text one inspection reads.
  *
@@ -91,7 +100,7 @@ export function buildChildDigest(input) {
     const { run, childAlive, trigger, messages, memory, elapsedSec } = input;
     const lines = [];
     lines.push(`child: ${run.label} "${run.description}"`);
-    lines.push(`trigger: ${trigger === 'silence' ? 'event silence (suspected stall)' : trigger === 'clock' ? 'wall-clock check' : 'post-mortem (child already ended)'}`);
+    lines.push(`trigger: ${TRIGGER_LABELS[trigger]}`);
     lines.push(`elapsed: ${Math.round(elapsedSec)}s, alive: ${childAlive ? 'yes' : 'no'}`);
     lines.push(`phase: ${run.phase}, turns: ${run.turns}, toolCalls: ${run.toolCalls}` +
         (run.lastTool ? `, lastTool: ${run.lastTool}` : ''));
@@ -270,8 +279,10 @@ export function parseOverseerBatchText(text) {
 }
 const OVERSEER_SYSTEM_PROMPT = [
     'You are the supervisor of a team of subagents. You are shown ONE subagent',
-    'that crossed a time trigger (event silence or a wall-clock check) and must',
-    'decide what to do with it. Answer with ONE JSON object and nothing else:',
+    'that crossed a supervision trigger (event silence, a wall-clock check, or',
+    'the configured turn cap) and must decide what to do with it. Crossing a',
+    'ceiling does NOT stop the child - your decision does. Answer with ONE JSON',
+    'object and nothing else:',
     '{"action": "wait" | "nudge" | "replace" | "abandon", "reason": "<= 200 chars",',
     ' "guidance": "<= 1200 chars, nudge only", "nextCheckMs": <ms, wait only>}.',
     'wait: the child looks healthy or is legitimately blocked (API backoff,',

package/dist/team/runtime.js

@@ -488,6 +488,18 @@ export class TeamRuntime {
             // ONE KICK PER REAL AGENT EVENT, unthrottled (I-OV3): the silence
             // window resets on evidence, not on a coalesced UI frame.
             onActivity: () => this.supervision?.kick(spec.label),
+            // A'2: under supervision the turn cap is ONE inspection, fired from the
+            // child's own `turn_end` at the crossing turn. Async-and-forgotten
+            // exactly like the silence timer's `onFire`: nothing in the child's
+            // event path may block or throw. ABSENT in the legacy regime, which
+            // keeps the hard stop - the hook's presence IS the gate.
+            ...(this.overseer !== null
+                ? {
+                    onTurnCapReached: (label) => {
+                        void this.inspectAndApply(dispatchId, label, 'turncap');
+                    },
+                }
+                : {}),
         });
         // ASSIGNMENT, not a declaration: a `const` here would shadow the `let` above
         // the bus, `canSend` would see the empty array forever, and every peer would
@@ -520,10 +532,15 @@ export class TeamRuntime {
         // its slowest child and only an Esc ends it early. The lead's idle
         // watchdog is paused for the whole dispatch either way, exactly as it is
         // for the lead's own long turns.
+        //
+        // D-4, NOW FOR THE WHOLE DISPATCH TOO: with the supervisor gate open the
+        // ceiling NEVER arms a hard abort - the cadence ladder is what looks at a
+        // long dispatch, exactly as it already looks at a long child. The legacy
+        // hard `abortAll()` exists ONLY under `team.overseer: false`, the same
+        // regime line `runCtx.subagentTimeoutMs` below draws.
+        const dispatchCeilingMs = team.overseer ? 0 : team.dispatchTimeoutMs;
         this.dispatchTimer =
-            team.dispatchTimeoutMs > 0
-                ? setTimeout(() => this.abortAll(), team.dispatchTimeoutMs)
-                : null;
+            dispatchCeilingMs > 0 ? setTimeout(() => this.abortAll(), dispatchCeilingMs) : null;
         const runCtx = {
             dispatchId,
             handles,

package/dist/team/subagent.d.ts

@@ -135,6 +135,16 @@ export interface SubagentHooks {
      * so the phase read at fire time is current.
      */
     onActivity?: () => void;
+    /**
+     * THE TURN CAP AS AN INSPECTION TRIGGER (F-8 A'2). Called ONCE, at the turn
+     * that crossed `maxTurnsPerSubagent`, ONLY when the dispatch supervisor is
+     * live - the runtime wires this hook under the same gate as
+     * `overseerActive`, so its presence IS the supervised/legacy branch. The
+     * child is NOT stopped: the supervisor decides wait / nudge / replace /
+     * abandon through the same `inspectAndApply` path every other trigger
+     * uses, and a child it lets run carries no `truncated` flag.
+     */
+    onTurnCapReached?: (label: string) => void;
 }
 export interface SubagentHandle {
     spec: SubagentSpec;

package/dist/team/subagent.js

@@ -359,12 +359,26 @@ export function createSubagent(spec, deps, hooks) {
                 // not runaway - it is working.
                 const turnCap = deps.config.team.maxTurnsPerSubagent;
                 if (turnCap > 0 && run.turns >= turnCap) {
-                    run.truncated = true;
-                    // THE FLAG FIRST, exactly like `handle.abort()`: the child's
-                    // reviewer reads `abortRequested` as its guard-1 fact, and a
-                    // turn-cap stop must be visible to it in the same tick.
-                    abortRequested = true;
-                    agent.abort();
+                    if (hooks.onTurnCapReached !== undefined) {
+                        // A'2, D-4 for the turn cap: SUPERVISED means the ceiling is
+                        // an inspection trigger, not a death sentence. ONE look at the
+                        // crossing turn (`===`), never a per-turn storm; the child
+                        // keeps working unless the supervisor decides replace or
+                        // abandon, and a child that keeps running carries NO
+                        // `truncated` flag - the report must not call it partial.
+                        if (run.turns === turnCap)
+                            hooks.onTurnCapReached(spec.label);
+                    }
+                    else {
+                        // LEGACY regime (no supervisor for this dispatch): the hard
+                        // stop, byte for byte what it always was.
+                        run.truncated = true;
+                        // THE FLAG FIRST, exactly like `handle.abort()`: the child's
+                        // reviewer reads `abortRequested` as its guard-1 fact, and a
+                        // turn-cap stop must be visible to it in the same tick.
+                        abortRequested = true;
+                        agent.abort();
+                    }
                 }
                 break;
             }

package/dist/team/types.d.ts

@@ -201,13 +201,14 @@ export interface OverseerIntervention {
     action: OverseerAction;
     reason: string;
     /**
-     * What the trigger was: event stall, wall-clock check, post-mortem, or
-     * the supervisor going QUIET (subagent-overseer-v2 D-10) - the look
+     * What the trigger was: event stall, wall-clock check, the child's turn
+     * cap (F-8 A'2 - an inspection the supervisor then ruled on), post-mortem,
+     * or the supervisor going QUIET (subagent-overseer-v2 D-10) - the look
      * budget ran out and supervision stopped waking this child. A VALUE OF
      * THE UNION, never a reason prefix: a human-readable sentence is not a
      * machine contract (the `run.error` rule).
      */
-    trigger: 'silence' | 'clock' | 'postmortem' | 'quiet';
+    trigger: 'silence' | 'clock' | 'turncap' | 'postmortem' | 'quiet';
 }
 /**
  * A terminal supervisor decision handed to the WORKER LOOP, which is the only

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aragon-agent/cli",
-  "version": "0.6.22",
+  "version": "0.6.23",
   "description": "AragonAgent CLI — a Claude-Code / Codex-style interactive terminal UI (TUI) on top of the @aragon-agent/core engine. Installable and runnable via npm / npx.",
   "license": "MIT",
   "author": "AragonAgent contributors",
@@ -56,7 +56,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@aragon-agent/core": "^0.2.34",
+    "@aragon-agent/core": "^0.2.35",
     "chalk": "^5.6.2",
     "cli-highlight": "^2.0.0",
     "commander": "^12.1.0",