@kushalkhemka/opensec-pi-subagents 0.20.4 → 0.20.5

package/CHANGELOG.md

@@ -7,6 +7,61 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.20.5] - 2026-10-16
+
+Orchestration results the main agent can act on: failed runs are error results with what they produced, unfinished
+agents point at the completion notification instead of inviting polling, and a released agent's result stays readable.
+
+> **Possibly breaking:**
+> - **Failed, aborted and stopped runs return `isError: true`**, as do unknown-agent lookups and refused steers or
+>   resumes. Pi shows them as tool errors and the main agent reads them as failures.
+> - **A model name whose closest matches span several providers is refused** instead of resolving to one of them,
+>   unless the parent's provider is among them. Use the exact `provider/id` to choose another provider.
+
+### Added
+
+- **`get_subagent_result` reads a released agent's result from its saved session.** After the 10-minute cleanup it
+  used to answer `Agent not found`; it now answers with the status and model from the kept resume state and the final
+  result read from the session file, marked as such. Nothing is held in memory longer: the file is read on demand. The
+  resume state now records the run's status.
+- **Each run records the model and thinking level it ran with**, a resumed run its own. The foreground result's
+  stats, `get_subagent_result` (`Model:`) and the completion notification (`<model>`, `<thinking>`) show them.
+- **Malformed tool arguments from weak models are repaired before validation** (`prepareArguments`) on the top-level
+  and nested `Agent`, `get_subagent_result` and `steer_subagent` tools: the arguments object sent as a JSON string or
+  stuffed into one string field, arrays where a string is expected, `null` optional fields, booleans and numbers sent
+  as strings, and a missing `subagent_type` on the top-level `Agent` tool, which goes to the default type under the
+  `fallbackSubagent` policy (`Note: No agent type given — using …`). A missing prompt is never invented.
+
+### Changed
+
+- **Failed runs are error results.** The foreground `Agent` result, resumed runs and `get_subagent_result`, top-level
+  and nested, set `isError` for `error`, `aborted` and `stopped`. The result renderer keeps the agent's status line for
+  these. A stopped run's headline reads `Agent was stopped by the user after …`, an aborted one `Agent was aborted
+  after …`, instead of `Agent completed in …`.
+- **Failure results keep the partial output and name the session file.** The run's last assistant text is kept also
+  when the run threw or a stopped run was abandoned, bounded to the run's own turns, and the result names the agent's
+  saved session file, which holds every turn (`<session-file>` in the notification). No separate files are written.
+- **No more polling prompts.** `get_subagent_result` on a running, queued or still-stopping agent says a completion
+  notification arrives on its own, to continue with other work, and not to call it again for that agent until then.
+  Its description and the `wait` parameter say the same; `wait` stays `false` by default. Background spawn and resume
+  results and the refused resume of a running agent no longer suggest `get_subagent_result` to wait.
+- **Notifications preview the first 10 lines of a result**, still capped at 500 characters (300 per agent in a group)
+  so one long line cannot flood the context, and carry the full result's size in `<result_bytes>`. The truncation note
+  says how many lines and bytes were left out.
+- **Model names no longer resolve across providers by guessing.** An exact `provider/id` (case-insensitive) resolves
+  as before. Among a short name's closest matches (`haiku`, `sonnet`), the parent's provider wins when it serves one;
+  matches from a single provider resolve to the tightest, as before (ties by id). Only matches that still span several
+  providers are an error naming up to five closest candidates. An exact id two providers serve follows the same rule.
+  A per-call model that does not resolve stays a tool error on every path.
+- **An agent file's model that does not resolve is reported.** The run still falls back to the parent's model, but its
+  results say which model was asked for, why it was not used and which model ran instead (the `Agent` and nested
+  `Agent` results, `get_subagent_result`, `<model-note>` in the notification). Spawns that resolve the agent file's
+  model by exact `provider/id` only (`@mentions`, RPC, scheduled jobs) and scheduled jobs whose model no longer
+  resolves note it the same way; workflows show it as a warning once per run.
+- **More released agents stay addressable:** 2000 top-level and 4000 nested or workflow entries (was 100 and 200).
+  An entry holds ids, paths and settings, about 450 bytes (700 with a worktree), never the conversation. Restoring
+  them at session start trims once instead of rescanning per entry.
+
 ## [0.20.4] - 2026-10-16
 
 The conversation viewer draws a subagent's transcript with Pi's own chat components, so it looks exactly like Pi's

package/README.md

@@ -61,7 +61,7 @@ Agent({ subagent_type: "Explore", prompt: "Find authentication code", descriptio
 | Tool | What it does |
 |---|---|
 | `Agent` | Starts an agent. A background run returns an ID and notifies the main session when it finishes; set `run_in_background: false` when the next step must wait for its result. Also accepts session-scoped cron, interval, and one-shot schedules. |
-| `get_subagent_result` | Returns the full result of an agent. |
+| `get_subagent_result` | Returns the full result of a finished agent, also after its record was released from memory. For an agent still running it says to wait for the completion notification instead of checking again (`wait: true` blocks, and is off by default). |
 | `steer_subagent` | Redirects a running agent. |
 | `SubagentWorkflow` | Runs repeatable multi-agent work (`agent()`, `parallel()`, `pipeline()`). |
 
@@ -82,6 +82,9 @@ When a background agent (or workflow) finishes, the main session is notified, as
 - If you interrupt the parent (`Esc`), what was waiting is kept and delivered once the interrupted turn has stopped,
   starting a turn.
 - Reading a result with `get_subagent_result` (or the RPC `consume`) before the notification is sent suppresses it.
+- A notification carries the first 10 lines of the result (at most 500 characters, 300 per agent in a group), the
+  full result's size in `<result_bytes>`, the model and thinking level the run used (`<model>`, `<thinking>`), and,
+  when anything was cut, how many lines and bytes were left out. `get_subagent_result` returns the rest.
 - A result that lands while another session is open, or that is still waiting for its parent's boundary when you switch
   away, is recorded in its own session and delivered the same way when you return there (see
   [Switching sessions](#switching-sessions)).
@@ -93,6 +96,21 @@ The join mode (`/agents → Settings → Join mode`, `defaultJoinMode`) decides
 | `smart` (default) | No waiting: each result is delivered at the parent's next boundary. `async` is accepted as an older name for it. |
 | `group` | The background agents spawned in one parent turn report together, in one notification once all of them have finished (a lone spawn reports alone). A 30 s timeout after the first completion sends a partial notification; stragglers follow within 15 s. |
 
+### Failed runs
+
+An agent that ends in an error, is aborted at its turn limit, or is stopped by the user is reported to the main agent
+as an error result (`isError`), not as a completed task: the foreground `Agent` result, a resumed run, and
+`get_subagent_result`, top-level and nested. So are lookups of an unknown agent and refused steers or resumes.
+
+- The result keeps the run's last assistant text (`Partial output before the failure:` for an error), also when the
+  run threw or a stopped run had to be abandoned, and names the agent's saved session file, which holds every turn.
+  The background notification carries the file as `<session-file>`.
+- A run the user stopped says so (`Agent was stopped by the user …`, `STOPPED BY THE USER`).
+- Weak models' malformed tool arguments are repaired before Pi validates them: the arguments object sent as a JSON
+  string or stuffed into one field, arrays for strings, `null` optional fields, `"true"` or `"5"` for booleans and
+  numbers, and a missing `subagent_type` (the default type, under the `fallbackSubagent` policy). A missing prompt is
+  never invented.
+
 ### Sending a foreground agent to the background
 
 While a foreground `Agent` call runs (`run_in_background: false`), press `ctrl+b` at the prompt to hand it to the
@@ -167,8 +185,10 @@ Agent({ resume: "<id>", prompt: "Now check the tests too", description: "Continu
 - A worktree agent resumes in its worktree: it is restored at the same path from the agent's branch, and the new work
   is committed to that branch afterwards. If the branch is gone the resume is refused and nothing runs.
 - How long: a finished agent stays in memory for about ten minutes; after that it is reopened from its saved session
-  file, under the same id, for as long as that file exists. Sessions are saved by default (`rememberAgents`; turn it
-  off and agents are resumable only for those ten minutes).
+  file, under the same id, for as long as that file exists, and `get_subagent_result` reads its status, model and
+  final result from that file (marked as read from the saved session). Sessions are saved by default (`rememberAgents`;
+  turn it off and agents are resumable only for those ten minutes). The last 2000 such agents of a session stay
+  addressable, and 4000 nested and workflow children, at a few hundred bytes each.
 - What survives a restart, `/resume`, `/fork` or `/reload`: finished agents of that session (on its branch, for a fork)
   stay resumable by the model and by `@handle`. `/new` starts with none. Nested agents and workflow children are
   rebuilt too (their resume state is written to the parent session as `subagents:resume` entries, one small entry per
@@ -204,11 +224,20 @@ A subagent runs on the parent's current model at the parent's current thinking l
 tool, nested delegation, workflow `agent()`, `@mentions`, scheduled jobs and cross-extension RPC. For a nested agent the
 parent is the agent that spawned it.
 
-- An agent file's own `model:` or `thinking:` is your configuration and always applies.
+- An agent file's own `model:` or `thinking:` is your configuration and always applies. `model:` takes an exact
+  `provider/id`, or a short name such as `haiku`. Among a short name's closest matches, the parent's provider wins when
+  it serves one, and matches from one provider resolve to the tightest. A name whose matches span several other
+  providers, or that matches nothing, is not guessed at: the agent runs on the parent's model and its result starts
+  with a note naming the model asked for, why it was not used (with up to five candidates for an ambiguous name), and
+  the model used instead. Workflows show the note as a warning. Spawns that pass no model of their own (`@mentions`, RPC, scheduled
+  jobs) match the agent file's `model:` by exact `provider/id` only, and note a fallback the same way.
+- A model passed per call (with `allowModelOverride`) resolves the same way; one that is ambiguous across providers or
+  unknown is refused with the candidates.
 - Per-call choices are ignored by default: the `Agent` tool and the nested tool do not offer `model` or `thinking`,
   workflow `agent({ model, effort })` is ignored, and so are a scheduled job's and an RPC spawn's model and thinking
   level. This keeps the main model from picking cheaper models or lower effort on its own.
-- A resumed agent keeps the model and thinking level it ran with.
+- A resumed agent keeps the model and thinking level it ran with. Each run records the model and level it actually ran
+  with; the foreground result, `get_subagent_result` and the notification show them.
 - `allowModelOverride: true` (project or global `subagents.json`, or `/agents → Settings → Model override`) restores the
   per-call overrides and the tool parameters. The resolution changes at once; the tool parameters at the next session.
 

package/dist/agent-manager.d.ts

@@ -209,6 +209,8 @@ interface SpawnOptions {
     onBeforeWorktreeCleanup?: (worktreePath: string) => Promise<void>;
     /** Resolved invocation snapshot captured for UI display. */
     invocation?: AgentInvocation;
+    /** The caller's note that the agent file's model did not resolve (see `AgentRecord.modelNote`). */
+    modelNote?: string;
     /** Parent abort signal — when aborted, the subagent is also stopped. */
     signal?: AbortSignal;
     /**
@@ -712,11 +714,20 @@ export declare class AgentManager {
      */
     private tombstone;
     private keepTombstone;
+    /**
+     * Bound the memory a long session can accumulate, per kind (top-level or
+     * owned). Oldest first, since the agent someone still wants to reach is the
+     * one they used most recently. One counting pass; the sort runs only for a
+     * kind that is over its cap.
+     */
+    private trimTombstones;
     /**
      * Make agents of an earlier activation (before a restart, `/resume`,
      * `/fork` or `/reload`) resumable again, from what was persisted in the
      * parent session. Later entries for the same id win. A live record keeps
-     * precedence: it is the newer state of the same agent.
+     * precedence: it is the newer state of the same agent. Trimmed once at the
+     * end rather than per entry, so a session with thousands of entries restores
+     * in one pass.
      */
     restoreTombstones(states: readonly AgentResumeState[]): void;
     private cleanup;

package/dist/agent-manager.js

@@ -18,6 +18,7 @@ import { existsSync, statSync } from "node:fs";
 import { isAbsolute } from "node:path";
 import { resumeAgent, runAgent } from "./agent-runner.js";
 import { getAgentConfig } from "./agent-types.js";
+import { extractText } from "./context.js";
 import { assignHandle, handleBase } from "./mention.js";
 import { describeModel } from "./model-resolver.js";
 import { sessionFileProblem } from "./session-file.js";
@@ -64,16 +65,19 @@ const DEFAULT_MAX_CONCURRENT = 10;
  */
 const DEFAULT_MAX_CONCURRENT_FOREGROUND = 0;
 /**
- * How many evicted agents stay addressable by name. Only a bound on memory —
- * a session that spawns hundreds of agents shouldn't retain every one — and
- * far above the handful anyone keeps in their head.
+ * How many evicted agents stay addressable — by name, by resume, and by
+ * get_subagent_result, which reads a released agent's result from its saved
+ * session. Only a bound on memory: an entry is a few hundred bytes of ids and
+ * paths (about 450 B, 700 B with a worktree), never the conversation, so 2000
+ * cost about 1 MB. High because a session that spawns hundreds of agents
+ * should still be able to read the result of any of them.
  */
-const MAX_TOMBSTONES = 100;
+const MAX_TOMBSTONES = 2000;
 /**
  * The same bound for owned children — nested agents and workflow children —
  * counted apart, so a large workflow cannot push the session's own agents out.
  */
-const MAX_OWNED_TOMBSTONES = 200;
+const MAX_OWNED_TOMBSTONES = 4000;
 /**
  * Validate a caller-supplied SpawnOptions.cwd. `undefined`/`null` mean "unset"
  * (parent cwd). Anything else must be an absolute path to an existing
@@ -234,6 +238,72 @@ function worktreeNote(wtResult, baseCwd, customCwd) {
         lines.push(`- ${note}`);
     return lines.length > 0 ? `\n\n---\n${lines.join("\n")}` : "";
 }
+/** How many messages a session holds — where a run's own turns begin. 0 for a stub. */
+function messageCount(session) {
+    try {
+        return session?.messages?.length ?? 0;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * The last assistant text a session holds from message `start` on: what a run
+ * that threw or was abandoned had produced. Bounded like the runner's own
+ * fallback, so a failed resume never surfaces the previous run's answer
+ * (#144). "" for none, or for a session that cannot be read.
+ */
+function salvageText(session, start) {
+    try {
+        const messages = session?.messages ?? [];
+        for (let i = messages.length - 1; i >= start; i--) {
+            const msg = messages[i];
+            if (msg.role !== "assistant")
+                continue;
+            const text = extractText(msg.content).trim();
+            if (text)
+                return text;
+        }
+    }
+    catch { /* a disposed or partial session has nothing to give */ }
+    return "";
+}
+/** Keep what a failed run produced on its record, unless the run already reported text. */
+function salvagePartial(record, start) {
+    if (record.result?.trim())
+        return;
+    const text = salvageText(record.session, start);
+    if (text)
+        record.result = text;
+}
+/**
+ * Record the model and thinking level a run actually runs with, from its
+ * session. Both are only knowable once pi has resolved its defaults and clamped
+ * the level to what the model supports. Writing them back makes the record
+ * authoritative, so every surface (the widget, the notification, the result
+ * tools) reads one place instead of each re-deriving "session, else the
+ * request" for itself. Called at the start of every run, so a resumed run
+ * records its own.
+ */
+function recordRunModel(record, session) {
+    if (!session.model)
+        return;
+    record.invocation ??= {};
+    // Read the kept request first: a caller's level survives being clamped
+    // AND, one line later, being replaced by the effective one.
+    const requested = record.invocation.requestedThinking ?? record.invocation.thinking;
+    Object.assign(record.invocation, describeModel(session.model));
+    // Guarded: a session that reports no level keeps the request rather than
+    // losing it. Overwriting unconditionally would turn an older or stubbed
+    // session into a blank `thinking:` tag, which is worse than the
+    // stale-but-true value it replaced.
+    if (session.thinkingLevel) {
+        record.invocation.thinking = session.thinkingLevel;
+        if (requested && requested !== session.thinkingLevel) {
+            record.invocation.requestedThinking = requested;
+        }
+    }
+}
 /**
  * Whether a run is in flight or waiting for a slot. A function rather than an
  * inline test so TypeScript does not narrow `status` across an `await` that
@@ -276,6 +346,7 @@ export function resumeStateOf(record) {
         description: record.description,
         sessionFile: record.sessionFile,
         completedAt: record.completedAt ?? Date.now(),
+        status: record.status,
         handle: record.handle,
         alias: record.alias,
         parentAgentId: record.parentAgentId,
@@ -733,6 +804,7 @@ export class AgentManager {
             // `options` has stopped being the interesting object.
             blocking: options.blocking,
             invocation: options.invocation,
+            modelNote: options.modelNote,
             depth: options.depth ?? 1,
             parentAgentId: options.parentAgentId,
             workflowId: options.workflowId,
@@ -1012,6 +1084,9 @@ export class AgentManager {
             this.onStart?.(record);
         }
         catch { /* a start observer must not fail the run */ }
+        // Where this run's turns begin in its session: past the history of a
+        // reopened conversation. Set once the session exists.
+        let runStart = 0;
         // Wire parent abort signal to stop the subagent when the parent is interrupted.
         // A queued spawn can start minutes after the caller handed us its signal,
         // by which time it may already be aborted — and `addEventListener` would
@@ -1075,6 +1150,7 @@ export class AgentManager {
                     return;
                 }
                 record.session = session;
+                runStart = messageCount(session);
                 // Capture now, while the session object exists: after eviction this
                 // path is the only thing that can reopen the conversation, and an
                 // in-memory session reports undefined, which correctly means
@@ -1084,28 +1160,7 @@ export class AgentManager {
                 // stubbed session must degrade to "not resumable" rather than throw
                 // and take the whole spawn down with it.
                 record.sessionFile = session.sessionManager?.getSessionFile?.();
-                // Same reason, different field: the model and thinking level are only
-                // knowable once pi has resolved its defaults and clamped the level to
-                // what the model supports. Writing them back here makes the record
-                // authoritative, so every surface reads one place instead of each
-                // re-deriving "session, else the request" for itself.
-                if (session.model) {
-                    record.invocation ??= {};
-                    // Read the kept request first: a caller's level survives being clamped
-                    // AND, one line later, being replaced by the effective one.
-                    const requested = record.invocation.requestedThinking ?? record.invocation.thinking;
-                    Object.assign(record.invocation, describeModel(session.model));
-                    // Guarded for the reason above: a session that reports no level keeps
-                    // the request rather than losing it. Overwriting unconditionally would
-                    // turn an older or stubbed session into a blank `thinking:` tag, which
-                    // is worse than the stale-but-true value it replaced.
-                    if (session.thinkingLevel) {
-                        record.invocation.thinking = session.thinkingLevel;
-                        if (requested && requested !== session.thinkingLevel) {
-                            record.invocation.requestedThinking = requested;
-                        }
-                    }
-                }
+                recordRunModel(record, session);
                 // Flush any steers that arrived before the session was ready
                 if (record.pendingSteers?.length) {
                     for (const msg of record.pendingSteers) {
@@ -1121,12 +1176,13 @@ export class AgentManager {
                 catch { /* ignore caller wiring errors */ }
             },
         })
-            .then(async ({ responseText, session, aborted, steered, failure, structuredJson, structuredRetried, maxTurns }) => {
+            .then(async ({ responseText, session, aborted, steered, failure, structuredJson, structuredRetried, maxTurns, modelNote }) => {
             // Abandoned after a stop it ignored: the record was settled without
             // this run, and may already belong to a newer one.
             if (run.abandoned)
                 return responseText;
             record.maxTurns = maxTurns;
+            record.modelNote ??= modelNote;
             // Don't overwrite status if externally stopped via abort()
             if (record.status !== "stopped") {
                 // Precedence: a hard abort keeps "aborted"; then a failed final turn
@@ -1189,6 +1245,8 @@ export class AgentManager {
             }
             record.error = err instanceof Error ? err.message : String(err);
             record.completedAt ??= Date.now();
+            // A run that threw reported no text; keep what its turns produced.
+            salvagePartial(record, runStart);
             detach();
             // Final flush of streaming output file on error
             if (record.outputCleanup) {
@@ -1221,6 +1279,7 @@ export class AgentManager {
         // done, minus the result it never produced.
         run.onAbandon = async () => {
             detach();
+            salvagePartial(record, runStart);
             if (record.outputCleanup) {
                 try {
                     record.outputCleanup();
@@ -1539,6 +1598,8 @@ export class AgentManager {
         record.result = undefined;
         record.error = undefined;
         const session = record.session;
+        recordRunModel(record, session);
+        const runStart = messageCount(session);
         const abortController = new AbortController();
         record.abortController = abortController;
         const onParentAbort = () => this.abort(id);
@@ -1589,6 +1650,7 @@ export class AgentManager {
                     record.error = err instanceof Error ? err.message : String(err);
                 }
                 record.completedAt ??= Date.now();
+                salvagePartial(record, runStart);
             }
             signal?.removeEventListener("abort", onParentAbort);
             this.abortOwnedChildren(id);
@@ -1598,6 +1660,7 @@ export class AgentManager {
             return record.result ?? "";
         })();
         run.onAbandon = async () => {
+            salvagePartial(record, runStart);
             signal?.removeEventListener("abort", onParentAbort);
             this.abortOwnedChildren(id);
             await this.finishResumedWorktree(record);
@@ -1763,6 +1826,8 @@ export class AgentManager {
             return;
         record.status = "running";
         record.startedAt = Date.now();
+        const runStart = messageCount(record.session);
+        recordRunModel(record, record.session);
         const run = this.beginRun(id, record, occupiesPoolSlot(record) ? "background" : undefined);
         try {
             this.onStart?.(record);
@@ -1793,6 +1858,10 @@ export class AgentManager {
         const windDown = async () => {
             detachParentSignal?.();
             detachParentSignal = undefined;
+            // What a run that threw or was abandoned had produced; a settled run's
+            // own text is already on the record.
+            if (record.status === "error" || record.status === "stopped")
+                salvagePartial(record, runStart);
             // Final flush of streaming output file
             if (record.outputCleanup) {
                 try {
@@ -2033,26 +2102,36 @@ export class AgentManager {
     }
     keepTombstone(state) {
         this.tombstones.set(state.id, state);
-        // Bound the memory a long session can accumulate, per kind (top-level or
-        // owned). Oldest first, since the agent someone still wants to reach is the
-        // one they used most recently.
-        const topLevel = isTopLevelAgent(state);
-        const sameKind = [...this.tombstones.values()].filter(entry => isTopLevelAgent(entry) === topLevel);
-        let excess = sameKind.length - (topLevel ? MAX_TOMBSTONES : MAX_OWNED_TOMBSTONES);
-        if (excess <= 0)
-            return;
-        sameKind.sort((a, b) => a.completedAt - b.completedAt);
-        for (const entry of sameKind) {
-            if (excess-- <= 0)
-                break;
-            this.tombstones.delete(entry.id);
+        this.trimTombstones();
+    }
+    /**
+     * Bound the memory a long session can accumulate, per kind (top-level or
+     * owned). Oldest first, since the agent someone still wants to reach is the
+     * one they used most recently. One counting pass; the sort runs only for a
+     * kind that is over its cap.
+     */
+    trimTombstones() {
+        let topLevel = 0;
+        for (const entry of this.tombstones.values())
+            if (isTopLevelAgent(entry))
+                topLevel++;
+        const owned = this.tombstones.size - topLevel;
+        for (const [kindIsTopLevel, excessCount] of [[true, topLevel - MAX_TOMBSTONES], [false, owned - MAX_OWNED_TOMBSTONES]]) {
+            if (excessCount <= 0)
+                continue;
+            const sameKind = [...this.tombstones.values()].filter(entry => isTopLevelAgent(entry) === kindIsTopLevel);
+            sameKind.sort((a, b) => a.completedAt - b.completedAt);
+            for (const entry of sameKind.slice(0, excessCount))
+                this.tombstones.delete(entry.id);
         }
     }
     /**
      * Make agents of an earlier activation (before a restart, `/resume`,
      * `/fork` or `/reload`) resumable again, from what was persisted in the
      * parent session. Later entries for the same id win. A live record keeps
-     * precedence: it is the newer state of the same agent.
+     * precedence: it is the newer state of the same agent. Trimmed once at the
+     * end rather than per entry, so a session with thousands of entries restores
+     * in one pass.
      */
     restoreTombstones(states) {
         for (const state of states) {
@@ -2062,8 +2141,9 @@ export class AgentManager {
             const current = this.tombstones.get(state.id);
             if (current && current.completedAt > state.completedAt)
                 continue;
-            this.keepTombstone(state);
+            this.tombstones.set(state.id, state);
         }
+        this.trimTombstones();
     }
     cleanup() {
         const cutoff = Date.now() - 10 * 60_000;

package/dist/agent-runner.d.ts

@@ -359,6 +359,11 @@ export interface RunResult {
     structuredRetried?: boolean;
     /** The turn limit this run enforced (undefined = unlimited), for later resumes. */
     maxTurns?: number;
+    /**
+     * Set when the agent file's `model:` could not be used and the run fell back
+     * to the parent's model: the visible note for the record (`modelNote`).
+     */
+    modelNote?: string;
 }
 export declare function runAgent(ctx: ExtensionContext, type: SubagentType, prompt: string, options: RunOptions): Promise<RunResult>;
 /** Callbacks and limits for one run of prompts on a session (first run or resume). */

package/dist/agent-runner.js

@@ -11,6 +11,7 @@ import { buildParentContext, extractText } from "./context.js";
 import { DEFAULT_AGENTS } from "./default-agents.js";
 import { detectEnv } from "./env.js";
 import { buildMemoryBlock, buildReadOnlyMemoryBlock } from "./memory.js";
+import { unresolvedModelNote } from "./model-resolver.js";
 import { createNestedSubagentTools, getMaxSubagentDepth } from "./nested-tools.js";
 import { isProjectCodeTrusted, isProjectTrustedBy } from "./project-trust.js";
 import { buildAgentPrompt } from "./prompts.js";
@@ -909,6 +910,15 @@ export async function runAgent(ctx, type, prompt, options) {
     }
     // Resolve model: explicit option > config.model > parent model
     const model = options.model ?? resolveDefaultModel(parent.model, parent.modelRegistry, agentConfig?.model);
+    // Spawns that pass no model (mentions, RPC, the scheduler) resolve the agent
+    // file's here, by exact provider/id only. A pin that falls back to the parent
+    // still runs, but says so rather than passing the parent's model off as it.
+    const configModel = agentConfig?.model;
+    const configModelUnused = options.model === undefined && configModel !== undefined && model === parent.model
+        && !(model && `${model.provider}/${model.id}`.toLowerCase() === configModel.toLowerCase());
+    const modelNote = configModelUnused
+        ? unresolvedModelNote(configModel, "did not match an available model's exact provider/id", model ?? "the session's default model")
+        : undefined;
     // Omitting this SDK option uses saved settings, not the live parent's effort.
     // A reopened session keeps the level it ran with — saved in its file —
     // unless explicitly overridden: neither the parent's current level nor the
@@ -1148,6 +1158,7 @@ export async function runAgent(ctx, type, prompt, options) {
         steered: run.steered,
         failure: run.failure ?? structuredFailure,
         maxTurns,
+        ...(modelNote !== undefined ? { modelNote } : {}),
         ...(structuredCapture?.json !== undefined ? { structuredJson: structuredCapture.json } : {}),
         ...(structuredRetried ? { structuredRetried } : {}),
     };

package/dist/cross-extension-rpc.js

@@ -71,7 +71,7 @@ export function registerRpcHandlers(deps) {
         // means "inherit" — not an override to resolve or scope-check.
         const override = normalizedOptions.model;
         if (override != null) {
-            const { modelRegistry, cwd } = ctx;
+            const { modelRegistry, cwd, model: parentModel } = ctx;
             // Names the override the same way in both messages below; an object
             // override would otherwise interpolate as "[object Object]".
             const label = typeof override === "string" ? override : `${override.provider}/${override.id}`;
@@ -80,7 +80,7 @@ export function registerRpcHandlers(deps) {
             }
             let model = override;
             if (typeof override === "string") {
-                const resolved = resolveModel(override, modelRegistry);
+                const resolved = resolveModel(override, modelRegistry, parentModel?.provider);
                 if (typeof resolved === "string") {
                     // resolveModel returns a human-readable error string when the
                     // input doesn't match any available model. Surface it instead of

package/dist/index.d.ts

@@ -16,6 +16,13 @@ import { type Theme } from "./ui/agent-widget.js";
 import { FOREIGN_WORKFLOW_TOOL_NAMES } from "./workflow/collisions.js";
 import { WORKFLOW_ENTRY_TYPE, type WorkflowEntryData, workflowEntryData } from "./workflow/entry.js";
 export declare function renderRunningAgentStatus(frame: string, statsText: string, activity: string, theme: Pick<Theme, "fg">): Container;
+/**
+ * The head of a result for a notification: its first `maxLines` lines, cut at
+ * `maxLen` characters as well so one huge line cannot flood the parent's
+ * context. When anything is left out, a note says how much and where the rest
+ * is.
+ */
+export declare function previewResult(result: string, maxLen: number, maxLines: number): string;
 /**
  * The `pending` results among a session's entries that no later
  * `subagents:delivered` entry covers, in order, as record-shaped objects a