@sema-agent/core 7.9.1 → 7.9.2

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 7.9.2 — 2026-09-09
+
+### Fixes — a delegated child runs on the parent run's model, not the deployment's boot default (#641 · B-050; @cli @server)
+- **One seat, one rule.** `childModelSeat` (subagent.ts) is now the only place an engine-spawned run's model is decided — the delegation child (`buildChildSpec`, every lane: sync / background / fork / revival) and the observer sidecar share it: an EXPLICIT model for the spawn (per-call `model` > agent definition `model` > tool-level `model`) > the deployment's STATED subagent tier (`roles.subagent` naming a model source of its own — the literal `"default"` spells "no tier of my own", a `select` form counts as stated) > the **parent run's effective model** (the caller's current `Model` object, per-model routing and credentials included) > the bare `subagent` role (only reachable outside a Runner-enriched ctx). The cell that changed is the last resort: it used to be `FALLBACK.subagent → "default"`, i.e. the boot default — a run whose main turn ran on model B spawned children on boot model A, and a bare deployment (catalog, no roles) spawned children that died at prepare with `No model for role "subagent"`. Both now run on the parent's model. A deployment that stated a cheap tier keeps it (that statement is operator intent; children do not follow the parent there).
+- **Role identity rides the seat.** Every non-explicit child spec carries `modelRole: "subagent"` beside the inherited `model`, so a deployment's `roles.subagent` `systemPrompt` / `thinking` preset still applies when the model is the parent's (the explicit-model branch of `resolveTaskModel` keys presets on the role).
+- **Precedence note (definition lane).** The tool-level `model` (`createSubagentTool({ model })`) is an explicit seat and now outranks "inherit the parent" for a definition that names no model; it used to sit below the parent snapshot on that lane only. Fork children are unchanged (always the caller's model).
+- **The workflow lane reads the same seat.** A model-less script child (`agent()` / `agentStream()`) used to take the host's `Model` unconditionally; the workflow mount's host-model getter now folds the deployment's stated tier first (`deploymentSubagentTierModel(runnerSelf.agentCatalog) ?? host model`, prepare-caps-and-workflow.ts — read off the LIVE catalog per call, so a `swapModels` between two spawns is seen by the second), so the Agent lanes and the workflow lane can no longer answer one deployment two ways. A script `model` and an `agentType` model keep outranking it (explicit), the allow-list keeps gating script words. A stated tier whose catalog ref is dead fails THAT call on the recorded path (failed agent record + `agent_end`, then the throw the script's own `catch` sees — the unknown-`agentType` shape; the next call's slot is released), never a substituted model. Both lanes' pre-launch catch now stamps an ordinary throw's message as the record's `errorMessage` (no machine code minted), so the row says why the ordinal has no child — previously only a review refusal or a budget stop named its cause.
+- **The durable row names the inherited model.** A background child's record (`model`, the tier-3 revival key) records the seat's model — the parent's id for an inherited child, exactly what the child's own ticks say — so a revival from another parent keeps running the model the row was spawned on instead of silently moving to the reviver's; a stated-tier child's row stays blank as before (the role resolves it).
+- **Read face (additive, @server @cli):** `Runner.agentCatalog` / `RunnerSelfSeat.agentCatalog` gains `roles?: ModelRoles` (a copy of `RunnerDeps.roles`) — the seat's reader. No wire change; no request-lane roles seat (the deployment/request boundary stands).
+- **Engine side channels are unchanged by design** (`@contract roles.side_channels_deployment_only`): the auto-mode classifier, the compaction/summarize lane, memory consolidation and next-prompt suggestion resolve on the deployment roles alone and never take a run's model — they are deployment tools, not children of the run.
+- Consumers: `@cli` the `_subagent-model-follows-run-live-pty.mjs` probe's `EXPECTED_VERDICT=b` door flips to `a` on this engine; `@server` zero code (`roles.subagent = "default"` when `MODEL_CHEAP_ID` is unset is exactly the "not stated" spelling).
+
+### Docs — the sub-run inheritance matrix (#643; @cli @server @test)
+- `docs/SUBRUN-INHERITANCE.md`: every inheritance face (model, approver seat + park facility, posture + spawn review, inherited gate + ancestor rules, thinking, role fallback, budgets/TTLs, event-forwarding identity keys, principal + auth hook, session/run lineage, contentOrigin) × every child lane (Agent sync / background / workflow agents / fork·team·synthesize / scheduler wake-up / observer·verifier·advisor / resume-rebuilt / tier-3 revival), each cell "inherits / falls back to (file:line) / gated?". Appendix A lists every deployment-default fallback position with its verdict (design → contract sentence; defect → ticket); Appendix B lists every fail-closed deny mouth with who reaches it and where it is visible.
+- **B-049 (#642) is DEFINED here, not fixed in this release** (see the matrix §B-049): a workflow-lane child whose inherited ask the host approver answers `unavailable` denies fail-closed exactly like a SYNC delegation child (pinned three-lane: `test/backlog642-child-ask-lanes.test.ts`); only the BACKGROUND lane parks, because only it is handed the parent's `durableApproval` (§7.3 park family). Making workflow children park is the same park family extended to the workflow row (`wa*` row parked state + the workflow's own pause cascade + a resume path) — a design slice, scheduled separately; the interim is the loud terminal (the deny sentence in the tool result and `tool_end.gate.settlement.kind = "approver_unavailable"`).
+
 ## 7.9.1 — 2026-09-08
 
 ### Wire (additive) — `mcp.injection_dropped`: the request-lane MCP drop reaches the user (L-167; @server @cli @client-core)

package/dist/agents/child-model-seat.d.ts

@@ -0,0 +1,51 @@
+import type { Model, ModelRef, ModelRoles } from "../core/types.js";
+/** The deployment role map behind the runner (`Runner.agentCatalog.roles`) — same posture as `runnerModelCatalog` (subagent.ts):
+ *  host code, a throwing/absent stand-in reads as "no role map", never as a failed delegation. */
+export declare function runnerRoleMap(runner: unknown): ModelRoles | undefined;
+/**
+ * Did the deployment STATE a model for its subagents? True iff `roles.subagent` names a model source of its
+ * own: a string ref other than the literal `"default"`, a `Model` object, or a `{ model | select }` config
+ * whose `model` is not that literal. The word `"default"` is how a deployment spells "no subagent tier of my
+ * own — same as the main model" (a catalog key of that name is the boot default), so it reads as NOT stated;
+ * a role entry carrying only a `thinking` / `systemPrompt` preset states no model either.
+ */
+export declare function deploymentStatesSubagentModel(roles: ModelRoles | undefined): boolean;
+/**
+ * The deployment's stated subagent tier as a resolved `Model` — for a spawn lane that needs the concrete
+ * model up front (the workflow lane keys call identity and the display label on it), so both lanes read the
+ * same rule: `undefined` when the deployment stated nothing (the caller then falls to the parent's model),
+ * else the role chain's answer for `subagent`. A stated ref the catalog cannot resolve throws here, loudly,
+ * exactly where a child's own prepare would have thrown.
+ */
+export declare function deploymentSubagentTierModel(deps: {
+    models?: Record<string, Model>;
+    roles?: ModelRoles;
+} | undefined): Model | undefined;
+/**
+ * The child run's model seat — ONE rule for every engine-spawned run (the delegation child at
+ * `buildChildSpec`, the observer sidecar): an EXPLICIT model for this spawn wins (per-call `model`, the
+ * agent definition's `model`, the tool-level `model`); else a deployment that STATED a subagent tier gets
+ * it (`{ modelRole: "subagent" }` — the role chain resolves the stated entry, `select` forms included);
+ * else the child runs on the PARENT run's effective model (the caller's current `Model` object, so
+ * per-model routing/credentials ride along); else — no parent model readable, which only happens outside
+ * a Runner-enriched ctx — the bare role, whose chain ends at the deployment default.
+ *
+ * The role identity `modelRole: "subagent"` stays on every non-explicit seat: the explicit-model branch of
+ * `resolveTaskModel` keys the role's `systemPrompt` / `thinking` presets on it, so a deployment's
+ * `roles.subagent` preset is not lost when the MODEL is inherited from the parent.
+ *
+ * Why "default" was the wrong last resort: `FALLBACK.subagent = ["default"]` resolves to the deployment's
+ * boot default, which is not the model the parent run was switched to — a run whose main turn was moved to
+ * model B by the caller spawned children on boot model A (and a deployment whose boot default was removed
+ * from the roster spawned children that failed at prepare). The parent's effective model is the honest
+ * default; the deployment's stated tier keeps outranking it because that statement is operator intent.
+ */
+/** The seat: an explicit ref alone, or the role identity with an optional inherited Model (see {@link childModelSeat}). */
+export type ChildModelSeat = {
+    model: ModelRef;
+    modelRole?: undefined;
+} | {
+    modelRole: "subagent";
+    model?: Model;
+};
+export declare function childModelSeat(explicit: ModelRef | undefined, deploymentStated: boolean, parent: Model | undefined): ChildModelSeat;

package/dist/agents/child-model-seat.js

@@ -0,0 +1,34 @@
+import { resolveTaskModel } from "../core/roles.js";
+export function runnerRoleMap(runner) {
+    try {
+        return runner?.agentCatalog?.roles;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function deploymentStatesSubagentModel(roles) {
+    const s = roles?.subagent;
+    if (s == null)
+        return false;
+    if (typeof s === "string")
+        return s !== "default";
+    if ("id" in s && "api" in s)
+        return true;
+    const cfg = s;
+    if (cfg.model !== undefined)
+        return cfg.model !== "default";
+    return cfg.select !== undefined;
+}
+export function deploymentSubagentTierModel(deps) {
+    return deps !== undefined && deploymentStatesSubagentModel(deps.roles) ? resolveTaskModel({ modelRole: "subagent" }, deps).model : undefined;
+}
+export function childModelSeat(explicit, deploymentStated, parent) {
+    if (explicit !== undefined)
+        return { model: explicit };
+    if (deploymentStated)
+        return { modelRole: "subagent" };
+    if (parent !== undefined)
+        return { modelRole: "subagent", model: parent };
+    return { modelRole: "subagent" };
+}

package/dist/agents/subagent.d.ts

@@ -1,5 +1,6 @@
 import type { RunInternals, RunnerSelfSeat } from "../core/runner/contracts.js";
 import type { AgentDefinition, Model, ModelRef, TaskLimits, TerminalCause, ToolSpec } from "../core/types.js";
+export { deploymentSubagentTierModel } from "./child-model-seat.js";
 import { type ExecutionEnv } from "../internal/harness.js";
 import type { TaskNotificationPayload } from "../core/task-notification.js";
 import { RETAIN_DEFAULT_TTL_MS, RETAIN_DEFAULT_MAX } from "../config/defaults.js";
@@ -679,12 +680,13 @@ export interface SubagentToolOptions {
          */
         ensureChildSessionDurable?: (sessionId: string) => Promise<void>;
     };
-    /** Model the child runs on. If omitted, the child resolves the `subagent` role (→ `default`). */
+    /** Model the child runs on when neither the call nor the agent definition names one (the tool-level explicit seat).
+     *  Omitted too ⇒ the deployment's stated `roles.subagent` tier, else the parent run's effective model (`childModelSeat`). */
     model?: ModelRef;
     /**
      * Declarative sub-agents the model can pick from (design/38 1B). When set, the tool exposes an `agent`
      * parameter (enum of these names) and the chosen definition's config builds the child task — its
-     * `allowTools`/`denyTools` REPLACE the tool-level ones, `model` omitted = inherit the caller's model.
+     * `allowTools`/`denyTools` REPLACE the tool-level ones, `model` omitted = tool-level `model` > stated `roles.subagent` tier > the caller's model (`childModelSeat`).
      * design/141 件A: when OMITTED, defaults to the runner's deployment catalog (`RunnerDeps.agents`) —
      * one Runner, one registry across the Agent-tool and workflow lanes. Pass explicitly to narrow.
      */

package/dist/agents/subagent.js

@@ -7,6 +7,8 @@ import { newDelegationProvenanceAggregate, reduceDelegationAttestation } from ".
 import { registerDelegationLaunch, replayExternalSettlementEffects, settleDelegation } from "../core/memory-engine/delegation-settlement.js";
 import { enqueueMemoryAnnouncement } from "../core/memory-engine/layout.js";
 import { resolveModel, resolveModelDisplayLabel } from "../core/roles.js";
+import { childModelSeat, deploymentStatesSubagentModel, runnerRoleMap } from "./child-model-seat.js";
+export { deploymentSubagentTierModel } from "./child-model-seat.js";
 import { OUTPUT_TOOL_NAME, REPORT_BLOCKED_TOOL_NAME } from "../core/runner/synthetic-tools.js";
 import { TOOL_SEARCH_NAME } from "../core/runner/tool-disclosure.js";
 import { OFFLOAD_TOOL_NAME } from "../core/tool-result-store.js";
@@ -1466,7 +1468,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. 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 for this agent. Takes precedence over the agent definition's model. If omitted, uses the agent definition's model, else the deployment's subagent tier, else 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", {
@@ -1784,9 +1786,9 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
             const childTools = def
                 ? resolveToolSubset(childPool, def.allowTools, def.denyTools)
                 : resolveToolSubset(childPool, opts.allowTools, opts.denyTools);
-            let childModel = wantsFork
-                ? ctx.model ?? opts.model
-                : perCallModel ?? (def ? (def.model ?? ctx.model ?? opts.model) : opts.model);
+            const explicitModelChain = wantsFork ? [ctx.model, opts.model] : [perCallModel, def?.model, opts.model];
+            let childModel = explicitModelChain.find((c) => c !== undefined);
+            const deploymentStatedSubagentModel = deploymentStatesSubagentModel(runnerRoleMap(opts.runner));
             if (reviveClaim !== undefined && typeof childModel === "string") {
                 const resolvable = (ref) => {
                     try {
@@ -1799,24 +1801,26 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                 };
                 if (!resolvable(childModel)) {
                     const dead = childModel;
-                    const rest = def !== undefined ? [ctx.model, opts.model] : [opts.model];
+                    const rest = explicitModelChain.slice(explicitModelChain.indexOf(dead) + 1);
                     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"
+            const childSeat = childModelSeat(childModel, deploymentStatedSubagentModel, ctx.model);
+            const seatModel = childSeat.model;
+            const spawnModel = typeof seatModel === "string"
                 ? (() => {
                     try {
-                        return resolveModel(childModel, judgedModels).id;
+                        return resolveModel(seatModel, judgedModels).id;
                     }
                     catch {
-                        return resolveModelDisplayLabel(childModel);
+                        return resolveModelDisplayLabel(seatModel);
                     }
                 })()
-                : childModel?.id;
-            const rowModelKey = perCallModel !== undefined ? requestedModel ?? perCallModel.id : typeof childModel === "string" ? childModel : childModel?.id;
+                : seatModel?.id;
+            const rowModelKey = perCallModel !== undefined ? requestedModel ?? perCallModel.id : typeof seatModel === "string" ? seatModel : seatModel?.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;
@@ -1888,7 +1892,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                     sessionId: sid,
                     ...(resume ? { requireExistingSession: true } : {}),
                     objective: objectiveText,
-                    ...(ctx.model !== undefined ? { model: ctx.model } : { modelRole: "subagent" }),
+                    ...childModelSeat(undefined, deploymentStatesSubagentModel(runnerRoleMap(opts.runner)), ctx.model),
                     ...(observerDef.systemPrompt !== undefined && !resume ? { systemPrompt: observerDef.systemPrompt } : {}),
                     ...(ctx.principal !== undefined ? { principal: ctx.principal } : {}),
                     ...(ctx.getApiKeyAndHeaders !== undefined ? { getApiKeyAndHeaders: ctx.getApiKeyAndHeaders } : {}),
@@ -2140,7 +2144,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                 : undefined;
             const buildChildSpec = (signal) => ({
                 objective: prompt,
-                ...(childModel ? { model: childModel } : { modelRole: "subagent" }),
+                ...childSeat,
                 ...(childThinking !== undefined ? { thinking: childThinking } : {}),
                 tools: childTools,
                 systemPrompt: childSystemPrompt,

package/dist/core/roles.d.ts

@@ -98,6 +98,14 @@ export interface ResolvedRole {
  * Resolve the model (and default thinking) for a task. Explicit `spec.model` wins; otherwise walk the
  * `modelRole`'s fallback chain over the merged roles (task overrides runner) and use the first role
  * that supplies a model. Throws a helpful error if nothing resolves.
+ *
+ * @contract roles.side_channels_deployment_only — an engine SIDE CHANNEL (the auto-mode classifier,
+ * the compaction/summarize lane, memory consolidation, next-prompt suggestion) resolves here with a
+ * `modelRole` and NO run model: it runs on the deployment's roles alone — the boot default at the end of
+ * its chain — and never follows the model a run was switched to. Only a run's CHILDREN follow the parent:
+ * the delegation seat (`childModelSeat`) passes the parent's `Model` as `spec.model` with the role kept
+ * on `modelRole`, so the role's presets still apply. A side channel that must follow a run passes that
+ * run's model explicitly; nothing here infers it.
  */
 export declare function resolveTaskModel(spec: {
     model?: ModelRef;

package/dist/core/runner/contracts.d.ts

@@ -43,7 +43,7 @@ import type { SystemInjectionPriority, TaskNotificationPayload } from "../task-n
 import type { OnAsk, PermissionResult, ResolvedAsk, ToolCallRequest, ToolPolicy } from "../tool-policy.js";
 import type { RemoteExecutionEnv, SnapshotId, WorkspaceHandle } from "../remote-env.js";
 import type { ToolDisclosureManifest } from "../trace.js";
-import type { AgentDefinition, Brain, CompactOutcome, NestedUsageAccum, RunnerDeps, TaskEvent, TaskResult, TaskSpec, TaskStream, ToolActivity, ToolEffect } from "../types.js";
+import type { AgentDefinition, Brain, CompactOutcome, ModelRoles, NestedUsageAccum, RunnerDeps, TaskEvent, TaskResult, TaskSpec, TaskStream, ToolActivity, ToolEffect } from "../types.js";
 import type { WiringManifest } from "../wiring-manifest.js";
 import type { ActiveSkillFrame } from "./active-skill-scope.js";
 import type { BudgetAxis } from "./assemble-result.js";
@@ -2377,11 +2377,12 @@ export interface RunnerDepsSeat {
 export interface RunnerSelfSeat {
     /** The session store this Runner was constructed over — the delegation tools acquire / release / fork through it. */
     readonly sessions: SessionStore;
-    /** The deployment agent + model catalog, READ-ONLY (a fresh copy per read; the definitions are the shared objects). */
+    /** The deployment agent + model catalog, READ-ONLY (a fresh copy per read; the definitions are the shared objects); `roles` = `RunnerDeps.roles` (the delegation seat's `childModelSeat` reads `roles.subagent`). */
     readonly agentCatalog: {
         agents?: AgentDefinition[];
         builtinAgents?: boolean;
         models?: Record<string, Model>;
+        roles?: ModelRoles;
     };
     /** The deployment-level gating baseline (deps toolPolicy / hooks) as delegate wrappers — for assemblers that compose with it. */
     readonly gateBaseline: {

package/dist/core/runner/prepare-caps-and-workflow.js

@@ -1,6 +1,6 @@
 import { isSyntheticApiErrorMessage } from "../../internal/harness.js";
 import { createHash } from "node:crypto";
-import { forkGovernanceDenial } from "../../agents/subagent.js";
+import { deploymentSubagentTierModel, forkGovernanceDenial } from "../../agents/subagent.js";
 import { CROSS_SESSION_CLASSIFIER_RULE } from "../../agents/cross-session-envelope.js";
 import { createRunWorkflowTool } from "../../orchestration/run-workflow-tool.js";
 import { isSelfOrchestrationActive } from "../../orchestration/workflow-script-runner.js";
@@ -243,7 +243,7 @@ export async function prepareCapsAndWorkflow(input) {
             taskOwner: hostTaskId,
             limits: deps.workflowLimits,
             sourceTaskId: hostTaskId,
-            parentModel: () => harnessRef.current?.getModel(),
+            parentModel: () => deploymentSubagentTierModel(runnerSelf.agentCatalog) ?? harnessRef.current?.getModel(),
             ...(spec.getApiKeyAndHeaders !== undefined ? { parentGetApiKeyAndHeaders: spec.getApiKeyAndHeaders } : {}),
             ...(frozenOnAsk !== undefined ? { parentOnAsk: frozenOnAsk } : {}),
             principal: spec.principal,

package/dist/core/runner/runtask.d.ts

@@ -3,7 +3,7 @@ import { type CheckpointToken, type ResumeOutcome } from "../checkpoint-store.js
 import { type TaskOutcome } from "../task-outcome.js";
 import { type SideQuerySpec, type SideQueryResult } from "../side-query.js";
 import type { SessionStore } from "../session.js";
-import type { AgentDefinition, ModelRef, RunnerDeps, TaskEvent, TaskResult, TaskSpec, TaskStream } from "../types.js";
+import type { AgentDefinition, ModelRef, ModelRoles, RunnerDeps, TaskEvent, TaskResult, TaskSpec, TaskStream } from "../types.js";
 import type { ResumeRun, ResumeTaskConfig, RunInternals, RunnerSelfSeat } from "./contracts.js";
 export type { ResumeTaskConfig } from "./contracts.js";
 /**
@@ -74,6 +74,7 @@ export declare class Runner implements RunnerSelfSeat {
         agents?: AgentDefinition[];
         builtinAgents?: boolean;
         models?: Record<string, Model>;
+        roles?: ModelRoles;
     };
     /** design/125 (实现审 B1) — the deployment-level gating baseline, exposed READ-ONLY so thin
      *  assemblers over the Runner (`runSpec`) can COMPOSE with it. The task-level engine semantic is a

package/dist/core/runner/runtask.js

@@ -138,7 +138,7 @@ export class Runner {
         return {
             ...(this.deps.agents ? { agents: [...this.deps.agents] } : {}),
             ...(this.deps.builtinAgents !== undefined ? { builtinAgents: this.deps.builtinAgents } : {}),
-            ...(this.deps.models ? { models: { ...this.deps.models } } : {}),
+            ...(this.deps.models ? { models: { ...this.deps.models } } : {}), ...(this.deps.roles ? { roles: { ...this.deps.roles } } : {}),
         };
     }
     get gateBaseline() {

package/dist/orchestration/workflow.js

@@ -1028,13 +1028,22 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
         const phaseInstance = resolveAgentPhase(agentOpts.phase);
         const groupId = currentGroup;
         const typeDefModel = agentOpts.agentType !== undefined ? agentRegistry.find((d) => d.name === agentOpts.agentType)?.model : undefined;
-        const inheritedModelSnap = spec.model === undefined && typeDefModel === undefined ? opts.defaultModel?.() : undefined;
+        let inheritedModelSnap;
+        let inheritedModelError;
+        if (spec.model === undefined && typeDefModel === undefined) {
+            try {
+                inheritedModelSnap = opts.defaultModel?.();
+            }
+            catch (err) {
+                inheritedModelError = err instanceof Error ? err : new Error(String(err));
+            }
+        }
         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 specForLabel = spec.model === undefined && typeDefModel !== undefined ? { ...spec, model: typeDefModel } : specForIdentity;
         const model = workflowModelLabel(specForLabel, modelCatalog);
-        return { label, phase, phaseInstance, groupId, inheritedModelSnap, callKey, prompt, model };
+        return { label, phase, phaseInstance, groupId, inheritedModelSnap, inheritedModelError, callKey, prompt, model };
     };
     const reviewSpawnBeforeLaunch = async (lane, label, callKey, runSpec, effectiveSignal) => {
         const review = opts.autoModeReview;
@@ -1181,7 +1190,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
         },
         async agent(spec, agentOpts = {}) {
             const effectiveSignal = assertAgentSpawnAllowed("ctx.agent", spec, agentOpts);
-            const { label, phase, phaseInstance, groupId, inheritedModelSnap, callKey, prompt, model } = prepareAgentCall(spec, agentOpts);
+            const { label, phase, phaseInstance, groupId, inheritedModelSnap, inheritedModelError, callKey, prompt, model } = prepareAgentCall(spec, agentOpts);
             if (opts.resumeFromRunId !== undefined && !diverged) {
                 const cached = replayByOrdinal[run.agents.length];
                 if (cached && cached.callKey === callKey && TERMINAL_CAUSE_IS_REPLAYABLE[cached.result.terminal.kind]) {
@@ -1265,6 +1274,8 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                 rec.startedAt = now();
                 const bornChildSessionId = resolveChildSessionIdAtSpawn(spec);
                 bceSpawn(callKey, label, agentOpts.agentType, false, bornChildSessionId, model);
+                if (inheritedModelError !== undefined)
+                    throw inheritedModelError;
                 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);
@@ -1490,6 +1501,8 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                         rec.errorCode = err.code;
                         rec.errorMessage = boundedRedactedSummary(err.message, MAX_TRANSCRIPT_CHARS);
                     }
+                    if (rec.errorMessage === undefined && err instanceof Error && err.message !== "")
+                        rec.errorMessage = boundedRedactedSummary(err.message, MAX_TRANSCRIPT_CHARS);
                     if (err instanceof WorkflowAgentStalledError && err.attempts > 1) {
                         rec.attempts = err.attempts;
                         rec.lastAttemptReason = "stalled";
@@ -1529,7 +1542,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
             if (budgetTotal !== null && spent() >= budgetTotal) {
                 throw new WorkflowBudgetExceededError(spent(), budgetTotal);
             }
-            const { label, phase, phaseInstance, groupId, inheritedModelSnap, callKey, prompt, model } = prepareAgentCall(spec, agentOpts);
+            const { label, phase, phaseInstance, groupId, inheritedModelSnap, inheritedModelError, callKey, prompt, model } = prepareAgentCall(spec, agentOpts);
             noteDivergence(run.agents.length, "ctx.agentStream results are never replayed");
             diverged = true;
             const rec = { label, callKey, ...(groupId !== undefined ? { groupId } : {}), phase, prompt, ...(model !== undefined ? { model } : {}), status: "running", queuedAt: now() };
@@ -1581,6 +1594,8 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
             bceSpawn(callKey, label, agentOpts.agentType, false, childSessionId, model);
             let stream;
             try {
+                if (inheritedModelError !== undefined)
+                    throw inheritedModelError;
                 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);
@@ -1622,6 +1637,8 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                 stream = workflowDepthStore.run({ depth: depth + 1 }, () => runner.runTaskStream(runSpec, undefined, runInternals));
             }
             catch (err) {
+                if (!finalized && rec.errorMessage === undefined && err instanceof Error && err.message !== "")
+                    rec.errorMessage = boundedRedactedSummary(err.message, MAX_TRANSCRIPT_CHARS);
                 if (!finalized && err instanceof WorkflowAgentBlockedError) {
                     rec.errorCode = WORKFLOW_SPAWN_BLOCKED_ERROR_CODE;
                     rec.errorMessage = boundedRedactedSummary(err.message, MAX_TRANSCRIPT_CHARS);

package/package.json

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