@aragon-agent/cli 0.6.42 → 0.6.44

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/proc/kill-tree.d.ts

@@ -38,5 +38,23 @@ export declare function killTree(pid: number | undefined, signal?: NodeJS.Signal
  * The only kill primitive a signal handler, `process.on('exit')` or
  * `handleFatal` may reach (I-9). No escalation ladder and no logging: a reaper
  * that can block or throw is worse than one that misses a child.
+ *
+ * IT RETURNS WHETHER THE KILL WAS CONFIRMED, AND THAT IS NOT BOOKKEEPING. The
+ * Windows branch is a `taskkill` PROCESS, and `spawnSync`'s own `timeout` kills
+ * that process when the budget runs out. Measured on 2026-10-23: one
+ * `taskkill /t /f` of a shell plus its node child takes 1027-1058 ms on an IDLE
+ * machine (five samples), and a `taskkill` cut off at a 150 ms deadline leaves the
+ * tree ALIVE 1.5 s later (`ETIMEDOUT`, `status = null`, `signal = SIGTERM`). This
+ * function used to `catch {}` that result and return `void`, so the one caller
+ * that promises "no service outlives the CLI" could not tell a kill from a
+ * timeout - and a loaded host, where a single tree kill genuinely needs more than
+ * the old 2000 ms, silently leaked every child it was asked to reap.
+ *
+ * The budget therefore lives in `PROC_LIMITS.killTreeSyncTimeoutMs`, sized from
+ * that measurement rather than from optimism, and the answer comes back to the
+ * caller so `reapSync` can raise `killIncomplete` instead of pretending.
+ *
+ * POSIX reports `true` when a signal was DELIVERED, which is as much as a signal
+ * can ever confirm.
  */
-export declare function killTreeSync(pid: number | undefined): void;
+export declare function killTreeSync(pid: number | undefined): boolean;

package/dist/proc/kill-tree.js

@@ -24,6 +24,7 @@
  */
 import { spawn, spawnSync } from 'node:child_process';
 import process from 'node:process';
+import { PROC_LIMITS } from './limits.js';
 /** Is the pid still there? `signal 0` tests for existence without delivering. */
 export function isAlive(pid) {
     if (pid === undefined || !Number.isFinite(pid) || pid <= 0)
@@ -88,32 +89,58 @@ export function killTree(pid, signal = 'SIGKILL') {
  * The only kill primitive a signal handler, `process.on('exit')` or
  * `handleFatal` may reach (I-9). No escalation ladder and no logging: a reaper
  * that can block or throw is worse than one that misses a child.
+ *
+ * IT RETURNS WHETHER THE KILL WAS CONFIRMED, AND THAT IS NOT BOOKKEEPING. The
+ * Windows branch is a `taskkill` PROCESS, and `spawnSync`'s own `timeout` kills
+ * that process when the budget runs out. Measured on 2026-10-23: one
+ * `taskkill /t /f` of a shell plus its node child takes 1027-1058 ms on an IDLE
+ * machine (five samples), and a `taskkill` cut off at a 150 ms deadline leaves the
+ * tree ALIVE 1.5 s later (`ETIMEDOUT`, `status = null`, `signal = SIGTERM`). This
+ * function used to `catch {}` that result and return `void`, so the one caller
+ * that promises "no service outlives the CLI" could not tell a kill from a
+ * timeout - and a loaded host, where a single tree kill genuinely needs more than
+ * the old 2000 ms, silently leaked every child it was asked to reap.
+ *
+ * The budget therefore lives in `PROC_LIMITS.killTreeSyncTimeoutMs`, sized from
+ * that measurement rather than from optimism, and the answer comes back to the
+ * caller so `reapSync` can raise `killIncomplete` instead of pretending.
+ *
+ * POSIX reports `true` when a signal was DELIVERED, which is as much as a signal
+ * can ever confirm.
  */
 export function killTreeSync(pid) {
     if (pid === undefined || !Number.isFinite(pid) || pid <= 0)
-        return;
+        return false;
     if (process.platform === 'win32') {
+        let result;
         try {
-            spawnSync('taskkill', ['/pid', String(pid), '/t', '/f'], {
+            result = spawnSync('taskkill', ['/pid', String(pid), '/t', '/f'], {
                 windowsHide: true,
                 stdio: 'ignore',
-                timeout: 2000,
+                timeout: PROC_LIMITS.killTreeSyncTimeoutMs,
             });
         }
         catch {
-            /* ignore */
+            return false;
         }
-        return;
+        // `error` is set for a spawn failure AND for the budget expiring (`ETIMEDOUT`,
+        // with `signal = SIGTERM`), and neither is a kill.
+        if (result.error)
+            return false;
+        return result.status === 0;
     }
     try {
         process.kill(-pid, 'SIGKILL');
+        return true;
     }
     catch {
         try {
             process.kill(pid, 'SIGKILL');
+            return true;
         }
         catch {
             /* already gone */
+            return false;
         }
     }
 }

package/dist/proc/limits.d.ts

@@ -102,6 +102,25 @@ export declare const PROC_LIMITS: {
     readonly killVerifyMs: 2000;
     /** Liveness poll interval while waiting for a `SIGKILL` to land. */
     readonly killVerifyPollMs: 50;
+    /**
+     * How long ONE synchronous tree kill (`killTreeSync`) may take.
+     *
+     * MEASURED, NOT GUESSED. A `taskkill /pid <shell> /t /f` of a shell plus its
+     * node child takes 1027-1058 ms on the reference machine on an IDLE host (five
+     * samples, 2026-10-23), so the old 2000 ms was 1.9x the honest cost and the
+     * 2026-10-23 release run - where the whole suite took 340 s against the usual
+     * 200-240 s - is comfortably inside the range where a single tree kill exceeds
+     * it. Crossing it is not a slow kill, it is NO kill: `spawnSync` kills
+     * `taskkill` itself at the deadline and the tree keeps running (verified: a
+     * 150 ms budget left the child alive 1.5 s later, `ETIMEDOUT` / `status null`).
+     *
+     * 5000 ms is ~5x the measured cost. It is a CEILING and not a cost: a tree that
+     * dies in the usual second still returns in that second. The worst case is
+     * `maxJobs` (16) trees at the ceiling on an exit hook, which is why this is not
+     * any larger - the reaper prefers a reported miss to an exit that never ends,
+     * and the miss is now reported (`ProcRecord.killIncomplete`).
+     */
+    readonly killTreeSyncTimeoutMs: 5000;
     /** Below this many terminal columns the status chip degrades to `[N]`. */
     readonly statusCompactCols: 92;
     /**

package/dist/proc/limits.js

@@ -102,6 +102,25 @@ export const PROC_LIMITS = {
     killVerifyMs: 2000,
     /** Liveness poll interval while waiting for a `SIGKILL` to land. */
     killVerifyPollMs: 50,
+    /**
+     * How long ONE synchronous tree kill (`killTreeSync`) may take.
+     *
+     * MEASURED, NOT GUESSED. A `taskkill /pid <shell> /t /f` of a shell plus its
+     * node child takes 1027-1058 ms on the reference machine on an IDLE host (five
+     * samples, 2026-10-23), so the old 2000 ms was 1.9x the honest cost and the
+     * 2026-10-23 release run - where the whole suite took 340 s against the usual
+     * 200-240 s - is comfortably inside the range where a single tree kill exceeds
+     * it. Crossing it is not a slow kill, it is NO kill: `spawnSync` kills
+     * `taskkill` itself at the deadline and the tree keeps running (verified: a
+     * 150 ms budget left the child alive 1.5 s later, `ETIMEDOUT` / `status null`).
+     *
+     * 5000 ms is ~5x the measured cost. It is a CEILING and not a cost: a tree that
+     * dies in the usual second still returns in that second. The worst case is
+     * `maxJobs` (16) trees at the ceiling on an exit hook, which is why this is not
+     * any larger - the reaper prefers a reported miss to an exit that never ends,
+     * and the miss is now reported (`ProcRecord.killIncomplete`).
+     */
+    killTreeSyncTimeoutMs: 5000,
     /** Below this many terminal columns the status chip degrades to `[N]`. */
     statusCompactCols: 92,
     // --- long-task-jobs: bounded waiting, progress, notices, log mirror --------

package/dist/proc/supervisor.js

@@ -404,9 +404,16 @@ export class ProcSupervisor {
         for (const entry of this.services.values()) {
             if (isTerminalStatus(entry.record.status))
                 continue;
-            killTreeSync(entry.record.pid);
+            // THE ANSWER IS PART OF THE REAP (AC-42, 2026-10-23 release). A `taskkill`
+            // that outlived its budget is killed itself and the tree survives, so an
+            // unconfirmed kill has to reach the record the card and `bash_output` read -
+            // otherwise "stopped" is a claim nobody made good on. `killIncomplete` is
+            // that field (P2-6), and it is the reason the reaper may keep a bound at all.
+            const killed = killTreeSync(entry.record.pid);
             entry.record.status = 'stopped';
             entry.record.endedAt = Date.now();
+            if (!killed)
+                entry.record.killIncomplete = true;
             entry.watcher?.stop();
             if (entry.outputTimer)
                 clearTimeout(entry.outputTimer);

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;
     /**