@sema-agent/core 7.0.0 → 7.0.1

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 7.0.1 — 2026-08-30
+
+### Added
+- **`task_progress.model` + `BackgroundChildEvent.model`** (#508①, cli [5725] item-B): every spawn-progress tick and background child event now carries the SERVED model id (PREPARED semantics — the id the child's prepare actually resolved, not the word the caller wrote). The fleet row publishes the same served id, so row/tick/card lanes state one fact; a replayed workflow leg reports the cached model on every face.
+- **`apiFailure` on the completed-agent details card and both notification lanes** (#506 residual): terminal API-failure evidence now reaches every reader of a settled child, not only the host-face `TaskResult`.
+
+### Changed — narrowing (named)
+- **Unknown/empty delegation `model` argument: soft note → typed reject** (#508②, CC $L closed-set anchored): `model.unknown` (echoes the accepted catalog) and `model.empty` replace the old accept-with-note behavior. A caller that previously leaned on the note-and-serve-default path now gets a refusal naming the legal values. Positive control: every cataloged id serves exactly as before. **Two lanes are exempt** (pre-ship rescan, the caller-census duty): the tier-3 revival lane feeds the durable row's MACHINE-minted recorded word back through this gate, so it keeps the soft-degrade (loud `modelNote` + inherited model — a catalog rotation must not permanently strand a named teammate and its queued mail), and its fallback chain skips string candidates the live catalog cannot resolve (a degrade that re-selects the retired word would revive a child dead on arrival); `subagent_type: "fork"` keeps the schema's own "model is ignored" promise for the empty string exactly as for any other word. Membership itself hardened: the catalog read is own-property (`Object.hasOwn`), so `Object.prototype` words (`constructor`, `toString`, …) refuse as `model.unknown` instead of passing the gate and crashing the child.
+- **Per-call model binding is resolved AT the gate** (rescan): a judged per-call word now rides the child spec as the resolved `Model` object, so the judged roster is the authoritative binding — an explicit `opts.models` table naming a key the runner's own catalog lacks now serves on the judged binding instead of passing the gate and dying inside the child's prepare. `BackgroundChildEvent.model` / roster-row docs restated to the served-id-first rule (display label is the unresolvable-ref fallback only); the residual one-generation lag window for definition/tool-level string refs after `swapModels` is documented, not claimed away. The background roster record gains optional `modelFallback` (additive; fork lane already carried it).
+- **File-history mode domain, both doors** (security): the import door refuses a version-row mode that is not an integer in [0, 0o7777] and refuses set-ID modes (setuid/setgid) BY NAME; on replay, `applyRecordedMode` STRIPS the set-ID bits and applies the remainder (`mode & 0o1777`, sticky preserved) under the loud `modeNotPreserved` account — set-ID bits never reach chmod (capture may legitimately record one; replay is where the escalation lives). A file already at exactly the recorded mode answers `unchanged` with no account (the equality fast path precedes the escalation arm), and `previewFileDelta` compares against what replay would actually apply, so a set-ID-recorded drift converges instead of being promised forever.
+
+### Changed — widening (named)
+- **The delegation tool's model roster is read at JUDGEMENT time, not frozen at mount** (#508 residual): after `Runner.swapModels`, a long-lived mount no longer hard-rejects the models the deployment just started serving (the old refusal echoed the RETIRED generation as the accepted values). Explicit `opts.models` keeps snapshot semantics; only the runner-derived roster re-reads live. The schema/announce projection remains a mount-time snapshot — the refusal therefore carries its own accepted-values echo.
+
+### Fixed
+- Flaky-guard ledger: the three new pin files registered as bounded effect-polling (gate was red since the #508 batch landed).
+
+### Docs
+- #509 core half: the subagent transcript LANDING law (three store shapes + the CC 2.1.250 unconditional-landing anchor) spelled out at `SubagentToolOptions.runner`, the background placement mint gate, and `resolveSubagentTranscriptTier`; reproduced-and-located, wiring fix owned by the delegation runner's store choice.
+- 6.0.0 release-criteria acceptance corrections (test [5719]/[5721]): G1.a added-count 65→77, F7 absent-seat claim restated.
+
 ## 7.0.0 — 2026-08-30
 
 > Ships as its own major immediately after 6.0.0 (ruled: the three-dimensional rule scope travels alone so downstream adapts to it in isolation). The 6.0.0 artifact is this same tree with the design/382 P1 surface excised whole (type-driven surgery in an isolated worktree, tag v6.0.0); `npm run handoff:diff v6.0.0 v7.0.0` reproduces exactly this surface.

package/dist/agents/launch-receipt-contract.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The HANDLING contract shared by every tool that launches background work and hands the model a
+ * receipt: the Agent tool's async-launch card and `run_workflow`'s backgrounded launch receipt.
+ *
+ * Why a module rather than two copies. Both receipts state the same two things — "these bytes are
+ * plumbing, do not paste them at the user" and "say what you launched in your own words" — and they
+ * had drifted into two wordings of it (`; ` vs ` — `, "this result" vs "this tool result"). Neither
+ * difference carried meaning; each was just the copy that happened to be typed second. A model reading
+ * one receipt and a model reading the other should be reading the same instruction, and a later edit
+ * to one of them should not be able to leave the other behind.
+ *
+ * What deliberately stays PER-LANE (the earlier ruling, narrowed rather than reversed): each receipt
+ * hands back different artifacts, so each names its own. The Agent card names `task_id`; the workflow
+ * receipt names the ids plus the host filesystem `scriptPath` it may have written. That enumeration is
+ * a fact about the lane and cannot be centralized without one of them lying. So the SCOPE clause is the
+ * caller's, and the sentence around it is this module's. Likewise the envelopes stay as they were —
+ * the Agent lane renders prose, the workflow lane a JSON field — which is why these are string parts
+ * rather than a rendered receipt.
+ */
+/**
+ * The no-quote clause for one lane. `artifactScope` is the caller's own enumeration of what "any part
+ * of it" covers, spliced in verbatim INCLUDING its leading separator — a comma clause
+ * (`", including the task_id below,"`) and a parenthetical (`" (the ids above, and scriptPath when
+ * present)"`) punctuate differently and the caller owns which it uses. Pass `""` for a lane with
+ * nothing to enumerate; the sentence still reads.
+ */
+export declare function launchReceiptNoQuoteClause(artifactScope: string): string;
+/**
+ * The closing instruction, whole and identical on every launch lane: report the launch in the model's
+ * own words instead of echoing the receipt. Callers append their own lane-specific continuation (how
+ * the result will or will not arrive) after a single space; this clause is a complete sentence on its
+ * own so a lane with nothing to add can use it unchanged.
+ */
+export declare const LAUNCH_RECEIPT_OWN_WORDS_CLAUSE = "In your own words, briefly tell the user what you launched \u2014 do not echo this tool result.";

package/dist/agents/launch-receipt-contract.js

@@ -0,0 +1,5 @@
+const NO_QUOTE_HEAD = "This tool result is internal metadata — never quote or paste any part of it";
+export function launchReceiptNoQuoteClause(artifactScope) {
+    return `${NO_QUOTE_HEAD}${artifactScope} into a user-facing reply.`;
+}
+export const LAUNCH_RECEIPT_OWN_WORDS_CLAUSE = "In your own words, briefly tell the user what you launched — do not echo this tool result.";

package/dist/agents/subagent.d.ts

@@ -4,6 +4,60 @@ import { type ExecutionEnv } from "../internal/harness.js";
 import type { RunInternals } from "../core/runner/prepare-task.js";
 import type { TaskNotificationPayload } from "../core/task-notification.js";
 import { RETAIN_DEFAULT_TTL_MS, RETAIN_DEFAULT_MAX } from "../config/defaults.js";
+/**
+ * #505 residual — the two GRANULARITY facts a delegation's terminal `usage` was missing beside
+ * tokens/turns/cost, closing a real reporting asymmetry rather than adding decoration: the workflow
+ * lane's completion notification has published `tool_uses` (summed `stats.toolCalls`) and `duration_ms`
+ * (wall clock) since it was written, and the Agent tool's own SYNC report publishes both in its
+ * `<usage>` footer — only the delegation TERMINAL faces (the background/fork/revive notification and its
+ * observer twin) reported neither, so the same child answered "how much work, how long" on one lane and
+ * refused on the other.
+ *
+ * PROVENANCE is the workflow lane's — `stats.toolCalls`, the RUN's own count — because that is the
+ * quantity the other side of the comparison publishes, and because it is available on every terminal
+ * lane, including the revive lane, which has no parent-side forwarding observer at all.
+ *
+ * WHAT THIS DOES NOT CLOSE, stated because the honest scope is narrower than "one name, one meaning":
+ * the Agent tool's SYNC `<usage>` footer keeps its own `tool_uses`, counted by the parent-side
+ * `toolStatsCounter`, and the two numbers differ in BOTH directions for the same child — that counter
+ * EXCLUDES the delegation tool's own calls and INCLUDES descendants' (CC's nested fold), while
+ * `stats.toolCalls` counts the direct child's calls and counts its delegations among them. A child that
+ * itself delegates therefore reports two different `tool_uses` depending on whether it was run
+ * synchronously or in the background. That footer is a byte-pinned CC-anchored face; reconciling the
+ * two is a separate ruling, and until it is made this comment is the place the divergence is written
+ * down rather than a claim that it is gone.
+ *
+ * Knownness follows `delegatedCostField`'s rule exactly: `toolCalls` is optional on the stats face
+ * ("undefined means the gateway reported no usage", and a checkpointed resume folds it per-leg), so the
+ * key is ABSENT rather than zeroed — a fabricated 0 reads as "ran no tools", which is a claim, not a
+ * gap. Duration is always knowable (the caller holds the lane's launch instant), so it is unconditional.
+ *
+ * TWO SPELLINGS, one meaning, matching each face's established vocabulary: the observer
+ * ({@link import("../core/types.js").BackgroundChildEvent}) `usage` face is camelCase and already
+ * DECLARES `toolUses`/`durationMs`; the model-facing `TaskNotificationPayload.usage` is rendered into
+ * `<usage>` as JSON where the workflow lane and the Agent sync footer both spell them snake_case. No new
+ * word is minted on either side.
+ *
+ * Exported at MODULE level (not from the package index — the same posture as `completedAgentCard` and
+ * `classifySubagentError`, and for the same reason): the ABSENT arm is the point of the knownness rule
+ * and it is not reachable through a real child. This engine's runner initializes `stats.toolCalls` to a
+ * number on every path, so only a `TaskResult` from elsewhere — a foreign runner, an older checkpoint —
+ * can carry the optional-and-missing shape the stats face declares. A pin that only ever sees a live
+ * child cannot tell "absent" apart from "zero", which is precisely the confusion being prevented.
+ */
+export declare function delegatedGranularityFields(stats: {
+    toolCalls?: number;
+}, elapsedMs: number): {
+    toolUses?: number;
+    durationMs: number;
+};
+/** {@link delegatedGranularityFields}'s snake_case twin for the model-facing notification `usage`. */
+export declare function delegatedGranularityFieldsWire(stats: {
+    toolCalls?: number;
+}, elapsedMs: number): {
+    tool_uses?: number;
+    duration_ms: number;
+};
 export { RETAIN_DEFAULT_TTL_MS, RETAIN_DEFAULT_MAX };
 import { SubagentRetainLedger } from "./retain-ledger.js";
 import { type PeerSelfRef } from "./peer-admission.js";
@@ -268,6 +322,17 @@ export declare function completedAgentCard(child: {
     blockedReason?: string;
     errorMessage?: string;
     errorCode?: string;
+    /** The child run's provider-boundary fault assertion, verbatim from its `TaskResult.apiFailure`.
+     *  PRESENCE is the claim ("this child's terminal failure came from the transport/provider, not from
+     *  this deployment refusing to send, a limit, or unusable model output"); the members are whatever
+     *  the failing attempt stated about itself (`status` when the provider answered with one, `requestId`
+     *  when it named one). An EMPTY object is therefore meaningful and must not be normalized away: it
+     *  says "provider fault, unlabelled", which is a different statement from absence ("not a provider
+     *  fault"). Absent on every non-provider terminal and on every completed child. */
+    apiFailure?: {
+        status?: number;
+        requestId?: string;
+    };
     retryAfterMs?: number;
     degraded?: unknown;
     structuredOutput?: unknown;
@@ -514,9 +579,61 @@ export declare function delegationEntryLedgerFootprint(registry: object): {
  * catalog) after mounting must REBUILD the ToolSpec — call `createSubagentTool` again with the fresh
  * roster and serve the new tool — for the change to take effect; already-running tasks keep the roster
  * they were prepared with.
+ *
+ * The MODEL roster ({@link SubagentToolOptions.models}) deliberately does NOT follow that rule when it
+ * is left to the runner: a hot-swapped catalog is a first-class runner verb (`Runner.swapModels`) with
+ * no rebuild step, so the tool re-reads it at each judgement instead of requiring a remount. Only the
+ * schema/announce projection of it stays a mount-time snapshot (cache-prefix stability). Passing
+ * `models` explicitly opts back into snapshot semantics for that table — see the field.
  */
 export interface SubagentToolOptions {
-    /** Runner used to execute child tasks. */
+    /**
+     * Runner used to execute child tasks.
+     *
+     * **This runner's session store decides where a child TRANSCRIPT lives — and therefore whether one
+     * exists at all after the fact.** A SYNC or BACKGROUND child mints its session through
+     * `runner.sessions`, never through the parent leg's store, so a deployment that mounts the Agent
+     * tool on a DIFFERENT runner than the one serving root tasks has split the transcript lane away
+     * from the session lane. (The FORK lane is the deliberate exception and shows the split is a known
+     * shape: a fork branches the CALLER's session through `ctx.hostSessionFork` — the host Runner's
+     * own store — precisely because `runner` may be a split child-execution runner whose store never
+     * held the source. A fork child therefore follows the HOST store's fate, an ordinary child this
+     * runner's, and the same deployment can land one on disk and lose the other.) Three shapes for the
+     * ordinary lanes, all reachable and all silent:
+     *  - durable store on THIS runner whose `release` PRESERVES history (`evict:"forget"`, the
+     *    `FileStorageBackend` default), no {@link SubagentToolOptions.background}.`agentStore` — the
+     *    child transcript lands UNPLACED and survives the settle leg's eager release (a cache drop),
+     *    so post-hoc forensics work even though nothing can ADDRESS it through an `a*` handle. The
+     *    qualifier is load-bearing, not decorative: durability and release semantics are INDEPENDENT
+     *    declarations, and a store that declares itself durable while deleting on release
+     *    (`new FileStorageBackend({ evict: "delete" })`, or any custom store with the same policy)
+     *    destroys the transcript at settle — the settle leg calls `release`, and there is no placement
+     *    to make the deletion refuse. "Durable" is a statement about restarts, never about release;
+     *  - durable store + `agentStore` — the placed partition (see the mint gate in the background
+     *    lane): addressable across a restart, list-excluded, joint-reaped with its row. This arm is
+     *    also the one immune to the evict policy above (the settle leg keeps a confirmed row's
+     *    transcript instead of releasing it);
+     *  - transient/process-local store on THIS runner (e.g. a throwaway sub-task store, or a routing
+     *    store that sends ordinary child acquires to a private cache) — the child transcript NEVER
+     *    reaches disk whatever the root leg's store is. Nothing in the engine compensates: the
+     *    completion notification's recent steps and the in-memory registry are the only readers, and
+     *    both die with the process.
+     * The asymmetry this produces is worth naming, because it reads as a bug from the outside: the
+     * `run_workflow` tool is mounted by the ENGINE on the run's own runner (prepare-task's
+     * `runnerSelf`), so a workflow node's child session always follows the ROOT store, while this tool
+     * is mounted by the DEPLOYMENT and follows whatever runner it was handed. One data root can
+     * therefore hold every workflow node's transcript and none of the Agent tool's.
+     * There is deliberately NO manifest field that answers "does a child transcript reach disk here":
+     * `WiringManifest.fleet.subagentTranscripts` is the ADDRESSABILITY tier and folds to `"none"` on
+     * the absent-row-store arm before it ever looks at a session store, so it cannot separate the
+     * first shape above from the third (the landing pins carry that as an explicit arm). The facts
+     * that DO answer it are this runner's store's own declarations — `sessions.durability` and its
+     * release/evict policy — read together, which is why they are named here rather than folded into
+     * a word. Upstream anchor (CC 2.1.250): a sub-agent transcript is written unconditionally to
+     * its own file beside the parent session (`projects/<projectKey>/<sessionId>/subagents/agent-<id>
+     * .jsonl` + a `.meta.json` sidecar), so "the child conversation is readable afterwards" is a
+     * property CC never makes conditional on a store tier.
+     */
     runner: Runner;
     /**
      * design/115 P3 — background sub-agents (CC `run_in_background`). When set, the tool exposes the
@@ -599,7 +716,22 @@ export interface SubagentToolOptions {
      * wins — fork-shadowing precedent).
      */
     builtinAgents?: boolean;
-    /** Model catalog, used ONLY to validate an agent's string `model` ref at assembly time (fail-fast). */
+    /**
+     * Model catalog the tool validates model words against — an agent definition's string `model` ref at
+     * assembly time (fail-fast), and the per-call `model` argument at call time.
+     *
+     * OMITTED is the normal deployment shape: the tool then reads the runner's CURRENT catalog
+     * (`Runner.agentCatalog.models`) at each of those moments, so a catalog hot-swapped after mount is
+     * the one a delegation is judged against. Passing this explicitly is a deliberate NARROWING and
+     * pins the tool to exactly this table for the tool's whole life — the runner's generation changes
+     * no longer reach it. And this table is AUTHORITATIVE for the per-call word, not merely advisory:
+     * a word judged against it leaves the gate as this table's resolved `Model` object and the child
+     * runs that binding — including a key the runner's own catalog does not carry, and including a
+     * same-name key the runner binds differently. (The judged-then-re-resolved split this replaced
+     * admitted such words and then killed the child inside its own prepare, or ran a binding the spawn
+     * frame never named.) A definition's string `model` ref is different: it is validated here at
+     * assembly time but still resolves at the child's own prepare through the runner's live table.
+     */
     models?: Record<string, Model>;
     /** Tools available to the child (a deliberately narrowed subset). */
     tools?: ToolSpec[];

package/dist/agents/subagent.js

@@ -37,10 +37,27 @@ function delegatedCostField(stats) {
     const total = rollupDelegatedCost(stats, stats.nested);
     return total !== undefined ? { costMicroUsd: total } : {};
 }
+export function delegatedGranularityFields(stats, elapsedMs) {
+    return { ...(stats.toolCalls !== undefined ? { toolUses: stats.toolCalls } : {}), durationMs: elapsedMs };
+}
+function providerFaultField(child) {
+    if (child.apiFailure === undefined)
+        return {};
+    return {
+        apiFailure: {
+            ...(typeof child.apiFailure.status === "number" ? { status: child.apiFailure.status } : {}),
+            ...(typeof child.apiFailure.requestId === "string" ? { requestId: child.apiFailure.requestId } : {}),
+        },
+    };
+}
+export function delegatedGranularityFieldsWire(stats, elapsedMs) {
+    return { ...(stats.toolCalls !== undefined ? { tool_uses: stats.toolCalls } : {}), duration_ms: elapsedMs };
+}
 export { RETAIN_DEFAULT_TTL_MS, RETAIN_DEFAULT_MAX };
 import { SUBAGENT_RESUME_CAP, SubagentRetainLedger, getOrCreateSessionRetainLedger, ensureSessionReapHook, createResumePrompt, } from "./retain-ledger.js";
 import { createPeerInboundChainRef, createPeerSelfRef } from "./peer-admission.js";
 import { recordRosterSpawn } from "./roster-store.js";
+import { LAUNCH_RECEIPT_OWN_WORDS_CLAUSE, launchReceiptNoQuoteClause } from "./launch-receipt-contract.js";
 import { ObserverDigestTap, ObserverPairing, createObserverReportToolSpec, markObserverTaskId, unmarkObserverTaskId, isObserverTaskId, ObserverResumeStateError, ObserverStoppedByUserError, observerFramingPrompt, observerSlug, resolveObserverDeclaration, } from "./observer.js";
 import { SubagentStepRecorder } from "./subagent-steps.js";
 const BG_AGENT_RESULT_MAX = 4_000;
@@ -326,6 +343,7 @@ function resumabilityClaim(f) {
 const BG_AGENT_COLLATERAL_REAP_REASON = "its parent run ended";
 const RESERVED_AGENT_NAMES = new Set([OUTPUT_TOOL_NAME, TOOL_SEARCH_NAME, OFFLOAD_TOOL_NAME, REPORT_BLOCKED_TOOL_NAME, DEFAULT_SUBAGENT_TOOL_NAME]);
 export const REPORT_FIELD_MAX = 300;
+const ROSTER_ECHO_MAX = 400;
 function configError(message, code) {
     const e = new Error(message);
     e.code = code;
@@ -364,6 +382,7 @@ export function completedAgentCard(child, extras) {
         ...(child.blockedReason !== undefined ? { blockedReason: child.blockedReason } : {}),
         ...(child.errorMessage !== undefined ? { errorMessage: child.errorMessage } : {}),
         ...(child.errorCode !== undefined ? { errorCode: child.errorCode } : {}),
+        ...providerFaultField(child),
         ...(child.retryAfterMs !== undefined ? { retryAfterMs: child.retryAfterMs } : {}),
         ...(child.degraded !== undefined ? { degraded: child.degraded } : {}),
         ...(extras.handbackWarning !== undefined ? { handbackWarning: extras.handbackWarning } : {}),
@@ -711,9 +730,10 @@ export function createSubagentResume(deps) {
                 const completionIdRevive = deps.registry?.getCompletionId(deps.taskId ?? "");
                 const reviveName = deps.rowDescription ?? `sub-agent ${marker}`;
                 const failReasonRevive = status === "failed" ? child.errorMessage : undefined;
+                const reviveElapsedMs = Date.now() - reviveStartedAt;
                 const reviveTerminalSummary = failReasonRevive !== undefined
-                    ? `Agent "${reviveName}" (resumed) failed: ${failReasonRevive}${ccElapsedTag(Date.now() - reviveStartedAt)}`.slice(0, 300) + errorKindClause(errClassRevive)
-                    : `Agent "${reviveName}" (resumed) ${status === "killed" ? "stopped" : child.status === "completed" ? "finished" : String(child.status)}${ccElapsedTag(Date.now() - reviveStartedAt)}`;
+                    ? `Agent "${reviveName}" (resumed) failed: ${failReasonRevive}${ccElapsedTag(reviveElapsedMs)}`.slice(0, 300) + errorKindClause(errClassRevive)
+                    : `Agent "${reviveName}" (resumed) ${status === "killed" ? "stopped" : child.status === "completed" ? "finished" : String(child.status)}${ccElapsedTag(reviveElapsedMs)}`;
                 const reviveDurableProbe = deps.registry !== undefined && deps.taskId !== undefined ? deps.registry.durableAgentRowProbe(deps.taskId) : undefined;
                 const reviveDurableRow = reviveDurableProbe !== undefined ? await reviveDurableProbe().catch(() => false) : false;
                 const resumableRevive = resumabilityClaim({
@@ -739,7 +759,7 @@ export function createSubagentResume(deps) {
                         summary: reviveTerminalSummary,
                         ...resumeResidual(),
                         resumable: resumableRevive,
-                        usage: { tokens: child.stats.tokens, turns: child.stats.turns, ...delegatedCostField(child.stats) },
+                        usage: { tokens: child.stats.tokens, turns: child.stats.turns, ...delegatedCostField(child.stats), ...delegatedGranularityFields(child.stats, reviveElapsedMs) },
                         ...(completionIdRevive !== undefined ? { completionId: completionIdRevive } : {}),
                     });
                 const resumeFrame = {
@@ -753,11 +773,12 @@ export function createSubagentResume(deps) {
                     summary: reviveTerminalSummary,
                     ...(failReasonRevive !== undefined ? { error: failReasonRevive.slice(0, REPORT_FIELD_MAX) } : {}),
                     ...(status === "failed" && errCodeRevive !== undefined ? { errorCode: errCodeRevive } : {}),
+                    ...providerFaultField(child),
                     ...(resumeHandbackResult ? { result: notifyResultField(resumeHandbackResult) } : {}),
                     ...(status === "killed" && child.result ? { partial: true } : {}),
                     ...resumeResidual(),
                     resumable: resumableRevive,
-                    usage: { tokens: child.stats.tokens, turns: child.stats.turns, ...delegatedCostField(child.stats) },
+                    usage: { tokens: child.stats.tokens, turns: child.stats.turns, ...delegatedCostField(child.stats), ...delegatedGranularityFieldsWire(child.stats, reviveElapsedMs) },
                     ...(completionIdRevive !== undefined ? { completionId: completionIdRevive } : {}),
                 };
                 const gateOwner = ownsTerminalFacesRevive && status === "completed" && deps.notify !== undefined && deps.registry !== undefined && ledger.get(deps.parentToolCallId) === entry
@@ -1206,7 +1227,7 @@ export function forkWorktreeTranslationNote(parentCwd, worktreeDir) {
 export function asyncLaunchedReceipt(p) {
     const noteLines = (p.notes ?? []).filter((n) => n !== undefined && n !== "");
     const oneShotBlocked = p.notify && p.oneShot === true;
-    return (`Async agent launched successfully. (This tool result is internal metadata — never quote or paste any part of it, including the task_id below, into a user-facing reply.)\n` +
+    return (`Async agent launched successfully. (${launchReceiptNoQuoteClause(", including the task_id below,")})\n` +
         `task_id: ${p.taskId} (internal ID - do not mention to user. Use SendMessage with to: '${p.taskId}', summary: '<5-10 word recap>' to continue this agent.)\n` +
         (oneShotBlocked
             ? `${p.workingLine} This is a ONE-SHOT submission — there is no later turn for a background notification to land in, so do NOT end your turn expecting one. Actively wait instead: TaskOutput(task_id: "${p.taskId}", block: true). If it is still running after the wait, wait again (bounded) rather than ending the turn, or write out your best available answer now if you are near your own time budget.\n`
@@ -1215,10 +1236,18 @@ export function asyncLaunchedReceipt(p) {
                 : `${p.workingLine} Its result is NOT pushed automatically — retrieve progress and results with TaskOutput(task_id) where mounted.\n`) +
         noteLines.map((n) => `${n}\n`).join("") +
         (oneShotBlocked
-            ? `In your own words, briefly tell the user what you launched — do not echo this tool result. Do not assume a later message will deliver the result: this submission ends after this turn, so retrieve it now with the blocking TaskOutput wait above before writing your final answer.`
+            ? `${LAUNCH_RECEIPT_OWN_WORDS_CLAUSE} Do not assume a later message will deliver the result: this submission ends after this turn, so retrieve it now with the blocking TaskOutput wait above before writing your final answer.`
             : p.notify
-                ? `In your own words, briefly tell the user what you launched — do not echo this tool result. Agent results will arrive in a subsequent message. If the user asks for progress, say the agent is still running.`
-                : `In your own words, briefly tell the user what you launched — do not echo this tool result. The result will NOT arrive on its own — retrieve it with TaskOutput(task_id) where mounted before relying on it.`));
+                ? `${LAUNCH_RECEIPT_OWN_WORDS_CLAUSE} Agent results will arrive in a subsequent message. If the user asks for progress, say the agent is still running.`
+                : `${LAUNCH_RECEIPT_OWN_WORDS_CLAUSE} The result will NOT arrive on its own — retrieve it with TaskOutput(task_id) where mounted before relying on it.`));
+}
+function runnerModelCatalog(runner) {
+    try {
+        return runner?.agentCatalog?.models;
+    }
+    catch {
+        return undefined;
+    }
 }
 export function createSubagentTool(opts) {
     const catalog = opts.runner.agentCatalog;
@@ -1227,8 +1256,7 @@ export function createSubagentTool(opts) {
     if (opts.builtinAgents === undefined && catalog?.builtinAgents !== undefined) {
         opts = { ...opts, builtinAgents: catalog.builtinAgents };
     }
-    if (opts.models === undefined && catalog?.models)
-        opts = { ...opts, models: catalog.models };
+    const assemblyModels = opts.models ?? catalog?.models;
     if (opts.agents?.length) {
         opts = {
             ...opts,
@@ -1252,7 +1280,7 @@ export function createSubagentTool(opts) {
             }
             if (typeof a.model === "string") {
                 try {
-                    resolveModel(a.model, opts.models);
+                    resolveModel(a.model, assemblyModels);
                 }
                 catch {
                     throw configError(`createSubagentTool: agent "${a.name}" references unknown model "${a.model}" (pass \`models\` to resolve string refs).`, "config.agent.unknown_model");
@@ -1308,7 +1336,9 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
         ...(forkOffered ? [FORK_SUBAGENT_TYPE] : []),
         ...(generalPurposeShadowed ? [] : [GENERAL_PURPOSE_SUBAGENT_TYPE]),
     ];
-    const rosterNames = opts.models ? Object.keys(opts.models) : undefined;
+    const activeModels = () => opts.models ?? runnerModelCatalog(opts.runner);
+    const mountModels = activeModels();
+    const rosterNames = mountModels ? Object.keys(mountModels) : undefined;
     const agentListing = [
         ...(generalPurposeShadowed
             ? []
@@ -1424,7 +1454,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
             })),
             model: Type.Optional(Type.String({
                 description: rosterNames !== undefined && rosterNames.length > 0
-                    ? `Optional model override for this agent. Takes precedence over the agent definition's model. If omitted, uses the agent definition's model, or inherits from the parent. Ignored for subagent_type: "${FORK_SUBAGENT_TYPE}" — forks always inherit the parent model.`
+                    ? `Optional model override for this agent. Takes precedence over the agent definition's model. If omitted, uses the agent definition's model, or inherits from the parent. A value outside this deployment's model catalog is REFUSED — the call does not fall back silently. Ignored for subagent_type: "${FORK_SUBAGENT_TYPE}" — forks always inherit the parent model.`
                     : `Optional model override request. No model catalog is configured here, so a requested name cannot be resolved — the agent runs its definition's model (or inherits from the parent) and the result notes the override was not applied. Ignored for subagent_type: "${FORK_SUBAGENT_TYPE}".`,
             })),
             isolation: Type.Optional(Type.Literal("worktree", {
@@ -1560,23 +1590,54 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                     };
                 }
             }
+            if (typeof a.model === "string" && a.model.trim() === "" && !wantsFork && reviveClaim === undefined) {
+                return {
+                    isError: true,
+                    content: "Sub-agent not started: `model` was empty. Name a model from this deployment's catalog, or omit the parameter to run the agent type's own model.",
+                    details: { error: "model.empty" },
+                };
+            }
             const requestedModel = typeof a.model === "string" && a.model.trim() !== "" ? a.model.trim() : undefined;
             let perCallModel;
             let modelNote;
-            if (requestedModel !== undefined) {
+            const judgedModels = activeModels();
+            const rosterKeys = judgedModels !== undefined ? Object.keys(judgedModels) : [];
+            if (typeof a.model === "string" && requestedModel === undefined) {
+                modelNote = wantsFork
+                    ? `note: model "" was ignored — a fork always runs on the caller's model.`
+                    : `note: the durable record's model was blank and was NOT applied — the revived agent ran on its default (inherited) model.`;
+            }
+            else if (requestedModel !== undefined) {
                 if (wantsFork) {
                     modelNote = `note: model "${requestedModel}" was ignored — a fork always runs on the caller's model.`;
                 }
-                else if (!opts.models) {
+                else if (rosterKeys.length === 0) {
                     modelNote = `note: model "${requestedModel}" was NOT applied — this delegation tool has no model roster configured; the sub-agent ran on its default (inherited) model.`;
                 }
                 else {
                     try {
-                        resolveModel(requestedModel, opts.models);
-                        perCallModel = requestedModel;
+                        perCallModel = resolveModel(requestedModel, judgedModels);
                     }
                     catch {
-                        modelNote = `note: model "${requestedModel}" was NOT applied — unknown model (roster: ${Object.keys(opts.models).join(", ")}); the sub-agent ran on its default (inherited) model.`;
+                        if (reviveClaim !== undefined) {
+                            modelNote = `note: recorded model "${inlineUntrusted(requestedModel, 80)}" is not on the current model roster and was NOT applied — the revived agent ran on its default (inherited) model.`;
+                        }
+                        else {
+                            const shown = [];
+                            let budget = ROSTER_ECHO_MAX;
+                            for (const k of rosterKeys) {
+                                if (budget - k.length < 0)
+                                    break;
+                                shown.push(k);
+                                budget -= k.length + 2;
+                            }
+                            const rosterEcho = shown.length === rosterKeys.length ? shown.join(", ") : `${shown.join(", ")}, … (${rosterKeys.length - shown.length} more)`;
+                            return {
+                                isError: true,
+                                content: `Sub-agent not started: unknown model "${inlineUntrusted(requestedModel, 80)}". Available model values: ${inlineUntrusted(rosterEcho, ROSTER_ECHO_MAX + 32)}. Omit \`model\` to run the agent type's own model, or inherit the caller's.`,
+                                details: { error: "model.unknown" },
+                            };
+                        }
                     }
                 }
             }
@@ -1690,9 +1751,39 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
             const childTools = def
                 ? resolveToolSubset(childPool, def.allowTools, def.denyTools)
                 : resolveToolSubset(childPool, opts.allowTools, opts.denyTools);
-            const childModel = wantsFork
+            let childModel = wantsFork
                 ? ctx.model ?? opts.model
                 : perCallModel ?? (def ? (def.model ?? ctx.model ?? opts.model) : opts.model);
+            if (reviveClaim !== undefined && typeof childModel === "string") {
+                const resolvable = (ref) => {
+                    try {
+                        resolveModel(ref, runnerModelCatalog(opts.runner));
+                        return true;
+                    }
+                    catch {
+                        return false;
+                    }
+                };
+                if (!resolvable(childModel)) {
+                    const dead = childModel;
+                    const rest = def !== undefined ? [ctx.model, opts.model] : [opts.model];
+                    childModel = rest.find((c) => c !== undefined && (typeof c !== "string" || resolvable(c)));
+                    if (modelNote === undefined) {
+                        modelNote = `note: model "${inlineUntrusted(dead, 80)}" from this agent type's configuration is not on the current model roster and was NOT applied — the revived agent ran on its default (inherited) model.`;
+                    }
+                }
+            }
+            const spawnModel = typeof childModel === "string"
+                ? (() => {
+                    try {
+                        return resolveModel(childModel, judgedModels).id;
+                    }
+                    catch {
+                        return resolveModelDisplayLabel(childModel);
+                    }
+                })()
+                : childModel?.id;
+            const rowModelKey = perCallModel !== undefined ? requestedModel : typeof childModel === "string" ? childModel : childModel?.id;
             const childSystemPrompt = def?.systemPrompt ?? opts.systemPrompt;
             const childDefaultPersona = childSystemPrompt === undefined && !wantsFork ? SUBAGENT_PROMPT : undefined;
             const defMaxTurns = typeof def?.maxTurns === "number" && Number.isFinite(def.maxTurns) && def.maxTurns > 0 ? def.maxTurns : undefined;
@@ -2342,7 +2433,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                             ...(ctx.taskId !== undefined && ctx.taskId !== ctx.sessionId ? { parentTaskId: ctx.taskId } : {}),
                             ...(ctx.sessionId !== undefined ? { parentSessionId: ctx.sessionId } : {}),
                             ...((ctx.rootSessionId ?? ctx.sessionId) !== undefined ? { rootSessionId: ctx.rootSessionId ?? ctx.sessionId } : {}),
-                            ...((typeof childModel === "string" ? resolveModelDisplayLabel(childModel) : childModel?.id) !== undefined ? { model: typeof childModel === "string" ? childModel : childModel?.id } : {}),
+                            ...(rowModelKey !== undefined ? { model: rowModelKey } : {}),
                             deliveryChannel: "attaching",
                             toolUseId: ctx.toolCallId,
                             ...(bg.agentStore !== undefined ? { store: bg.agentStore } : {}),
@@ -2403,7 +2494,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                         }, { priority: "next" }), "subagent.reapTerminalNotify");
                     });
                     if (agentName !== undefined) {
-                        recordRosterSpawn(ctx.roster, { name: agentName, agentId: taskId, sessionId: forkedId, toolUseId: ctx.toolCallId, owner: bgOwner, scope: bgScope, ...((typeof childModel === "string" ? resolveModelDisplayLabel(childModel) : childModel?.id) !== undefined ? { model: typeof childModel === "string" ? childModel : childModel?.id } : {}), ...(modelFallback !== undefined ? { modelFallback } : {}), ...((ctx.rootSessionId ?? ctx.sessionId) !== undefined ? { rootSessionId: ctx.rootSessionId ?? ctx.sessionId } : {}), ...(sessionScopedBg ? { sessionScoped: true } : {}), createdAt: Date.now() }, (err) => opts.onObserverError?.(err, { site: "roster.recordSpawn" }));
+                        recordRosterSpawn(ctx.roster, { name: agentName, agentId: taskId, sessionId: forkedId, toolUseId: ctx.toolCallId, owner: bgOwner, scope: bgScope, ...(rowModelKey !== undefined ? { model: rowModelKey } : {}), ...(modelFallback !== undefined ? { modelFallback } : {}), ...((ctx.rootSessionId ?? ctx.sessionId) !== undefined ? { rootSessionId: ctx.rootSessionId ?? ctx.sessionId } : {}), ...(sessionScopedBg ? { sessionScoped: true } : {}), createdAt: Date.now() }, (err) => opts.onObserverError?.(err, { site: "roster.recordSpawn" }));
                     }
                     const bgSink = ctx.onBackgroundChildEvent;
                     const sinkEmit = (event) => {
@@ -2422,6 +2513,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                         ...(bgScope !== undefined ? { scope: bgScope } : {}),
                         description: shortDesc,
                         agentType: spawnAgentType,
+                        ...(spawnModel !== undefined ? { model: spawnModel } : {}),
                         ...(bgForkCycleSeq !== undefined ? { seq: bgForkCycleSeq } : {}),
                         ...(agentName !== undefined ? { name: agentName } : {}),
                         sessionId: forkedId,
@@ -2451,6 +2543,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                             parentToolCallId: ctx.toolCallId,
                             progressTaskId: forkedId,
                             agentType: spawnAgentType,
+                            ...(spawnModel !== undefined ? { model: spawnModel } : {}),
                             ...(bgForkCycleSeq !== undefined ? { seq: bgForkCycleSeq } : {}),
                             ...(currentAction !== undefined ? { currentAction } : {}),
                             ...(currentTool !== undefined ? { currentTool } : {}),
@@ -2485,6 +2578,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                                         progressTaskId: e.taskId,
                                         ...(e.parentTaskId !== undefined ? { progressParentTaskId: e.parentTaskId } : {}),
                                         agentType: spawnAgentType,
+                                        ...(spawnModel !== undefined ? { model: spawnModel } : {}),
                                         ...(e.name !== undefined ? { name: e.name } : {}),
                                         ...(currentAction !== undefined ? { currentAction } : {}),
                                         ...(currentTool !== undefined ? { currentTool } : {}),
@@ -2562,9 +2656,10 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                         const resumableFork = false;
                         const forkTranscriptId = child.sessionId ?? forkedId;
                         const failReasonFork = settledBg === "failed" ? child.errorMessage : undefined;
+                        const forkElapsedMs = Date.now() - forkBgStartedAt;
                         const forkTerminalSummary = failReasonFork !== undefined
-                            ? `Agent "${shortDesc}" failed: ${failReasonFork}${ccElapsedTag(Date.now() - forkBgStartedAt)}`.slice(0, 300) + errorKindClause(errClassFork)
-                            : `${ccCompletionText(shortDesc, settledBg, String(child.status), Date.now() - forkBgStartedAt)}`;
+                            ? `Agent "${shortDesc}" failed: ${failReasonFork}${ccElapsedTag(forkElapsedMs)}`.slice(0, 300) + errorKindClause(errClassFork)
+                            : `${ccCompletionText(shortDesc, settledBg, String(child.status), forkElapsedMs)}`;
                         const ownsTerminalFacesFork = bg.registry.claimAgentTerminalNotify(taskId);
                         if (ownsTerminalFacesFork)
                             sinkEmit({
@@ -2580,7 +2675,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                                 summary: forkTerminalSummary,
                                 ...residualFork,
                                 resumable: resumableFork,
-                                usage: { tokens: child.stats.tokens, turns: child.stats.turns, ...delegatedCostField(child.stats) },
+                                usage: { tokens: child.stats.tokens, turns: child.stats.turns, ...delegatedCostField(child.stats), ...delegatedGranularityFields(child.stats, forkElapsedMs) },
                                 ...(completionIdFork !== undefined ? { completionId: completionIdFork } : {}),
                             });
                         try {
@@ -2594,12 +2689,13 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                                     summary: forkTerminalSummary,
                                     ...(failReasonFork !== undefined ? { error: failReasonFork.slice(0, REPORT_FIELD_MAX) } : {}),
                                     ...(settledBg === "failed" && errCodeFork !== undefined ? { errorCode: errCodeFork } : {}),
+                                    ...providerFaultField(child),
                                     ...(child.sessionId ? { sessionId: child.sessionId } : {}),
                                     ...(forkBgResult ? { result: notifyResultField(forkBgResult) } : {}),
                                     ...(settledBg === "killed" && child.result ? { partial: true } : {}),
                                     ...residualFork,
                                     resumable: resumableFork,
-                                    usage: { tokens: child.stats.tokens, turns: child.stats.turns, ...delegatedCostField(child.stats) },
+                                    usage: { tokens: child.stats.tokens, turns: child.stats.turns, ...delegatedCostField(child.stats), ...delegatedGranularityFieldsWire(child.stats, forkElapsedMs) },
                                     ...(completionIdFork !== undefined ? { completionId: completionIdFork } : {}),
                                 }, { priority: "next" });
                         }
@@ -2912,7 +3008,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                             ...(ctx.taskId !== undefined && ctx.taskId !== ctx.sessionId ? { parentTaskId: ctx.taskId } : {}),
                             ...(ctx.sessionId !== undefined ? { parentSessionId: ctx.sessionId } : {}),
                             ...((ctx.rootSessionId ?? ctx.sessionId) !== undefined ? { rootSessionId: ctx.rootSessionId ?? ctx.sessionId } : {}),
-                            ...((typeof childModel === "string" ? resolveModelDisplayLabel(childModel) : childModel?.id) !== undefined ? { model: typeof childModel === "string" ? childModel : childModel?.id } : {}),
+                            ...(rowModelKey !== undefined ? { model: rowModelKey } : {}),
                             deliveryChannel: "attaching",
                             toolUseId: ctx.toolCallId,
                             ...(bg.agentStore !== undefined ? { store: bg.agentStore } : {}),
@@ -2936,7 +3032,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                     chargeDelegationEntryHandle(bg.registry, capLedgerKey, bg.agentStore, reviveRow === undefined ? taskId : undefined);
                 childInternals.peerSelfRef?.addAxis("h", taskId);
                 if (agentName !== undefined) {
-                    recordRosterSpawn(ctx.roster, { name: agentName, agentId: taskId, toolUseId: ctx.toolCallId, owner: bgOwner, scope: bgScope, ...((typeof childModel === "string" ? resolveModelDisplayLabel(childModel) : childModel?.id) !== undefined ? { model: typeof childModel === "string" ? childModel : childModel?.id } : {}), ...(reviveRow !== undefined ? ((reviveRow.rootSessionId ?? reviveRow.parentSessionId) !== undefined ? { rootSessionId: reviveRow.rootSessionId ?? reviveRow.parentSessionId } : {}) : (ctx.rootSessionId ?? ctx.sessionId) !== undefined ? { rootSessionId: ctx.rootSessionId ?? ctx.sessionId } : {}), ...(sessionScopedBg ? { sessionScoped: true } : {}), createdAt: reviveRow?.spawnedAt ?? Date.now() }, (err) => opts.onObserverError?.(err, { site: "roster.recordSpawn" }));
+                    recordRosterSpawn(ctx.roster, { name: agentName, agentId: taskId, toolUseId: ctx.toolCallId, owner: bgOwner, scope: bgScope, ...(reviveRow !== undefined ? (reviveRow.model !== undefined ? { model: reviveRow.model } : {}) : rowModelKey !== undefined ? { model: rowModelKey } : {}), ...(modelFallback !== undefined ? { modelFallback } : {}), ...(reviveRow !== undefined ? ((reviveRow.rootSessionId ?? reviveRow.parentSessionId) !== undefined ? { rootSessionId: reviveRow.rootSessionId ?? reviveRow.parentSessionId } : {}) : (ctx.rootSessionId ?? ctx.sessionId) !== undefined ? { rootSessionId: ctx.rootSessionId ?? ctx.sessionId } : {}), ...(sessionScopedBg ? { sessionScoped: true } : {}), createdAt: reviveRow?.spawnedAt ?? Date.now() }, (err) => opts.onObserverError?.(err, { site: "roster.recordSpawn" }));
                 }
                 const bgSink = ctx.onBackgroundChildEvent;
                 const sinkEmit = (event) => {
@@ -2992,6 +3088,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                     ...(bgScope !== undefined ? { scope: bgScope } : {}),
                     description: reviveRow !== undefined ? `${shortDesc} (revived)` : shortDesc,
                     agentType: spawnAgentType,
+                    ...(spawnModel !== undefined ? { model: spawnModel } : {}),
                     ...(bgCycleSeq !== undefined ? { seq: bgCycleSeq } : {}),
                     ...(agentName !== undefined ? { name: agentName } : {}),
                     sessionId: bgChildSessionId,
@@ -3065,6 +3162,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                         parentToolCallId: ctx.toolCallId,
                         progressTaskId: bgChildSessionId,
                         agentType: spawnAgentType,
+                        ...(spawnModel !== undefined ? { model: spawnModel } : {}),
                         ...(bgCycleSeq !== undefined ? { seq: bgCycleSeq } : {}),
                         ...(currentAction !== undefined ? { currentAction } : {}),
                         ...(currentTool !== undefined ? { currentTool } : {}),
@@ -3111,6 +3209,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                                     progressTaskId: e.taskId,
                                     ...(e.parentTaskId !== undefined ? { progressParentTaskId: e.parentTaskId } : {}),
                                     agentType: spawnAgentType,
+                                    ...(spawnModel !== undefined ? { model: spawnModel } : {}),
                                     ...(e.name !== undefined ? { name: e.name } : {}),
                                     ...(currentAction !== undefined ? { currentAction } : {}),
                                     ...(currentTool !== undefined ? { currentTool } : {}),
@@ -3399,9 +3498,10 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                         named: agentName !== undefined,
                     });
                     const failReasonBg = settled === "failed" ? unparkedPauseReason ?? child.errorMessage : undefined;
+                    const bgElapsedMs = Date.now() - bgStartedAt;
                     const bgTerminalSummary = failReasonBg !== undefined
-                        ? `Agent "${shortDesc}" failed: ${failReasonBg}${ccElapsedTag(Date.now() - bgStartedAt)}${observerNote}`.slice(0, 300) + errorKindClause(errClassBg)
-                        : `${ccCompletionText(shortDesc, settled, String(child.status), Date.now() - bgStartedAt)}${observerNote}`;
+                        ? `Agent "${shortDesc}" failed: ${failReasonBg}${ccElapsedTag(bgElapsedMs)}${observerNote}`.slice(0, 300) + errorKindClause(errClassBg)
+                        : `${ccCompletionText(shortDesc, settled, String(child.status), bgElapsedMs)}${observerNote}`;
                     const ownsTerminalFaces = bg.registry.claimAgentTerminalNotify(taskId);
                     if (ownsTerminalFaces)
                         sinkEmit({
@@ -3416,7 +3516,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                             summary: bgTerminalSummary,
                             ...residual,
                             resumable: resumableBg,
-                            usage: { tokens: child.stats.tokens, turns: child.stats.turns, ...delegatedCostField(child.stats) },
+                            usage: { tokens: child.stats.tokens, turns: child.stats.turns, ...delegatedCostField(child.stats), ...delegatedGranularityFields(child.stats, bgElapsedMs) },
                             ...(completionIdBg !== undefined ? { completionId: completionIdBg } : {}),
                         });
                     const completionFrame = {
@@ -3429,12 +3529,13 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                         summary: bgTerminalSummary,
                         ...(failReasonBg !== undefined ? { error: failReasonBg.slice(0, REPORT_FIELD_MAX) } : {}),
                         ...(settled === "failed" && errCodeBg !== undefined ? { errorCode: errCodeBg } : {}),
+                        ...providerFaultField(child),
                         ...(child.sessionId ? { sessionId: child.sessionId } : {}),
                         ...(bgHandbackResult ? { result: notifyResultField(bgHandbackResult) } : {}),
                         ...(settled === "killed" && child.result ? { partial: true } : {}),
                         ...residual,
                         resumable: resumableBg,
-                        usage: { tokens: child.stats.tokens, turns: child.stats.turns, ...delegatedCostField(child.stats) },
+                        usage: { tokens: child.stats.tokens, turns: child.stats.turns, ...delegatedCostField(child.stats), ...delegatedGranularityFieldsWire(child.stats, bgElapsedMs) },
                         ...(completionIdBg !== undefined ? { completionId: completionIdBg } : {}),
                     };
                     const gateOwner = ownsTerminalFaces && settled === "completed" && notify !== undefined ? bgRetain?.childSessionId : undefined;

package/dist/core/file-history-store.js

@@ -166,6 +166,14 @@ export function validateFileHistoryExport(data) {
                 return bad(`tracked row ${t.relOrAbsPath} carries a non-integer version number`);
             if (v.blobHash !== null && (typeof v.blobHash !== "string" || !/^[0-9a-f]{64}$/.test(v.blobHash)))
                 return bad(`tracked row ${t.relOrAbsPath} carries a blob reference that is not a sha256 digest`);
+            if (v.mode !== undefined) {
+                if (typeof v.mode !== "number" || !Number.isInteger(v.mode) || v.mode < 0 || v.mode > 0o7777) {
+                    return bad(`tracked row ${t.relOrAbsPath} carries a mode outside the permission-bit domain [0, 0o7777] — refused, never coerced`);
+                }
+                if ((v.mode & 0o6000) !== 0) {
+                    return bad(`tracked row ${t.relOrAbsPath} carries a set-ID mode (0o${v.mode.toString(8)}) — a restore replaying setuid/setgid bits would mint a privilege-escalation primitive; refused`);
+                }
+            }
         }
         if (new Set(t.versions.map((v) => v.version)).size !== t.versions.length)
             return bad(`tracked row ${t.relOrAbsPath} carries the same version number twice — a chain whose versions are ambiguous cannot be published`);
@@ -284,13 +292,15 @@ export async function applyFileRestoreViaEnv(env, absPath, target, opts) {
             return { outcome: "identical" };
         if (modeOnly === "applied")
             return { outcome: "applied" };
+        if (modeOnly === "applied_unpreserved")
+            return { outcome: "applied", modeNotPreserved: true };
         return { outcome: "identical", modeNotPreserved: true };
     }
     const w = await writeRestoredBytes(env, absPath, target.bytes, signal);
     if (!w.ok)
         return { outcome: w.refused ? "refused" : "failed", reason: `write: ${w.code}` };
     const modeAfter = await applyRecordedMode(env, absPath, opts, undefined);
-    return { outcome: "applied", ...(modeAfter === "unpreserved" ? { modeNotPreserved: true } : {}) };
+    return { outcome: "applied", ...(modeAfter === "unpreserved" || modeAfter === "applied_unpreserved" ? { modeNotPreserved: true } : {}) };
 }
 async function restorePreflight(env, absPath, opts) {
     const info = await env.fileInfo(absPath, opts.signal);
@@ -337,7 +347,10 @@ export async function previewFileDelta(env, absPath, targetHash, targetBytes, ta
             return undefined;
         const info = await env.fileInfo(absPath);
         const currentMode = info.ok ? info.value.mode : undefined;
-        return modeProvenDifferent(targetMode, currentMode) ? { insertions: 0, deletions: 0 } : undefined;
+        const replayMode = (targetMode & 0o6000) !== 0 ? targetMode & 0o1777 : targetMode;
+        return modeProvenDifferent(targetMode, currentMode) && modeProvenDifferent(replayMode, currentMode)
+            ? { insertions: 0, deletions: 0 }
+            : undefined;
     }
     return countRestoreLineDiff(curBytes, targetBytes);
 }
@@ -347,6 +360,15 @@ async function applyRecordedMode(env, absPath, opts, currentMode) {
         return "unchanged";
     if (currentMode === (want & 0o7777))
         return "unchanged";
+    if ((want & 0o6000) !== 0) {
+        const stripped = want & 0o1777;
+        if (currentMode === stripped)
+            return "unpreserved";
+        if (env.setFileMode === undefined)
+            return "unpreserved";
+        const r = await env.setFileMode(absPath, stripped, opts.signal);
+        return r.ok ? "applied_unpreserved" : "unpreserved";
+    }
     if (env.setFileMode === undefined)
         return "unpreserved";
     const r = await env.setFileMode(absPath, want & 0o7777, opts.signal);

package/dist/core/roles.js

@@ -3,7 +3,7 @@ export function resolveModel(ref, models) {
     if (typeof ref !== "string") {
         return ref;
     }
-    const m = models?.[ref];
+    const m = models !== undefined && Object.hasOwn(models, ref) ? models[ref] : undefined;
     if (!m) {
         throw new Error(`Unknown model ref "${ref}". Provide it in RunnerDeps.models or pass a Model object.`);
     }

package/dist/core/runner/runtask.js

@@ -1410,6 +1410,7 @@ function makeHarnessHandlers(prepared, stats, rs, deps) {
                 ...(internals?.cycleSeq !== undefined ? { seq: internals.cycleSeq } : {}),
                 ...(internals?.parentTaskId !== undefined ? { parentTaskId: internals.parentTaskId } : {}),
                 ...(subagentName ? { name: subagentName } : {}),
+                model: prepared.model.id,
                 usage: { totalTokens: stats.tokens, toolUses: stats.toolCalls, durationMs: Date.now() - rs.telemetry.taskStart },
                 status: "running",
                 ...ident(),
@@ -4223,6 +4224,7 @@ export class Runner {
                     ...(internals?.cycleSeq !== undefined ? { seq: internals.cycleSeq } : {}),
                     ...(internals?.parentTaskId !== undefined ? { parentTaskId: internals.parentTaskId } : {}),
                     ...(subagentName ? { name: subagentName } : {}),
+                    model: prepared.model.id,
                     usage: { totalTokens: stats.tokens, toolUses: stats.toolCalls, durationMs: Date.now() - rs.telemetry.taskStart },
                     status: result.status === "completed" ? "completed" : "failed",
                     ...ident(),

package/dist/core/task-notification.d.ts

@@ -66,6 +66,19 @@ export interface TaskNotificationPayload {
      *  `TaskResult.errorCode` taxonomy (brain `[code]` prefixes via extractErrorCode, `limit.*`,
      *  `budget.*`, …). Engine-minted, never model text. Absent when the failure carried no code. */
     errorCode?: string;
+    /** Terminal, delegation lanes: the settling run's PROVIDER-BOUNDARY fault assertion, mirrored from
+     *  its `TaskResult.apiFailure`. Its PRESENCE is the claim — "this failure came from the transport or
+     *  the provider, not from this deployment refusing to send, a limit, or unusable model output" — and
+     *  `errorCode` beside it names WHICH terminal; the two answer different questions and neither implies
+     *  the other. Members are whatever the failing attempt stated about itself (`status` when the provider
+     *  answered with one, `requestId` when it named one), so an EMPTY object is meaningful: "provider
+     *  fault, unlabelled", which is not the same statement as absence. Absent on every non-provider
+     *  terminal, on every completed run, and on the non-delegation lanes (bash/monitor), whose failures do
+     *  not pass through a model provider at all. */
+    apiFailure?: {
+        status?: number;
+        requestId?: string;
+    };
     /** Structured exit code of a background command's terminal notification (bash lane): the process
      *  exited on its own with this code. Lets consumers branch on success/failure without parsing the
      *  summary wording. Absent when the process never exited by itself (killed / spawn-failed lanes). */
@@ -77,6 +90,13 @@ export interface TaskNotificationPayload {
      *  every other notification (a completed result is never flagged). */
     partial?: boolean;
     output_file?: string;
+    /** Whatever the settling lane knows about its own spend, JSON-rendered verbatim into one `<usage>`
+     *  tag. Deliberately untyped — the lanes report different quantities and nothing here should force
+     *  one to fabricate a figure it does not have. What IS contracted is the VOCABULARY: a name that two
+     *  lanes both publish must mean the same thing on both. The delegation lanes
+     *  (`background_agent`, its fork/revive cycles) and the workflow lane therefore agree on
+     *  `tokens`/`turns`/`costMicroUsd`/`tool_uses`/`duration_ms`; the workflow lane's fan-out counters
+     *  (`agent_count`, `agents_done`, …) and resume counters have no delegation analog and are its own. */
     usage?: unknown;
     /** CC `<diagnostics>` parity: ENGINE-MINTED teaching text for the "result is empty/unexpected —
      *  now what" moment (per-agent read route / journal coordinate / resume command). Producers must mint it

package/dist/core/types.d.ts

@@ -4646,6 +4646,31 @@ export type TaskEvent = ({
      *  nor an agent-type — the child then keeps its taskId (NOT the raw objective, which could leak a delegated
      *  secret to a progress-scoped consumer — dual-review Q2). Sanitized (control-char-stripped, length-capped). */
     name?: string;
+    /**
+     * The model this sub-run was PREPARED with — the resolved id, read off the leg's prepared model
+     * at the mint, so it is the same value `TaskResult.model` and the `task.start` trace frame carry.
+     * (`task.end` reports the run's totals and has never named a model; there is nothing to join to
+     * there.)
+     *
+     * Why it rides the live lane at all: a delegation may name a tier word (`"sonnet"`), an agent
+     * definition's model, or NOTHING (inherit the caller's current model, or fall to the `subagent`
+     * role) — every one of those resolves somewhere the consumer cannot see, so a shell badging a
+     * running child previously had only the REQUESTED word (or nothing) to render, which is a
+     * different claim from what the child runs on. This is the resolved answer, not the request.
+     *
+     * PREPARED, deliberately, and NOT "whatever is serving this turn" — stated in the first sentence
+     * because the difference is observable. A mid-run DEGRADE switch (`spec.limits.degrade`) or a
+     * gateway re-route moves the serving model without rewriting this field, exactly as
+     * `TaskResult.model` behaves; the switch is announced on its own channel (`TaskResult.degraded`),
+     * and the per-call served id lives on the brain-call telemetry. One name, one meaning, across the
+     * three faces that use it — at the cost of being the leg's declared model rather than a live one.
+     *
+     * Present on every tick this build mints (the frame family is subagent-only by construction, so
+     * there is no lane where a leg has no prepared model). Declared optional for the ordinary reason:
+     * a consumer folding frames from a pre-key producer must keep compiling, and absence there means
+     * "this producer did not state it", never "no model".
+     */
+    model?: string;
     /** The child's most recent tool intent as one human line ("Bash npm test",
      *  "Edit src/x.ts") — the SAME source/value as the registry sink tick's `currentAction` (residual
      *  observability, lane B), attached to the FORWARDED frame because every client wire projects this
@@ -5246,6 +5271,40 @@ export interface BackgroundChildEvent {
      *  waiting for spawn-frame forwarding; `name` stays the design/99 DISPLAY label (description-backed)
      *  and was never a type field. */
     agentType?: string;
+    /**
+     * spawn + tick: the model the ROW runs on — the resolved `ModelRef` the spawner selected for this
+     * child (a per-call `model`, an agent definition's, or the caller's own current model, inherited).
+     * It answers with the SERVED catalog model id wherever that is knowable, because this value sits
+     * beside the child's own `task_progress.model` (the leg's prepared id) and a consumer joins the
+     * two: a row saying "sonnet" next to ticks naming the catalog id it routed to is indistinguishable
+     * from two different children. A `Model` object carries its id — and a per-call word that passed
+     * the spawn gate arrives as exactly that resolved object, so for it the row and the ticks are one
+     * value by construction. A definition/tool-level STRING ref resolves through the catalog in force
+     * at the spawn judgement; the child's own prepare re-resolves such a ref against the runner's live
+     * table, so for those refs alone a catalog hot-swapped between the two reads can lag the row one
+     * generation behind the ticks. The DISPLAY rule survives only as the FALLBACK, for a string the
+     * judgement-time catalog cannot resolve (a CC tier alias then shows its sema tier, never the alias
+     * verbatim). It rides ticks as well as spawn for the same reason
+     * {@link agentType} does: a consumer that only forwards ticks must not have to wait for spawn-frame
+     * forwarding to fill its row. Like `agentType` it is the ROW's own fact and is NEVER copied off a
+     * forwarded frame — a nested descendant's `task_progress` names ITS model, not this row's.
+     *
+     * ABSENT is a fact, not a gap, and there are exactly three ways to get there:
+     *  · the delegation named no model anywhere in the chain, so the child runs on the `subagent` ROLE
+     *    and its concrete id is only decided at the child's own prepare;
+     *  · the RETAIN-LEDGER wake lane (a `SendMessage` resume of a completed child), whose frames are
+     *    projected from an `AccessibleTaskRow` — and that row has no model column, so this lane has
+     *    nothing to state and will not invent one. Stated precisely because the sibling wake lane does
+     *    NOT share the limitation: a tier-3 DURABLE revive re-enters through the ordinary background
+     *    spawn, re-derives the model like a first spawn, and its `(revived)` frames carry it whenever
+     *    that derivation lands on a model (the durable record keeps a `model` of its own; a recorded
+     *    key the current catalog no longer resolves degrades the revival to the inherited model, and a
+     *    mount with nothing to inherit then leaves these frames honestly silent);
+     *  · a pre-key producer.
+     * In every case the child's own `task_progress` frames still carry the resolved answer, which is the
+     * authority; this field is the row-level convenience beside it.
+     */
+    model?: string;
     /** spawn: the HOST task's DECLARED task id (parent attribution). Omitted when the host
      *  run declared no task id (the `spec.taskId ?? sessionId` fallback would launder a session id into
      *  a task-id field — the orphan-pointer shape); {@link parentSessionId} is the always-on linkage. */
@@ -5359,7 +5418,21 @@ export interface BackgroundChildEvent {
     stoppedBy?: "user" | "parent" | "system" | (string & {});
     /** terminal: bounded human summary (same text the task_notification carries). */
     summary?: string;
-    /** tick: live rollup (`task_progress.usage`) · terminal: final `{tokens, turns, costMicroUsd}`. */
+    /** tick: live rollup (`task_progress.usage`) · terminal: the settled
+     *  `{tokens, turns, costMicroUsd?, toolUses?, durationMs}`. `costMicroUsd` is own+nested and present
+     *  only when that total is KNOWN (RB-368); `toolUses` is the run's own `stats.toolCalls` and is
+     *  absent — never zeroed — when the gateway reported no usage. The last two joined the terminal face
+     *  to close a reporting asymmetry: the workflow lane's completion notification and the Agent tool's
+     *  own sync `<usage>` footer had published both all along, so one child answered "how much work, how
+     *  long" on one lane and refused on the other.
+     *
+     *  `durationMs` MEASURES DIFFERENT SPANS on the two kinds, which is worth knowing before plotting it:
+     *  on a TICK it is the child RUN's own elapsed (the forwarded frame's value, from the run's start);
+     *  on the TERMINAL it is the delegation LEG's, from the lane's launch instant — which is earlier, so
+     *  a consumer graphing one series sees a step up at settle. Both are true of what they name; neither
+     *  can be computed from the other without the spawn/prepare interval, which is why they are not
+     *  reconciled into one. The intra-turn activity beat carries a third, narrower shape (`{toolUses}`
+     *  alone — there is no honest live token figure on that lane). */
     usage?: {
         totalTokens?: number;
         toolUses?: number;

package/dist/core/wiring-manifest.d.ts

@@ -133,7 +133,12 @@ export interface WiringManifest {
      *  a completed/failed/killed(non-user) subagent minted through the deps-visible assembly is
      *  continuable across a process restart. A statement about the DEPS-VISIBLE assembly only: a
      *  caller-mounted Agent tool over its own runner is outside this manifest's sight (per-read
-     *  honest degrade + the integrity notice own that case, never a fabricated tier). */
+     *  honest degrade + the integrity notice own that case, never a fabricated tier) — and that
+     *  blind spot is load-bearing here, because the store this field is derived from is the ROOT
+     *  leg's while the store an ordinary child transcript is actually minted through is the AGENT
+     *  TOOL's runner's ({@link resolveSubagentTranscriptTier} names the rule and the fork-lane
+     *  exception). The word names ADDRESSABILITY: `none`/`rows` are silent on whether a child
+     *  transcript reaches disk at all, and only `full` promises the a* handle survives a restart. */
     fleet: {
         backgroundAgentStore: boolean;
         hostChildEventSink: boolean;
@@ -254,6 +259,18 @@ export type SubagentTranscriptTier = "none" | "rows" | "full";
  * fold picked). This is the DEPLOYMENT-level judgment only; the per-handle "did this row's
  * transcript actually land" question belongs to `durableAgentRowProbe` (the S1b release-flip gate)
  * — two different questions, deliberately two named faces (do not merge them back into one).
+ *
+ * WHICH session store to pass: the one on the runner the Agent tool was mounted with
+ * (`SubagentToolOptions.runner.sessions`), because that is the store an ordinary (sync/background)
+ * child transcript is minted through — the fork lane deliberately branches through the HOST store
+ * instead, see the law on `SubagentToolOptions.runner`. A deployment that serves root tasks from one
+ * runner and delegated children from another (a throwaway sub-task store, a routing store) has two
+ * different stores here, and passing the ROOT deps' store reports the root lane's fate under the
+ * child lane's name. Note what the three words do and do not promise about DISK: this tier names
+ * ADDRESSABILITY, not persistence. `none` is returned before any store is inspected, so it covers
+ * both "the transcript is on disk but nothing can address it" and "there is no transcript" — an
+ * operator asking whether a child conversation is readable afterwards must read the delegation
+ * store's own durability + release/evict semantics, not this word.
  */
 export declare function resolveSubagentTranscriptTier(agentStoreWired: boolean, sessionStore: {
     readonly placements?: {

package/dist/orchestration/run-workflow-tool.js

@@ -3,6 +3,7 @@ import { defineTool, errorResult } from "../core/tools.js";
 import { governanceBaselineError, governanceBaselineProblem } from "./governance-baseline-validity.js";
 import { redactSecrets, redactHostLeaks, boundedRedactedSummary } from "../core/untrusted-egress.js";
 import { withDelegationProvenance } from "../core/tool-policy.js";
+import { LAUNCH_RECEIPT_OWN_WORDS_CLAUSE, launchReceiptNoQuoteClause } from "../agents/launch-receipt-contract.js";
 import { startWorkflow } from "./workflow.js";
 import { buildWorkflowPrimitives } from "./workflow-primitives.js";
 import { parseWorkflowMeta, splitWorkflowMeta, workflowScriptReadsClockOrRandom } from "./workflow-meta.js";
@@ -630,8 +631,7 @@ export async function createRunWorkflowTool(d) {
                     task_id: runId,
                     status: "started",
                     ...(persistedScriptPath !== undefined ? { scriptPath: persistedScriptPath } : {}),
-                    handling: "This tool result is internal metadata — never quote or paste any part of it (the ids above, and scriptPath when present) into a user-facing reply. " +
-                        "In your own words, briefly tell the user what you launched; do not echo this result.",
+                    handling: `${launchReceiptNoQuoteClause(" (the ids above, and scriptPath when present)")} ${LAUNCH_RECEIPT_OWN_WORDS_CLAUSE}`,
                     note: (() => {
                         const pollExpr = d.taskRegistry ? `TaskOutput({ task_id: "${runId}" })` : undefined;
                         const blockingPollExpr = d.taskRegistry ? `TaskOutput({ task_id: "${runId}", block: true })` : undefined;

package/dist/orchestration/workflow.js

@@ -54,11 +54,14 @@ function forReview(text) {
         return text;
     return `${text.slice(0, MAX_REVIEWED_PROMPT_CHARS)}\n[…TRUNCATED FOR REVIEW: ${text.length - MAX_REVIEWED_PROMPT_CHARS} further characters follow that the child WILL receive and this review did NOT see]`;
 }
-function workflowModelLabel(spec) {
+function workflowModelLabel(spec, catalog) {
     const model = spec.model;
     if (model === undefined)
         return undefined;
-    return typeof model === "string" ? resolveModelDisplayLabel(model) : model.id ?? model.name;
+    if (typeof model !== "string")
+        return model.id ?? model.name;
+    const served = catalog?.[model]?.id;
+    return served ?? resolveModelDisplayLabel(model);
 }
 export const WORKFLOW_SUBAGENT_PROMPT = `You are a subagent spawned by a workflow orchestration script. Use the tools available to complete the task.
 
@@ -441,6 +444,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
     }
     const concurrency = normalizeConcurrency(opts.concurrency);
     const agentRegistry = workflowAgentRegistry(opts);
+    const modelCatalog = runner.agentCatalog?.models;
     const store = opts.store;
     const maxAgents = normalizeWorkflowHardCap("maxAgents", opts.maxAgents);
     const maxLogChars = normalizeWorkflowHardCap("maxLogChars", opts.maxLogChars);
@@ -633,11 +637,11 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
     const bceParentToolCall = opts.parentToolCallId !== undefined ? { parentToolCallId: opts.parentToolCallId } : {};
     const waIdOf = (callKey) => `wa${createHash("sha256").update(`${runId}:${callKey}`).digest("hex").slice(0, 16)}`;
     const bceLive = new Map();
-    const bceSpawn = (callKey, label, agentType, replayed, sessionId) => {
+    const bceSpawn = (callKey, label, agentType, replayed, sessionId, model) => {
         if (!bceSink)
             return;
         const id = waIdOf(callKey);
-        bceLive.set(id, { callKey, label, ...(agentType !== undefined ? { agentType } : {}), ...(sessionId !== undefined ? { sessionId } : {}) });
+        bceLive.set(id, { callKey, label, ...(agentType !== undefined ? { agentType } : {}), ...(sessionId !== undefined ? { sessionId } : {}), ...(model !== undefined ? { model } : {}) });
         bceEmit({
             kind: "spawn",
             taskId: id,
@@ -648,6 +652,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
             ...(scope !== undefined ? { scope } : {}),
             description: replayed ? `${label} (replayed)` : label,
             agentType: agentType ?? "workflow-agent",
+            ...(model !== undefined ? { model } : {}),
             name: label,
             ...(opts.parentTaskId !== undefined ? { parentTaskId: opts.parentTaskId } : {}),
             workflowRunId: runId,
@@ -679,6 +684,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
             workflowRunId: runId,
             ...(scope !== undefined ? { scope } : {}),
             ...(row.agentType !== undefined ? { agentType: row.agentType } : { agentType: "workflow-agent" }),
+            ...(row.model !== undefined ? { model: row.model } : {}),
             ...(row.sessionId !== undefined ? { sessionId: row.sessionId, transcriptId: row.sessionId } : {}),
             name: e.name ?? row.label,
             progressTaskId: e.taskId,
@@ -1003,7 +1009,8 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
         const specForIdentity = inheritedModelSnap !== undefined ? { ...spec, model: inheritedModelSnap } : spec;
         const callKey = workflowAgentCallKey(run.agents.length, specForIdentity, agentOpts);
         const prompt = boundedRedactedSummary(spec.systemPrompt ? `${spec.systemPrompt}\n\n${spec.objective}` : spec.objective, MAX_TRANSCRIPT_CHARS);
-        const model = workflowModelLabel(specForIdentity);
+        const specForLabel = spec.model === undefined && typeDefModel !== undefined ? { ...spec, model: typeDefModel } : specForIdentity;
+        const model = workflowModelLabel(specForLabel, modelCatalog);
         return { label, phase, phaseInstance, groupId, inheritedModelSnap, callKey, prompt, model };
     };
     const reviewSpawnBeforeLaunch = async (lane, label, callKey, runSpec, effectiveSignal) => {
@@ -1161,13 +1168,14 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                     const rs = r.stats;
                     const cachedOutput = boundedRedactedSummary(r.structuredOutput ?? r.result, MAX_TRANSCRIPT_CHARS);
                     const at = now();
+                    const replayModel = r.model;
                     const replayRec = {
                         label,
                         callKey,
                         ...(groupId !== undefined ? { groupId } : {}),
                         phase,
                         prompt,
-                        ...(model !== undefined ? { model } : {}),
+                        ...(replayModel !== undefined ? { model: replayModel } : {}),
                         replayed: true,
                         status: r.status === "completed" ? "completed" : "failed",
                         taskStatus: r.status,
@@ -1185,9 +1193,9 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                     run.agents.push(replayRec);
                     if (phaseInstance)
                         agentPhaseOf.set(replayRec, phaseInstance);
-                    emit({ type: "agent_start", runId, label, phase, ...(groupId !== undefined ? { groupId } : {}), callKey, prompt, ...(model !== undefined ? { model } : {}), replayed: true, ts: at });
+                    emit({ type: "agent_start", runId, label, phase, ...(groupId !== undefined ? { groupId } : {}), callKey, prompt, ...(replayModel !== undefined ? { model: replayModel } : {}), replayed: true, ts: at });
                     emit({ type: "agent_end", runId, label, phase, ...(groupId !== undefined ? { groupId } : {}), status: replayRec.status, output: cachedOutput, ...(rs.toolCalls !== undefined ? { toolCalls: rs.toolCalls } : {}), replayed: true, ts: at });
-                    bceSpawn(callKey, label, agentOpts.agentType, true, r.sessionId || undefined);
+                    bceSpawn(callKey, label, agentOpts.agentType, true, r.sessionId || undefined, replayModel);
                     bceTerminal(callKey, replayRec.status === "completed" ? "completed" : "failed", cachedOutput, r.sessionId || undefined, replayRec.stats);
                     accumulateStats(r, false);
                     void persist("update");
@@ -1233,7 +1241,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                 }
                 rec.startedAt = now();
                 const bornChildSessionId = resolveChildSessionIdAtSpawn(spec);
-                bceSpawn(callKey, label, agentOpts.agentType, false, bornChildSessionId);
+                bceSpawn(callKey, label, agentOpts.agentType, false, bornChildSessionId, model);
                 const typedSpec0 = applyWorkflowAgentType(spec, agentOpts.agentType, agentRegistry);
                 const typedSpec = typedSpec0.model === undefined && inheritedModelSnap !== undefined ? { ...typedSpec0, model: inheritedModelSnap } : typedSpec0;
                 const framedSpec = withWorkflowChildPersona(typedSpec, agentOpts.schema ?? typedSpec.outputSchema);
@@ -1545,7 +1553,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
             }
             rec.startedAt = now();
             const childSessionId = resolveChildSessionIdAtSpawn(spec);
-            bceSpawn(callKey, label, agentOpts.agentType, false, childSessionId);
+            bceSpawn(callKey, label, agentOpts.agentType, false, childSessionId, model);
             let stream;
             try {
                 const typedSpec0 = applyWorkflowAgentType(spec, agentOpts.agentType, agentRegistry);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/core",
-  "version": "7.0.0",
+  "version": "7.0.1",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",