@aragon-agent/cli 0.6.40 → 0.6.43

package/dist/team/limits.d.ts

@@ -265,4 +265,44 @@ 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.
+ *
+ * The block's words are a CONTRACT with the model, so a behaviour report ("it
+ * still did the work itself") has to be tieable to one revision. Kept beside
+ * `TEAM_BLOCK_VERSION` rather than reusing it: the two blocks answer different
+ * questions ("can dispatch" versus "must dispatch") and a shared number would
+ * name neither revision.
+ */
+export declare const FORCED_TEAM_BLOCK_VERSION = "v1-2026-10";
+/**
+ * Length ceiling of the `<forced_team_mode>` text.
+ *
+ * THE FIRST BLOCK LENGTH IN THIS SUBSYSTEM THAT A TEST ASSERTS: the `<team_mode>`
+ * block's 1200 is a comment in `team/prompt.ts`, and unifying the two is a
+ * separate small refactor (deliberately out of scope here). Looser than 1200
+ * because this block is only ever paid for while the session is ARMED, and it
+ * carries three layers of instruction rather than one.
+ */
+export declare const FORCED_TEAM_BLOCK_MAX_CHARS = 1400;
+/**
+ * Fallback nudges per user turn. ONE, and not configurable.
+ *
+ * The gate exists because the first two layers (the directive and the prompt
+ * block) both depend on the model cooperating. A second nudge would double the
+ * worst case of a model that is simply not going to dispatch - at N children per
+ * attempt - and D-8's whole argument is that the mechanical layer must be
+ * bounded by something other than the model's willingness.
+ */
+export declare const FORCED_NUDGE_LIMIT = 1;
+/**
+ * Grace window before the fallback nudge fires, in milliseconds.
+ *
+ * SAME ORDER AS THE TODO FOLLOW-THROUGH GRACE, for a structural reason rather
+ * than a stylistic one: both continuations share ONE `followTimer` in `App`
+ * (I-9), so "at most one armed continuation" is only explicable while the two
+ * numbers stay in the same order of magnitude. **Changing todo's grace means
+ * re-reading this constant.**
+ */
+export declare const FORCED_NUDGE_GRACE_MS = 3000;

package/dist/team/limits.js

@@ -279,4 +279,52 @@ 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).
+//
+// FOUR STRUCTURAL NUMBERS, here rather than in the modules that read them for
+// the reason this file's header records: none of them is a user preference, and
+// a `config.json` key for any of them would make "the model ignored the
+// instruction" tunable by the person the instruction exists to protect.
+// ---------------------------------------------------------------------------
+/**
+ * The version string on `<forced_team_mode>`'s first line.
+ *
+ * The block's words are a CONTRACT with the model, so a behaviour report ("it
+ * still did the work itself") has to be tieable to one revision. Kept beside
+ * `TEAM_BLOCK_VERSION` rather than reusing it: the two blocks answer different
+ * questions ("can dispatch" versus "must dispatch") and a shared number would
+ * name neither revision.
+ */
+export const FORCED_TEAM_BLOCK_VERSION = 'v1-2026-10';
+/**
+ * Length ceiling of the `<forced_team_mode>` text.
+ *
+ * THE FIRST BLOCK LENGTH IN THIS SUBSYSTEM THAT A TEST ASSERTS: the `<team_mode>`
+ * block's 1200 is a comment in `team/prompt.ts`, and unifying the two is a
+ * separate small refactor (deliberately out of scope here). Looser than 1200
+ * because this block is only ever paid for while the session is ARMED, and it
+ * carries three layers of instruction rather than one.
+ */
+export const FORCED_TEAM_BLOCK_MAX_CHARS = 1400;
+/**
+ * Fallback nudges per user turn. ONE, and not configurable.
+ *
+ * The gate exists because the first two layers (the directive and the prompt
+ * block) both depend on the model cooperating. A second nudge would double the
+ * worst case of a model that is simply not going to dispatch - at N children per
+ * attempt - and D-8's whole argument is that the mechanical layer must be
+ * bounded by something other than the model's willingness.
+ */
+export const FORCED_NUDGE_LIMIT = 1;
+/**
+ * Grace window before the fallback nudge fires, in milliseconds.
+ *
+ * SAME ORDER AS THE TODO FOLLOW-THROUGH GRACE, for a structural reason rather
+ * than a stylistic one: both continuations share ONE `followTimer` in `App`
+ * (I-9), so "at most one armed continuation" is only explicable while the two
+ * numbers stay in the same order of magnitude. **Changing todo's grace means
+ * re-reading this constant.**
+ */
+export const FORCED_NUDGE_GRACE_MS = 3000;

package/dist/team/model.d.ts

@@ -5,16 +5,16 @@
  * ASCII ONLY: `src/team/**` is inside the glyph scanner's scope.
  *
  * EVERY CONSUMER READS THE CHILD'S MODEL THROUGH THIS FUNCTION AND NOWHERE
- * ELSE — `createSubagent`, the `task` report header, the settings root row and
- * `/team model` — following the `resolveFastTier` precedent one directory over:
- * four call sites each recomputing "which model do children run on?" from raw
+ * ELSE — `createSubagent`, the `task` report header and the settings root row —
+ * following the `resolveFastTier` precedent one directory over: three call
+ * sites each recomputing "which model do children run on?" from raw
  * config keys is exactly how the report ends up naming a model the children
  * silently fell back from.
  *
  * IT IS RE-RUN ON EVERY DISPATCH AND EVERY RENDER, NOT ONCE (rule 8 / RV-3 of
  * the fast tier, inherited here): `team.model`, the fast tier and the profile
- * library are all LIVE keys a settings save, `/fast off` or `/team model` can
- * rewrite mid-session. A resolution captured at construction would be a
+ * library are all LIVE keys a settings save (the `Subagent model` row), `/fast
+ * off` or a kit can rewrite mid-session. A resolution captured at construction would be a
  * resolution describing a session that no longer exists.
  *
  * A CHILD IS NEVER LEFT WITHOUT A MODEL (D-4). Every failure mode — fast tier
@@ -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

@@ -5,16 +5,16 @@
  * ASCII ONLY: `src/team/**` is inside the glyph scanner's scope.
  *
  * EVERY CONSUMER READS THE CHILD'S MODEL THROUGH THIS FUNCTION AND NOWHERE
- * ELSE — `createSubagent`, the `task` report header, the settings root row and
- * `/team model` — following the `resolveFastTier` precedent one directory over:
- * four call sites each recomputing "which model do children run on?" from raw
+ * ELSE — `createSubagent`, the `task` report header and the settings root row —
+ * following the `resolveFastTier` precedent one directory over: three call
+ * sites each recomputing "which model do children run on?" from raw
  * config keys is exactly how the report ends up naming a model the children
  * silently fell back from.
  *
  * IT IS RE-RUN ON EVERY DISPATCH AND EVERY RENDER, NOT ONCE (rule 8 / RV-3 of
  * the fast tier, inherited here): `team.model`, the fast tier and the profile
- * library are all LIVE keys a settings save, `/fast off` or `/team model` can
- * rewrite mid-session. A resolution captured at construction would be a
+ * library are all LIVE keys a settings save (the `Subagent model` row), `/fast
+ * off` or a kit can rewrite mid-session. A resolution captured at construction would be a
  * resolution describing a session that no longer exists.
  *
  * A CHILD IS NEVER LEFT WITHOUT A MODEL (D-4). Every failure mode — fast tier
@@ -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.