@aragon-agent/cli 0.6.42 → 0.6.43

package/dist/agent/controller.js

@@ -900,18 +900,15 @@ export class AgentController {
                     // executor's timeout is cooperative, so an override is inert for any
                     // tool that does not listen (I-2).
                     //
-                    // `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).
-                    // 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 }
-                        : {}),
+                    // ALWAYS `0` = NO EXECUTOR TIMER, and the override itself must stay:
+                    // deleting it would drop `task` back onto the executor's default tool
+                    // timeout and kill every long fan-out at that default. The dispatch
+                    // ceiling lives in ONE place, `TeamRuntime.dispatch()`, which re-reads
+                    // `team.overseer` / `team.dispatchTimeoutMs` on every dispatch. The
+                    // executor's table is frozen at construction, so a ceiling armed here
+                    // outlived a mid-session `Settings > Team` switch to the supervisor
+                    // and killed the dispatch the supervisor was meant to look after.
+                    ...(this.teamRegistered ? { task: 0 } : {}),
                 },
             },
         });

package/dist/agent/headless.js

@@ -6,6 +6,7 @@
  */
 import { formatCost, formatTokens, formatDuration, computeCost } from './usage.js';
 import { formatStreamError } from './reducer.js';
+import { runDurationMs } from '../team/report.js';
 import { derivePlanPhase } from '../todo/acceptance.js';
 import { advanceBudget, decideFollowThrough, emptyBudget, } from '../todo/follow-through.js';
 /** Run a single prompt headlessly and resolve with the process exit code. */
@@ -99,19 +100,22 @@ export async function runHeadless(controller, prompt, options = {}) {
         if (quiet)
             return;
         if (event.type === 'dispatch_start') {
+            // Labels default to a1, a2... on every dispatch, so "once only" is per dispatch.
+            started.clear();
+            finished.clear();
             err.write(`\n[team] dispatch ${event.specs.length} subagents\n`);
             return;
         }
         if (event.type === 'agent_update') {
             const { run } = event;
-            if (run.phase !== 'queued' && !started.has(run.label)) {
+            if (run.startedAt !== undefined && !started.has(run.label)) {
                 started.add(run.label);
                 err.write(`[team] ${run.label} start "${run.description}"\n`);
             }
             const terminal = run.phase === 'done' || run.phase === 'failed' || run.phase === 'aborted';
             if (terminal && !finished.has(run.label)) {
                 finished.add(run.label);
-                const ms = Math.max(0, (run.endedAt ?? 0) - (run.startedAt ?? 0));
+                const ms = runDurationMs(run);
                 const verdict = run.phase === 'done' && !run.error ? 'ok' : run.phase;
                 err.write(`[team] ${run.label} ${verdict} ${formatDuration(ms)} ${run.toolCalls} tools\n`);
             }

package/dist/exec/runner.js

@@ -15,6 +15,7 @@
  * same `--session-id` must not race the writer of the file it is about to read.
  */
 import { formatStreamError } from '../agent/reducer.js';
+import { runDurationMs } from '../team/report.js';
 import { setSignalTerminator } from '../logging/install.js';
 import { advanceBudget, decideFollowThrough, emptyBudget, } from '../todo/follow-through.js';
 import { EXEC_SCHEMA_VERSION, buildRequestEndEvent } from './events.js';
@@ -1622,7 +1623,7 @@ export class ExecRunner {
                 label: run.label,
                 phase: run.phase,
                 description: run.description,
-                durationMs: Math.max(0, (run.endedAt ?? 0) - (run.startedAt ?? 0)),
+                durationMs: runDurationMs(run),
                 toolCalls: run.toolCalls,
             });
             return;

package/dist/team/bus.d.ts

@@ -36,6 +36,10 @@ export type SendVerdict = {
     ok: false;
     reason: 'unknown_recipient';
     recipients: string[];
+} | {
+    ok: false;
+    reason: 'recipient_finished';
+    who: string[];
 } | {
     ok: false;
     reason: 'agent_quota';

package/dist/team/bus.js

@@ -103,10 +103,20 @@ export class TeamBus {
     send(from, to, subjectRaw, bodyRaw) {
         const target = to.trim().toLowerCase();
         const cost = target === ALL_KEY ? TEAM_LIMITS.broadcastCost : 1;
-        const recipients = this.resolveRecipients(from, target);
-        if (recipients.length === 0) {
+        const addressed = this.resolveRecipients(from, target);
+        if (addressed.length === 0) {
             return { ok: false, reason: 'unknown_recipient', recipients: this.participants() };
         }
+        // A finished peer has no loop left to drain its mailbox, so "Delivered" would be
+        // a false receipt and the quota spent on it a pure loss. Same fact `checkWaitable`
+        // already honours. The lead is always addressable: its mail is collected for the
+        // report, not read by a loop. Refused like every other refusal: nothing is spent
+        // and `lastSentAt` does not move. A peer that is about to finish but has not yet is
+        // still delivered to; that window cannot be closed without a lock.
+        const recipients = addressed.filter((r) => r === LEAD_KEY || this.canSend(r));
+        if (recipients.length === 0) {
+            return { ok: false, reason: 'recipient_finished', who: addressed };
+        }
         const used = this.sentCount(from);
         if (used + cost > TEAM_LIMITS.messagesPerAgent) {
             return { ok: false, reason: 'agent_quota', used, max: TEAM_LIMITS.messagesPerAgent };

package/dist/team/comm-tools.js

@@ -64,6 +64,9 @@ export function makeTeamSend(bus, selfKey) {
                 case 'unknown_recipient':
                     return textResult(`Not sent: no subagent labelled "${to.trim()}". Teammates: ` +
                         `${verdict.recipients.filter((r) => r !== selfKey).join(', ')}.`);
+                case 'recipient_finished':
+                    return textResult(`Not sent: ${verdict.who.join(', ')} already finished and will not read it. ` +
+                        'Put what matters in your own final summary instead.');
                 case 'agent_quota':
                     return textResult(`Not sent: message quota spent (${verdict.used}/${verdict.max}). Finish your work ` +
                         'and put it in your final summary.');

package/dist/team/limits.d.ts

@@ -265,7 +265,7 @@ export declare const TEAM_SUBAGENT_TOOL_NAMES: ReadonlySet<string>;
  * Bumped whenever the wording of either prompt block changes, so a behaviour
  * report can be tied to a block revision with one grep.
  */
-export declare const TEAM_BLOCK_VERSION = "v2-2026-10";
+export declare const TEAM_BLOCK_VERSION = "v3-2026-10";
 /**
  * The version string on `<forced_team_mode>`'s first line.
  *

package/dist/team/limits.js

@@ -279,7 +279,7 @@ export const TEAM_SUBAGENT_TOOL_NAMES = new Set(['team_send', 'team_wait']);
  * Bumped whenever the wording of either prompt block changes, so a behaviour
  * report can be tied to a block revision with one grep.
  */
-export const TEAM_BLOCK_VERSION = 'v2-2026-10';
+export const TEAM_BLOCK_VERSION = 'v3-2026-10';
 // ---------------------------------------------------------------------------
 // Forced team mode (`/team <brief>`, team-command-forced-dispatch §6.5).
 //

package/dist/team/model.d.ts

@@ -23,7 +23,7 @@
  * went stale. The reason is disclosed, never swallowed: the report header and
  * the settings summary line both render it.
  */
-import type { ModelRef, ThinkingLevel } from '@aragon-agent/core';
+import type { ModelCost, ModelRef, ThinkingLevel, TokenUsage } from '@aragon-agent/core';
 import type { ModelProfile, ModelRole } from '../config/model-profiles.js';
 import type { CliConfig } from '../config/schema.js';
 /** Which model children run on. `main` is the default and the historical behavior. */
@@ -53,6 +53,22 @@ export interface SubagentModelResolution {
     /** Present only when `effective !== mode`. */
     fallbackReason?: SubagentFallbackReason;
 }
+/** What `priceTeamUsage` needs from the controller: the lead's table and the lookup. */
+export interface TeamPriceBook {
+    /** The lead's own price table (`main` mode prices at exactly this). */
+    mainCost: ModelCost | undefined;
+    isPriced: (ref: ModelRef) => boolean;
+    costFor: (ref: ModelRef) => ModelCost | undefined;
+}
+/**
+ * USD for one child `usage` event, at the model the children ACTUALLY ran.
+ *
+ * The status bar and the dispatch report must agree, so both price through the same
+ * resolution: under the default `main` mode this is the lead's table (byte parity),
+ * otherwise the fast / profile model's. A model no table prices contributes ZERO rather
+ * than a fabricated figure (C-11 / RV-4), where the report says `pricing unknown`.
+ */
+export declare function priceTeamUsage(resolution: SubagentModelResolution, usage: TokenUsage, book: TeamPriceBook): number;
 /** The `AgentController.hasApiKey` shape, injected so there is one key resolver. */
 export type HasApiKey = (providerId: string, role?: ModelRole) => boolean;
 /** The lead-layer key resolver `resolveSubagentKey` falls back to. */

package/dist/team/model.js

@@ -23,7 +23,21 @@
  * went stale. The reason is disclosed, never swallowed: the report header and
  * the settings summary line both render it.
  */
+import { computeCost } from '../agent/usage.js';
 import { resolveFastTier } from '../fast/resolve.js';
+/**
+ * USD for one child `usage` event, at the model the children ACTUALLY ran.
+ *
+ * The status bar and the dispatch report must agree, so both price through the same
+ * resolution: under the default `main` mode this is the lead's table (byte parity),
+ * otherwise the fast / profile model's. A model no table prices contributes ZERO rather
+ * than a fabricated figure (C-11 / RV-4), where the report says `pricing unknown`.
+ */
+export function priceTeamUsage(resolution, usage, book) {
+    if (resolution.effective === 'main')
+        return computeCost(usage, book.mainCost);
+    return book.isPriced(resolution.ref) ? computeCost(usage, book.costFor(resolution.ref)) : 0;
+}
 function mainRef(config) {
     return {
         providerId: config.provider,

package/dist/team/overseer.d.ts

@@ -293,5 +293,9 @@ export declare class TeamOverseer {
  * THE NOTE TELLS THE FRESH CHILD WHAT THE DEAD ONE DID (`filesTouched` is
  * best-effort, the same caveat the report's conflict warning carries): a
  * replacement that rewrites a half-written file blind is not a recovery.
+ *
+ * ONLY THE VARIABLE MIDDLE IS EVER CLAMPED. The closing sentence and the blank line
+ * that separates the note from the brief are what make the note a note; clamping the
+ * whole string from the tail glued an ellipsis onto the first word of the brief.
  */
 export declare function buildReplacementPrompt(spec: SubagentSpec, decision: OverseerDecision, previousRun: SubagentRun): string;

package/dist/team/overseer.js

@@ -629,8 +629,33 @@ export class TeamOverseer {
 // ---------------------------------------------------------------------------
 // Replacement brief
 // ---------------------------------------------------------------------------
-/** Headroom the amended brief keeps over the original prompt's clamp. */
-const REPLACEMENT_NOTE_CHARS = 800;
+/**
+ * Headroom the amended brief keeps over the original prompt's clamp. Sized for the
+ * LARGEST legal note: the head, a reason (`overseerReasonChars`), the file list
+ * (`REPLACEMENT_FILES_CHARS`), a guidance (`overseerGuidanceChars`) and the closing
+ * sentence. A cap below that sum silently chops a supervisor's own words.
+ */
+const REPLACEMENT_NOTE_CHARS = 1_900;
+/** The file list gets a small slice of its own: 30 long paths must not crowd out guidance. */
+const REPLACEMENT_FILES_CHARS = 240;
+/** The last thing a replacement reads before its brief; never clamped away. */
+const REPLACEMENT_NOTE_TAIL = ' Verify rather than assume prior work is complete.\n\n';
+/** `a, b, +3 more`: whole paths only, never a path cut in half. */
+function listFiles(files, max) {
+    const kept = [];
+    let used = 0;
+    for (const file of files) {
+        const next = used + file.length + (kept.length > 0 ? 2 : 0);
+        if (next > max)
+            break;
+        kept.push(file);
+        used = next;
+    }
+    const hidden = files.length - kept.length;
+    if (kept.length === 0)
+        return clampChars(files[0] ?? '', max);
+    return hidden > 0 ? `${kept.join(', ')}, +${hidden} more` : kept.join(', ');
+}
 /**
  * Prepend the supervisor's note to a spec's prompt, bounding the TOTAL to
  * `TEAM_LIMITS.promptChars` so the replacement fits exactly what a
@@ -639,17 +664,24 @@ const REPLACEMENT_NOTE_CHARS = 800;
  * THE NOTE TELLS THE FRESH CHILD WHAT THE DEAD ONE DID (`filesTouched` is
  * best-effort, the same caveat the report's conflict warning carries): a
  * replacement that rewrites a half-written file blind is not a recovery.
+ *
+ * ONLY THE VARIABLE MIDDLE IS EVER CLAMPED. The closing sentence and the blank line
+ * that separates the note from the brief are what make the note a note; clamping the
+ * whole string from the tail glued an ellipsis onto the first word of the brief.
  */
 export function buildReplacementPrompt(spec, decision, previousRun) {
+    const head = `[supervisor note] A previous attempt at this task ran ${previousRun.turns} turns ` +
+        'and was replaced. Reason: ';
     const files = previousRun.filesTouched.length > 0
-        ? ` It already wrote to: ${previousRun.filesTouched.join(', ')}.`
+        ? ` It already wrote to: ${listFiles(previousRun.filesTouched, REPLACEMENT_FILES_CHARS)}.`
         : '';
     const guidance = decision.action === 'replace' && decision.guidance !== undefined
         ? ` Guidance: ${decision.guidance}`
         : '';
-    const note = clampChars(`[supervisor note] A previous attempt at this task ran ${previousRun.turns} turns ` +
-        `and was replaced. Reason: ${decision.reason}.${files}${guidance} ` +
-        `Verify rather than assume prior work is complete.\n\n`, REPLACEMENT_NOTE_CHARS);
+    const fixedChars = head.length + REPLACEMENT_NOTE_TAIL.length;
+    const middleBudget = Math.max(0, REPLACEMENT_NOTE_CHARS - fixedChars);
+    const middle = clampChars(`${decision.reason}.${files}${guidance}`, middleBudget);
+    const note = `${head}${middle}${REPLACEMENT_NOTE_TAIL}`;
     const originalBudget = Math.max(0, TEAM_LIMITS.promptChars - note.length);
     return `${note}${spec.prompt.slice(0, originalBudget)}`;
 }

package/dist/team/prompt.js

@@ -48,9 +48,9 @@ export function buildTeamBlock(params) {
         '',
         'Each subagent starts with no memory of this conversation, so its prompt must',
         'carry everything it needs: the goal, the files or areas it owns, and what to',
-        'report back. Give each one a disjoint set of files to write. Every subagent',
-        'runs on your own model. Subagents cannot dispatch further subagents and',
-        'cannot ask the user anything.',
+        'report back. Give each one a disjoint set of files to write. Each subagent runs',
+        'on the model the user configured for subagents (usually your own). Subagents',
+        'cannot dispatch further subagents and cannot ask the user anything.',
         '',
         'You get one combined report when they all finish. Read it before deciding what',
         'to do next, and tell the user what the team found in your own words.',

package/dist/team/report.d.ts

@@ -57,6 +57,27 @@ export interface ReportOptions {
  * one layer lower down.
  */
 export declare function truncateBytes(text: string, maxBytes: number): string;
+/**
+ * Wall time of a child's run for the machine-readable feeds (`-p` stderr, `exec` JSON).
+ *
+ * A child that was aborted while still queued carries `endedAt` but NO `startedAt`
+ * (`startedAt` means "an attempt began", and `selectPanelRows` / `teamClockText` rely on
+ * it), so `endedAt - 0` would be an epoch-sized number. A running child (`endedAt`
+ * unset) keeps reading `0`, exactly as the feeds always have.
+ */
+export declare function runDurationMs(run: SubagentRun): number;
+/**
+ * The form a written path is stored in: relative to the child's cwd with `/`
+ * separators when it lives under it, otherwise the resolved absolute path. `src/a.ts`,
+ * `./src/a.ts` and `<cwd>/src/a.ts` are one file and have to read as one file.
+ */
+export declare function normalizeLedgerPath(cwd: string, path: string): string;
+/**
+ * The identity two spellings are compared by. Case is folded on Windows only: ext4 and
+ * APFS disagree about case, and a missed warning beats an invented one for a message
+ * that is phrased as a warning (see `findFileConflicts`).
+ */
+export declare function ledgerPathKey(path: string): string;
 /**
  * Files written by more than one child.
  *

package/dist/team/report.js

@@ -20,6 +20,7 @@
  * outcome of a fan-out; an all-or-nothing result would throw away four successes
  * because of one HTTP 429.
  */
+import { isAbsolute, relative, resolve } from 'node:path';
 import { computeCost, formatCost, formatDuration, formatTokens } from '../agent/usage.js';
 import { TEAM_AGGREGATE_LABEL, TEAM_LIMITS } from './limits.js';
 /** The pseudo-label aggregate notices use; reserved at normalization. */
@@ -57,6 +58,19 @@ function statusBadge(run) {
         return '[stopped: turn cap reached]';
     return '[ok]';
 }
+/**
+ * Wall time of a child's run for the machine-readable feeds (`-p` stderr, `exec` JSON).
+ *
+ * A child that was aborted while still queued carries `endedAt` but NO `startedAt`
+ * (`startedAt` means "an attempt began", and `selectPanelRows` / `teamClockText` rely on
+ * it), so `endedAt - 0` would be an epoch-sized number. A running child (`endedAt`
+ * unset) keeps reading `0`, exactly as the feeds always have.
+ */
+export function runDurationMs(run) {
+    if (run.startedAt === undefined)
+        return 0;
+    return Math.max(0, (run.endedAt ?? 0) - run.startedAt);
+}
 function elapsed(run) {
     if (run.startedAt === undefined)
         return '0.0s';
@@ -65,6 +79,26 @@ function elapsed(run) {
 function isOk(run) {
     return run.phase === 'done' && !run.error;
 }
+/**
+ * The form a written path is stored in: relative to the child's cwd with `/`
+ * separators when it lives under it, otherwise the resolved absolute path. `src/a.ts`,
+ * `./src/a.ts` and `<cwd>/src/a.ts` are one file and have to read as one file.
+ */
+export function normalizeLedgerPath(cwd, path) {
+    const absolute = resolve(cwd, path);
+    const rel = relative(cwd, absolute);
+    const inside = rel.length > 0 && rel.split(/[/\\]/)[0] !== '..' && !isAbsolute(rel);
+    return (inside ? rel : absolute).replace(/\\/g, '/');
+}
+/**
+ * The identity two spellings are compared by. Case is folded on Windows only: ext4 and
+ * APFS disagree about case, and a missed warning beats an invented one for a message
+ * that is phrased as a warning (see `findFileConflicts`).
+ */
+export function ledgerPathKey(path) {
+    const key = resolve(path).replace(/\\/g, '/');
+    return process.platform === 'win32' ? key.toLowerCase() : key;
+}
 /**
  * Files written by more than one child.
  *
@@ -77,17 +111,14 @@ export function findFileConflicts(runs) {
     const owners = new Map();
     for (const run of runs) {
         for (const path of run.filesTouched) {
-            const list = owners.get(path) ?? [];
-            if (!list.includes(run.label))
-                list.push(run.label);
-            owners.set(path, list);
+            const key = ledgerPathKey(path);
+            const entry = owners.get(key) ?? { path, labels: [] };
+            if (!entry.labels.includes(run.label))
+                entry.labels.push(run.label);
+            owners.set(key, entry);
         }
     }
-    const out = [];
-    for (const [path, labels] of owners) {
-        if (labels.length > 1)
-            out.push({ path, labels });
-    }
+    const out = [...owners.values()].filter((entry) => entry.labels.length > 1);
     return out.sort((a, b) => a.path.localeCompare(b.path, 'en'));
 }
 function buildHeader(outcome, options) {

package/dist/team/runtime.d.ts

@@ -157,6 +157,9 @@ export declare class TeamRuntime {
     /** The live roster, for `/team` status. `null` when nothing is dispatching. */
     snapshot(): TeamSnapshot | null;
     dispatch(specs: SubagentSpec[], requested: number, signal?: AbortSignal): Promise<DispatchOutcome>;
+    /** Idempotent: puts every per-dispatch field back where `dispatch()` found it. */
+    private resetDispatchState;
+    private runDispatch;
     /** One slot of the pool: take the next index until the list is exhausted. */
     private worker;
     /**

package/dist/team/runtime.js

@@ -361,6 +361,36 @@ export class TeamRuntime {
     // Dispatch
     // -------------------------------------------------------------------------
     async dispatch(specs, requested, signal) {
+        try {
+            return await this.runDispatch(specs, requested, signal);
+        }
+        catch (error) {
+            // A throw out of the dispatch body (a child that cannot be constructed) must not
+            // leave `busy` latched: every later `task` call, `/team` and busy-guarded command
+            // of the session would answer "a dispatch is already running". The success path
+            // tears down inline and never reaches this.
+            this.resetDispatchState();
+            throw error;
+        }
+    }
+    /** Idempotent: puts every per-dispatch field back where `dispatch()` found it. */
+    resetDispatchState() {
+        if (this.dispatchTimer)
+            clearTimeout(this.dispatchTimer);
+        this.dispatchTimer = null;
+        for (const handle of this.live)
+            handle.unsubscribe();
+        this.monitor?.dispose();
+        this.monitor = null;
+        this.supervision?.clearAll();
+        this.supervision = null;
+        this.overseer = null;
+        this.live = [];
+        this.bus = null;
+        this.snapshotState = null;
+        this.busy = false;
+    }
+    async runDispatch(specs, requested, signal) {
         this.counter += 1;
         const dispatchId = `d${this.counter}`;
         const config = this.deps.getConfig();
@@ -703,7 +733,9 @@ export class TeamRuntime {
             // where the replacement is actually built and driven. `attempt` resets so
             // the fresh body gets its own cold-start budget.
             if (verdict !== null && verdict.action === 'replace' && !this.aborted) {
-                this.replaceChild(dispatchId, handles, index, makeHandle, handle, verdict);
+                if (this.replaceChild(dispatchId, handles, index, makeHandle, handle, verdict) === null) {
+                    return;
+                }
                 attempt = 0;
                 continue;
             }
@@ -734,7 +766,8 @@ export class TeamRuntime {
                 this.monitor?.clear(run.label);
                 return;
             }
-            this.replaceChild(dispatchId, handles, index, makeHandle, handle, null);
+            if (this.replaceChild(dispatchId, handles, index, makeHandle, handle, null) === null)
+                return;
             await this.backoff(TEAM_LIMITS.retryBackoffMs);
             if (this.aborted) {
                 const fresh = handles[index];
@@ -778,12 +811,13 @@ export class TeamRuntime {
             trigger: 'postmortem',
         });
         if (decision.action === 'replace' && overseer.replacementsLeft(run.label)) {
-            this.replaceChild(ctx.dispatchId, ctx.handles, index, ctx.makeHandle, handle, {
+            const fresh = this.replaceChild(ctx.dispatchId, ctx.handles, index, ctx.makeHandle, handle, {
                 action: 'replace',
                 reason: decision.reason,
                 ...(decision.guidance !== undefined ? { guidance: decision.guidance } : {}),
             });
-            await this.runOne(ctx, index);
+            if (fresh !== null)
+                await this.runOne(ctx, index);
         }
     }
     /**
@@ -822,13 +856,35 @@ export class TeamRuntime {
                 }, handle.run),
             }
             : handle.spec;
-        const fresh = makeHandle(spec);
+        let fresh;
+        try {
+            fresh = makeHandle(spec);
+        }
+        catch (err) {
+            // The old body is already unsubscribed and aborted, so nothing will ever update
+            // its run again: left alone the panel shows it running forever. Settle IT.
+            const run = handle.run;
+            const reason = err instanceof Error ? err.message : String(err);
+            run.phase = 'failed';
+            run.error = `${run.error ? `${run.error}; ` : ''}could not build replacement: ${reason}`;
+            run.endedAt = run.endedAt ?? Date.now();
+            this.supervision?.clear(run.label);
+            this.monitor?.clear(run.label);
+            this.publish(dispatchId, run);
+            return null;
+        }
         // Provably {0,0} under the cold-start predicate above (no turn completed,
         // so no `turn_end` and no usage event). Carried anyway so that a future
         // relaxation of the predicate cannot silently under-report spend - the most
         // misleading failure this feature can produce.
         fresh.run.usage = carried;
         fresh.run.retries = retries;
+        // The files the discarded body already wrote are on disk whatever happens next,
+        // so the report and the conflict warning must keep seeing them (and a chained
+        // replacement must keep telling the next body about them). ONLY the ledger moves:
+        // `turns` / `toolCalls` are live controls (turn cap, cold-start retry predicate,
+        // supervisor digest) that describe the CURRENT body. Empty on a cold-start retry.
+        fresh.run.filesTouched = handle.run.filesTouched.slice(0, TEAM_LIMITS.filesTouchedMax);
         if (replacements > 0)
             fresh.run.replacements = replacements;
         if (interventions !== undefined)

package/dist/team/subagent.js

@@ -15,6 +15,7 @@ import { formatStreamError } from '../agent/reducer.js';
 import { buildSystemPrompt } from '../agent/system-prompt.js';
 import { buildFastBlock } from '../fast/prompt.js';
 import { createBuiltinTools, gatedToolTimeouts, } from '../tools/index.js';
+import { ledgerPathKey, normalizeLedgerPath } from './report.js';
 import { describeToolActivity, pickActivityArgs, sanitizeActivity } from './activity.js';
 import { TEAM_LIMITS, TEAM_SUBAGENT_TOOL_NAMES } from './limits.js';
 import { appendTimeline } from './timeline.js';
@@ -386,17 +387,26 @@ export function createSubagent(spec, deps, hooks) {
             textTail.length > 0 ? sanitizeActivity(textTail, TEAM_LIMITS.activityChars) : undefined;
         hooks.onUpdate({ ...run, filesTouched: [...run.filesTouched] });
     };
-    const noteFile = (toolName, args) => {
+    /**
+     * The path a write tool is ABOUT to touch, or `undefined` for every other tool.
+     * Staged on the start event and committed on the end event, because only the end
+     * event knows whether the write happened (`isError`). The string is the path alone,
+     * never the file body (P1-4 / P1-5).
+     */
+    const stagedWritePath = (toolName, args) => {
         if (toolName !== 'write_file' && toolName !== 'edit_file')
-            return;
+            return undefined;
         const path = args?.path;
-        if (typeof path !== 'string' || path.length === 0)
-            return;
-        if (run.filesTouched.includes(path))
+        return typeof path === 'string' && path.length > 0 ? path : undefined;
+    };
+    const noteFile = (path) => {
+        const normalized = normalizeLedgerPath(deps.getCwd(), path);
+        const key = ledgerPathKey(normalized);
+        if (run.filesTouched.some((known) => ledgerPathKey(known) === key))
             return;
         if (run.filesTouched.length >= TEAM_LIMITS.filesTouchedMax)
             return;
-        run.filesTouched.push(path);
+        run.filesTouched.push(normalized);
     };
     const unsubscribe = agent.subscribe((event) => {
         switch (event.type) {
@@ -476,18 +486,26 @@ export function createSubagent(spec, deps, hooks) {
                 // Recorded for the DURATION only; the entry itself is appended on the end
                 // event, when `ok` and `ms` are both known (§4.5.2).
                 pendingTool = { name: event.toolName, at: Date.now() };
+                const stagedPath = stagedWritePath(event.toolName, event.args);
+                if (stagedPath !== undefined)
+                    pendingTool.path = stagedPath;
                 run.phase = event.toolName === 'team_wait' ? 'waiting' : 'tool';
                 run.lastTool = event.toolName;
                 run.toolCalls += 1;
                 textTail = '';
                 run.activity = undefined; // prose is stale now
                 run.activityArgs = pickActivityArgs(event.args); // PICKED, not raw (P1-4)
-                noteFile(event.toolName, event.args);
                 break;
             case 'tool_execution_end': {
                 const endedAt = Date.now();
                 const startedAt = pendingTool?.at;
+                const writtenPath = pendingTool?.path;
                 pendingTool = null;
+                // The ledger records a write that HAPPENED: a refused (plan gate, --confirm,
+                // sandbox) or failed write is not a touched file, and the timeline below
+                // already reads `isError` for the same reason.
+                if (writtenPath !== undefined && event.isError !== true)
+                    noteFile(writtenPath);
                 // THE ARGUMENTS ARE GONE BY NOW, on purpose (P1-5): `activityArgs` is cleared a
                 // few lines below, and the timeline's text comes from `describeToolActivity` on
                 // the PICKED subset, so a `write_file` body can never reach the board.

package/dist/ui/App.js

@@ -55,6 +55,7 @@ import { advanceBudget, decideFollowThrough, emptyBudget, } from '../todo/follow
 // no policy. Imported beside the todo decision it shares one timer with.
 import { decideForcedDispatch, FORCED_NUDGE_NOTICE } from '../team/dispatch-gate.js';
 import { FORCED_NUDGE_GRACE_MS } from '../team/limits.js';
+import { priceTeamUsage } from '../team/model.js';
 import { useTerminalSize } from './layout/useTerminalSize.js';
 import { useHeightStore } from './use-height-store.js';
 import { useRenderGovernor } from './use-render-governor.js';
@@ -929,21 +930,34 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
                     // handler above records): this effect's dependency list never changes,
                     // so it closes over the `cfg` object of the render it mounted in, and
                     // `setModel` builds a NEW one.
-                    const live = controller.getConfig();
-                    // Every child runs the lead's own model (main-agent parity), so the
-                    // lead's live connection IS the tier that billed.
-                    const ref = { providerId: live.provider, modelId: live.model };
-                    // Unknown pricing contributes ZERO rather than a fabricated figure
-                    // (C-11 / RV-4); `/fast status` and the dispatch report say `unknown`.
-                    const costDelta = controller.isPricedModel(ref)
-                        ? computeCost(event.usage, controller.getModelInfoFor(ref).cost)
-                        : 0;
+                    //
+                    // PRICED AT THE MODEL THE CHILDREN RAN (`team.model`), through the same
+                    // resolution the dispatch report prices with: under `fast` / `profile` the
+                    // lead's table would over-report by up to an order of magnitude, and an
+                    // unpriced child model must read as unknown (ZERO here), not as the lead's.
+                    const costDelta = priceTeamUsage(controller.subagentModelResolution(), event.usage, {
+                        mainCost: controller.getModelInfo().cost,
+                        isPriced: (ref) => controller.isPricedModel(ref),
+                        costFor: (ref) => controller.getModelInfoFor(ref).cost,
+                    });
                     dispatch({ type: 'teamUsage', usage: event.usage, costDelta });
                     break;
                 }
-                case 'dispatch_end':
+                case 'dispatch_end': {
+                    // The supervisor's own calls never emit a usage event (they go through the fast
+                    // registry directly), so their spend reaches the readout HERE, once per
+                    // dispatch, at the fast tier's price - the same channel review spend uses.
+                    const spend = event.outcome.overseerUsage;
+                    if (spend !== undefined && (spend.inputTokens > 0 || spend.outputTokens > 0)) {
+                        const tier = controller.getFastStatus().tier;
+                        const costDelta = tier.ok && controller.isPricedModel(tier.ref)
+                            ? computeCost(spend, controller.getModelInfoFor(tier.ref).cost)
+                            : 0;
+                        dispatch({ type: 'fastUsage', usage: spend, costDelta });
+                    }
                     dispatch({ type: 'teamEnd', outcome: event.outcome });
                     break;
+                }
             }
         });
         return () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aragon-agent/cli",
-  "version": "0.6.42",
+  "version": "0.6.43",
   "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.54",
+    "@aragon-agent/core": "^0.2.55",
     "chalk": "^5.6.2",
     "cli-highlight": "^2.0.0",
     "commander": "^12.1.0",