@nredd/pi-subagents 0.22.0-nredd.6 → 0.22.0-nredd.8

package/src/ui/fleet-state.ts

@@ -0,0 +1,154 @@
+/** Session-journal authority for bounded fleet alerts and settled disclosure choices. */
+import { stripTerminalSequences } from "@earendil-works/pi-tui";
+
+export const FLEET_STATE_ENTRY = "subagents:fleet-state";
+export const FLEET_STATE_VERSION = 1;
+export const MAX_FLEET_ALERT_DETAILS = 128;
+export const MAX_COMPACT_ALERT_COUNT = 99;
+export const MAX_ALERT_ID_LENGTH = 160;
+export const MAX_ALERT_TYPE_LENGTH = 80;
+export const MAX_ALERT_DESCRIPTION_LENGTH = 240;
+const ALERT_FIELD_COUNT = 5;
+
+export type FailureKind = "error" | "aborted" | "failed" | "killed";
+/** No AgentRecord, result, session, promise or usage references may cross this boundary. */
+export interface FleetAlert {
+  id: string;
+  type: string;
+  description: string;
+  state: FailureKind;
+  timestamp: number;
+}
+export interface FleetSnapshot {
+  version: typeof FLEET_STATE_VERSION;
+  collapsed: boolean;
+  alerts: FleetAlert[];
+  overflow: Record<FailureKind, number>;
+  /** Identity history lives in the existing journal, not an unbounded UI set. */
+  transition?: { alert: FleetAlert; acknowledged: boolean };
+}
+export interface FleetJournalEntry { type: string; customType?: string; data?: unknown }
+const KINDS: readonly FailureKind[] = ["error", "aborted", "failed", "killed"];
+const emptyOverflow = (): Record<FailureKind, number> => ({ error: 0, aborted: 0, failed: 0, killed: 0 });
+
+/** Validate whole checkpoints; corrupt/unknown entries cannot partially replace valid state. */
+function snapshot(data: unknown): FleetSnapshot | undefined {
+  if (!data || typeof data !== "object") return undefined;
+  const value = data as FleetSnapshot;
+  if (value.version !== FLEET_STATE_VERSION || typeof value.collapsed !== "boolean") return undefined;
+  // Earlier disclosure-only entries are valid empty checkpoints.
+  if (value.alerts === undefined && value.overflow === undefined) return { version: FLEET_STATE_VERSION, collapsed: value.collapsed, alerts: [], overflow: emptyOverflow() };
+  if (!Array.isArray(value.alerts) || value.alerts.length > MAX_FLEET_ALERT_DETAILS || !value.alerts.every(validAlert)
+    || new Set(value.alerts.map(alert => alert.id)).size !== value.alerts.length
+    || !value.overflow || !KINDS.every(kind => Number.isSafeInteger(value.overflow[kind]) && value.overflow[kind] >= 0)
+    || (value.transition !== undefined && (!value.transition || !validAlert(value.transition.alert) || typeof value.transition.acknowledged !== "boolean"))) return undefined;
+  return value;
+}
+
+function validAlert(value: unknown): value is FleetAlert {
+  if (!value || typeof value !== "object") return false;
+  const alert = value as FleetAlert;
+  return typeof alert.id === "string" && alert.id.length > 0 && alert.id.length <= MAX_ALERT_ID_LENGTH
+    && typeof alert.type === "string" && alert.type.length <= MAX_ALERT_TYPE_LENGTH
+    && typeof alert.description === "string" && alert.description.length <= MAX_ALERT_DESCRIPTION_LENGTH
+    && Object.keys(alert).length === ALERT_FIELD_COUNT
+    && KINDS.includes(alert.state) && Number.isFinite(alert.timestamp);
+}
+
+/** Bounded strings and plain values only, including when a detached spool supplied the input. */
+export function fleetAlert(value: unknown): FleetAlert | undefined {
+  if (!value || typeof value !== "object") return undefined;
+  const record = value as { id?: unknown; type?: unknown; description?: unknown; status?: unknown; completedAt?: unknown; startedAt?: unknown };
+  if (typeof record.id !== "string" || !record.id || record.id.length > MAX_ALERT_ID_LENGTH || typeof record.type !== "string"
+    || typeof record.description !== "string" || !KINDS.includes(record.status as FailureKind)) return undefined;
+  const timestamp = record.completedAt ?? record.startedAt;
+  if (typeof timestamp !== "number" || !Number.isFinite(timestamp)) return undefined;
+  const clean = (text: string, limit: number) => stripTerminalSequences(text).replace(/[\x00-\x1f\x7f]/g, " ").slice(0, limit);
+  return { id: record.id, type: clean(record.type, MAX_ALERT_TYPE_LENGTH), description: clean(record.description, MAX_ALERT_DESCRIPTION_LENGTH), state: record.status as FailureKind, timestamp };
+}
+
+/**
+ * At most N detailed alerts plus four exact overflow counters in RAM. Each transition
+ * checkpoints bounded state. For an overflow id, scan the active branch backwards for
+ * its last transition (O(journal length) time, O(1) extra space). The host already owns
+ * that journal; no extra id/ack set, file, or global registry is retained here.
+ */
+export class FleetJournal {
+  collapsed = true;
+  private readonly details = new Map<string, FleetAlert>();
+  private overflow = emptyOverflow();
+  private entries: () => readonly FleetJournalEntry[] = () => [];
+  private append: ((state: FleetSnapshot) => void) | undefined;
+  private settledCollapsed = true;
+
+  restore(entries: () => readonly FleetJournalEntry[], append: (state: FleetSnapshot) => void): void {
+    this.entries = entries;
+    this.append = append;
+    this.details.clear();
+    this.overflow = emptyOverflow();
+    this.collapsed = true;
+    const branch = entries();
+    for (let i = branch.length - 1; i >= 0; i--) {
+      const entry = branch[i];
+      if (entry.type !== "custom" || entry.customType !== FLEET_STATE_ENTRY) continue;
+      const state = snapshot(entry.data);
+      if (!state) continue;
+      this.collapsed = state.collapsed;
+      this.overflow = { ...state.overflow };
+      for (const alert of state.alerts) this.details.set(alert.id, { ...alert });
+      break;
+    }
+    this.settledCollapsed = this.collapsed;
+  }
+
+  get alerts(): readonly FleetAlert[] { return [...this.details.values()]; }
+  get overflowCount(): number { return KINDS.reduce((sum, kind) => sum + this.overflow[kind], 0); }
+  get count(): number { return this.details.size + this.overflowCount; }
+
+  /** Duplicate notices and polling are not new failures; acknowledged ids stay read. */
+  report(alert: FleetAlert): void {
+    const detail = this.details.get(alert.id);
+    const previous = detail ? { alert: detail, acknowledged: false } : this.previous(alert.id);
+    if (previous && previous.alert.timestamp >= alert.timestamp) return;
+    // A resumed agent keeps its id. Replace its unread attempt, or reopen an
+    // acknowledged identity only for a newer failure, never for a stale notice.
+    if (previous && !previous.acknowledged) {
+      if (detail) this.details.set(alert.id, alert);
+      else { this.overflow[previous.alert.state]--; this.overflow[alert.state]++; }
+    } else if (this.details.size < MAX_FLEET_ALERT_DETAILS) this.details.set(alert.id, alert);
+    else this.overflow[alert.state]++;
+    this.write({ alert, acknowledged: false });
+  }
+
+  acknowledge(id: string): void {
+    const detail = this.details.get(id);
+    const previous = detail ? { alert: detail, acknowledged: false } : this.previous(id);
+    if (!previous || previous.acknowledged) return;
+    if (!this.details.delete(id)) this.overflow[previous.alert.state]--;
+    this.write({ alert: previous.alert, acknowledged: true });
+  }
+
+  /** Debounced by the controller; a net-no-change burst writes nothing. */
+  flushDisclosure(): void {
+    if (this.collapsed !== this.settledCollapsed) this.write();
+  }
+
+  private previous(id: string): FleetSnapshot["transition"] {
+    const branch = this.entries();
+    for (let i = branch.length - 1; i >= 0; i--) {
+      const entry = branch[i];
+      if (entry.type !== "custom" || entry.customType !== FLEET_STATE_ENTRY) continue;
+      const data = entry.data as FleetSnapshot | undefined;
+      if (data?.version === FLEET_STATE_VERSION && data.transition?.alert?.id === id) {
+        const valid = snapshot(data);
+        if (valid) return valid.transition;
+      }
+    }
+    return undefined;
+  }
+
+  private write(transition?: FleetSnapshot["transition"]): void {
+    this.append?.({ version: FLEET_STATE_VERSION, collapsed: this.collapsed, alerts: [...this.details.values()], overflow: { ...this.overflow }, ...(transition ? { transition } : {}) });
+    this.settledCollapsed = this.collapsed;
+  }
+}

package/src/ui/notification-view.ts

@@ -15,6 +15,7 @@ import { pathToFileURL } from "node:url";
 import { type Component, hyperlink, truncateToWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import type { NotificationDetails } from "../types.js";
 import { formatCost, formatMs, formatTokens, formatTurns, type Theme } from "./agent-widget.js";
+import { fallbackFlag, fallbackFlagText, hasFallback } from "./fallback-flag.js";
 
 /** Lines of the result preview shown when expanded. */
 const EXPANDED_PREVIEW_LINES = 30;
@@ -41,7 +42,10 @@ function statParts(d: NotificationDetails, showCost: boolean): string[] {
 /** `✓ desc · 12 tools · 33.8k token · ~$0.0042 · 41.2s`. */
 export function noticeSummary(d: NotificationDetails, theme: Theme, showCost: boolean): string {
   const dot = ` ${theme.fg("dim", "·")} `;
-  const head = `${icon(d, theme)} ${theme.bold(d.description)}`;
+  // Leading, before the unbounded description: the collapsed line is truncated
+  // from the right, and a substituted model must not be what gets cut.
+  const flag = fallbackFlag(theme, d) ? `${fallbackFlag(theme, d)} ` : "";
+  const head = `${icon(d, theme)} ${flag}${theme.bold(d.description)}`;
   const stats = statParts(d, showCost).map(p => theme.fg("dim", p));
   return [head, ...stats].join(dot);
 }
@@ -49,7 +53,18 @@ export function noticeSummary(d: NotificationDetails, theme: Theme, showCost: bo
 /** `3 agents finished · ✓ a, ✓ b, ✗ c`. */
 export function groupSummary(all: NotificationDetails[], theme: Theme): string {
   const names = all.map(d => `${icon(d, theme)} ${d.description}`).join(theme.fg("dim", ", "));
-  return `${theme.bold(`${all.length} agents finished`)} ${theme.fg("dim", "·")} ${names}`;
+  // In the heading, ahead of the member list that truncation eats from the end,
+  // so a fallback member listed last is still counted.
+  const groups = new Map<string, { carrier: NotificationDetails; count: number }>();
+  for (const carrier of all.filter(d => d.modelTier !== undefined || hasFallback(d))) {
+    const key = `${hasFallback(carrier)}:${fallbackFlagText(1, carrier)}`;
+    const group = groups.get(key);
+    if (group) group.count++;
+    else groups.set(key, { carrier, count: 1 });
+  }
+  const flags = [...groups.values()].map(({ carrier, count }) => fallbackFlag(theme, carrier, count)).join(" ");
+  const flag = flags ? ` ${flags}` : "";
+  return `${theme.bold(`${all.length} agents finished`)}${flag} ${theme.fg("dim", "·")} ${names}`;
 }
 
 /** The transcript as an OSC 8 hyperlink, so a click opens it. */
@@ -68,6 +83,7 @@ function detailLines(d: NotificationDetails, theme: Theme, showCost: boolean, in
   stats.push(...statParts(d, showCost));
   if (stats.length > 0) lines.push(indent + theme.fg("dim", stats.join(" · ")));
   if (d.error) lines.push(indent + theme.fg("error", d.error));
+  if (d.modelNote) lines.push(indent + theme.fg("warning", d.modelNote));
   for (const line of d.resultPreview.split("\n").slice(0, EXPANDED_PREVIEW_LINES)) {
     lines.push(indent + theme.fg("dim", line));
   }

package/src/ui/workflow-card.ts

@@ -46,6 +46,7 @@ import {
   type WorkflowRunStatus,
 } from "../workflow/progress.js";
 import type { Theme } from "./agent-widget.js";
+import { fallbackFlagText, hasFallback } from "./fallback-flag.js";
 
 /**
  * Header re-render cadence. Claude Code ticks the workflow clock once a second,
@@ -355,12 +356,15 @@ export function layoutWorkflowCard(input: WorkflowCardInput): WorkflowCardLine[]
     const rail = lastGroup ? "  " : `${glyphs.vertical} `;
     group.agents.forEach((entry, agentIndex) => {
       const lastAgent = agentIndex === group.agents.length - 1;
+      const flag = entry.modelTier || hasFallback(entry) ? fallbackFlagText(1, entry) : "";
       const segments: WorkflowCardLine = [
         { text: "  " },
         { text: rail, color: "dim" },
         { text: `${lastAgent ? glyphs.lastBranch : glyphs.branch} `, color: "dim" },
         rowGlyph(entry, glyphs),
         { text: " " },
+        // Leading, ahead of the label: the row is clamped from the right.
+        ...(flag ? [{ text: `${flag} `, color: hasFallback(entry) ? "warning" as const : "dim" as const }] : []),
       ];
 
       // Prepended rather than folded into `agentStatSegments`, which is the
@@ -370,7 +374,7 @@ export function layoutWorkflowCard(input: WorkflowCardInput): WorkflowCardLine[]
       const statParts = entry.cached
         ? [REPLAYED_ANNOTATION, ...agentStatSegments(entry)]
         : agentStatSegments(entry);
-      const pad = Math.max(0, labelColumn - visibleWidth(entry.label));
+      const pad = Math.max(0, labelColumn - visibleWidth(entry.label) - (flag ? visibleWidth(flag) + 1 : 0));
       segments.push({ text: statParts.length > 0 ? entry.label + " ".repeat(pad) : entry.label });
       for (const part of statParts) {
         segments.push({ text: " · ", color: "dim" }, { text: part, color: "dim" });

package/src/ui/workflow-dialog.ts

@@ -62,6 +62,7 @@ import {
   type WorkflowEntry,
 } from "../workflow/progress.js";
 import { SPINNER, type Theme } from "./agent-widget.js";
+import { fallbackFlagText, hasFallback } from "./fallback-flag.js";
 import {
   ASCII_GLYPHS,
   clampLine,
@@ -643,6 +644,8 @@ function agentRow(options: {
     { text: " " },
     dialogRowGlyph(display, glyphs, options.spinnerFrame),
     { text: " " },
+    // Leading, ahead of the label, in both pane modes: the row clamps from the right.
+    ...(entry.modelTier || hasFallback(entry) ? [{ text: `${fallbackFlagText(1, entry)} `, color: hasFallback(entry) ? "warning" as const : "dim" as const }] : []),
     { text: entry.label, color: selected ? "accent" : undefined },
   ];
   // The narrow pane holds the label and nothing else; there is no room for a
@@ -796,6 +799,13 @@ export function layoutWorkflowDialog(input: WorkflowDialogInput): WorkflowCardLi
     if (stats.length > 0) {
       detailRows.push(clampLine([{ text: ` ${stats.join(" · ")}`, color: "dim" }], rightWidth));
     }
+    // A substituted model is never cosmetic: name the failed input and what ran.
+    // Wrapped, not clamped: this is the one place the full note is readable.
+    if (entry.modelNote) {
+      for (const line of wrapTextWithAnsi(entry.modelNote, Math.max(1, rightWidth - 1))) {
+        detailRows.push(clampLine([{ text: ` ${line}`, color: "warning" }], rightWidth));
+      }
+    }
 
     const prompt = previewLines(entry.promptPreview);
     const collapsed = !state.promptExpanded && prompt.length > PROMPT_COLLAPSED_LINES;

package/src/workflow/host.ts

@@ -36,8 +36,7 @@ import { existsSync } from "node:fs";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { AgentManager } from "../agent-manager.js";
 import { getAgentConfig, resolveSpawnType } from "../agent-types.js";
-import { configuredAgentModel, resolveModel } from "../model-resolver.js";
-import { checkModelScope } from "../model-scope.js";
+import { modelSelectionNote, selectModel } from "../model-selection.js";
 import type { AgentRecord, ThinkingLevel } from "../types.js";
 import { getLifetimeTotal } from "../usage.js";
 import type { WorkflowGateResult, WorkflowHost, WorkflowSpawnResult } from "./runtime.js";
@@ -51,6 +50,8 @@ import { resolveWorkflowSource } from "./saved.js";
 export const DEFAULT_GATE_TIMEOUT_MS = 10 * 60_000;
 
 export interface WorkflowHostOptions {
+  /** Home directory for nested saved workflows. */
+  homeDir?: string;
   pi: ExtensionAPI;
   ctx: ExtensionContext;
   manager: AgentManager;
@@ -113,10 +114,13 @@ function resolvedInfo(record: AgentRecord | undefined) {
     modelId: invocation.modelId,
     thinking: invocation.thinking,
     requestedThinking: invocation.requestedThinking,
+    // From the record, so a resumed child reports the model it actually ran on.
+    ...(modelSelectionNote(record) ? { modelNote: modelSelectionNote(record) } : {}),
+    ...(record?.modelTier ? { modelTier: record.modelTier } : {}),
   };
 }
 
-function toSpawnResult(record: AgentRecord): WorkflowSpawnResult {
+function toSpawnResult(record: AgentRecord, opts: { resumed?: boolean } = {}): WorkflowSpawnResult {
   const tokens = getLifetimeTotal(record.lifetimeUsage);
   // Reported separately from `tokens`, which is the lifetime total. The script's
   // `budget` counts *output* tokens, as Claude Code's does — billing the input
@@ -131,15 +135,26 @@ function toSpawnResult(record: AgentRecord): WorkflowSpawnResult {
     ...(cwd !== undefined ? { cwd } : {}),
   };
 
+  // Disclosed in the text/error the script reads AND as a field. A schema'd
+  // payload is JSON the script parses, so the note is only a field there.
+  const note = modelSelectionNote(record);
+  const lead = note ? `${note}\n\n` : "";
+  const modelNote = { ...(note ? { modelNote: note } : {}), ...(record.modelTier ? { modelTier: record.modelTier } : {}) };
+
   if (succeeded(record)) {
     return {
       ...common,
+      ...modelNote,
       ok: true,
       // The schema'd payload when there is one: `result` is prose, and for a
       // worktree child it has had the branch note appended, so it would not
       // parse. A child asked for a schema that produced none never reaches
       // here — `runAgent` reports that through `failure`.
-      text: record.structuredJson ?? record.result ?? "",
+      // A RESUMED child answers in prose (resume forbids `schema`), but its record
+      // still holds the original run's `structuredJson`; returning that would hand
+      // the script a stale payload with no note, and the worker only injects or
+      // logs for schema calls. So a resume reads `result` and leads with the note.
+      text: !opts.resumed && record.structuredJson !== undefined ? record.structuredJson : `${lead}${record.result ?? ""}`,
       ...(record.structuredRetried ? { structuredRetried: true } : {}),
     };
   }
@@ -147,9 +162,9 @@ function toSpawnResult(record: AgentRecord): WorkflowSpawnResult {
   // fleet list, a workflow abort. That is the same thing the workflows dialog's
   // skip action means, so it renders as skipped rather than failed.
   if (record.status === "stopped") {
-    return { ...common, ok: false, skipped: true, error: record.error ?? "Stopped." };
+    return { ...common, ...modelNote, ok: false, skipped: true, error: `${lead}${record.error ?? "Stopped."}` };
   }
-  return { ...common, ok: false, error: record.error ?? `Agent ${record.status}.` };
+  return { ...common, ...modelNote, ok: false, error: `${lead}${record.error ?? `Agent ${record.status}.`}` };
 }
 
 /** Shell used to run a `gate` command, mirroring how a user would type it. */
@@ -196,45 +211,17 @@ export function createWorkflowHost(deps: WorkflowHostOptions): WorkflowHost {
       const dispatch = resolveSpawnType(request.agentType);
       if (!dispatch.ok) return { ok: false, error: dispatch.message };
 
-      // Same precedence as the Agent tool: the caller's model wins, then the
-      // `agentModels` setting, the agent definition's is next, and the parent's
-      // is the floor. A model the script
-      // named and we cannot resolve is an error; one the definition named falls
-      // back to the parent silently, because the script never asked for it.
-      let model = ctx.model;
       const config = getAgentConfig(dispatch.type);
-      const modelInput = request.model ?? configuredAgentModel(dispatch.type, config?.model);
-      if (modelInput !== undefined) {
-        const resolved = resolveModel(modelInput, ctx.modelRegistry);
-        if (typeof resolved === "string") {
-          if (request.model !== undefined) return { ok: false, error: resolved };
-        } else {
-          model = resolved;
-        }
-      }
-
-      // Same scopeModels policy as the Agent tool and the nested delegation
-      // tools: a script's `agent({ model })` is a runtime LLM choice, and the
-      // script is written by the model, so it must not reach a model the user's
-      // enabledModels list excludes. `callerSupplied` keys off `request.model`
-      // and NOT `modelInput` — the latter has already absorbed the agent file's
-      // own `model:`, which is user-authored config and so earns the
-      // warn-and-proceed branch rather than a refusal.
-      const scopeVerdict = checkModelScope({
-        model,
-        cwd: ctx.cwd,
-        modelRegistry: ctx.modelRegistry,
-        callerSupplied: request.model !== undefined,
-        agentLabel: config?.displayName ?? dispatch.type,
-        modelInput,
+      const selection = selectModel({
+        homeDir: deps.homeDir,
+        agentType: dispatch.type, definitionModel: config?.model, paramModel: request.model,
+        parentModel: ctx.model, registry: ctx.modelRegistry, cwd: ctx.cwd, agentLabel: config?.displayName,
       });
-      // This agent's failure, not the run's — the same shape a bad agent type
-      // takes above. The script sees `null` and its siblings carry on, which is
-      // the difference between one refused model and a discarded fan-out.
-      if (scopeVerdict.kind === "error") return { ok: false, error: scopeVerdict.message };
-      if (scopeVerdict.kind === "warn" && !warnedScopeMessages.has(scopeVerdict.message)) {
-        warnedScopeMessages.add(scopeVerdict.message);
-        ctx.ui.notify(scopeVerdict.message, "warning");
+      if (typeof selection === "string") return { ok: false, error: selection };
+      const model = selection.model;
+      if (selection.scopeWarning && !warnedScopeMessages.has(selection.scopeWarning)) {
+        warnedScopeMessages.add(selection.scopeWarning);
+        ctx.ui.notify(selection.scopeWarning, "warning");
       }
 
       /**
@@ -298,6 +285,7 @@ export function createWorkflowHost(deps: WorkflowHostOptions): WorkflowHost {
           request.prompt,
           {
             description: request.label,
+            modelSelection: selection,
             // Same as the Agent tool: `isolated` comes off the agent definition.
             // Left out, a hermetic agent's script-spawned children loaded every
             // host extension and picked up its MCP and web tools.
@@ -343,6 +331,10 @@ export function createWorkflowHost(deps: WorkflowHostOptions): WorkflowHost {
             reportResolved();
           },
         );
+        if (record.modelTier) {
+          const finalInfo = resolvedInfo(record);
+          if (finalInfo) request.onResolved?.(finalInfo);
+        }
         return { ...toSpawnResult(record), ...(gate !== undefined ? { gate } : {}) };
       } catch (error) {
         // Strict worktree isolation rejects out of `awaitStartup` — the child
@@ -364,6 +356,12 @@ export function createWorkflowHost(deps: WorkflowHostOptions): WorkflowHost {
       if (id === undefined) {
         return { ok: false, error: `Cannot resume "${agentId}" — it never started.` };
       }
+      // The provenance is already on the record, so the running row shows it
+      // now rather than only once the resume has finished.
+      const existing = manager.getRecord(id);
+      if (modelSelectionNote(existing)) {
+        onResolved?.({ recordId: id, modelNote: modelSelectionNote(existing), modelTier: existing?.modelTier });
+      }
       const record = await manager.resume(id, prompt, deps.signal);
       if (record === undefined) {
         return {
@@ -379,7 +377,7 @@ export function createWorkflowHost(deps: WorkflowHostOptions): WorkflowHost {
       onResolved?.({ recordId: id });
       const info = resolvedInfo(record);
       if (info !== undefined) onResolved?.(info);
-      return toSpawnResult(record);
+      return toSpawnResult(record, { resumed: true });
     },
 
     /**
@@ -387,7 +385,7 @@ export function createWorkflowHost(deps: WorkflowHostOptions): WorkflowHost {
      * comes back is a workflow; this only finds it.
      */
     loadWorkflow(ref) {
-      return resolveWorkflowSource(ref, ctx.cwd);
+      return resolveWorkflowSource(ref, ctx.cwd, deps.homeDir);
     },
 
     // Reached only for a gate the spawn did not already run — a child with no

package/src/workflow/journal.ts

@@ -46,6 +46,7 @@
 
 import { createHash } from "node:crypto";
 import { appendFileSync, readFileSync } from "node:fs";
+import { isTierDisclosure, type TierDisclosure, tierDisclosure } from "../model-tiers.js";
 
 /** One settled agent call, as replayed. */
 export interface WorkflowJournalEntry {
@@ -57,6 +58,14 @@ export interface WorkflowJournalEntry {
   ok: boolean;
   /** The agent's answer, when it had one. */
   text?: string;
+  /**
+   * The `Note:` line when the child ran on another model than configured.
+   * Replayed with the text so a resumed run discloses it too; absent on
+   * journals written before it existed, which means "no note", not an error.
+   */
+  modelNote?: string;
+  /** The original tier outcome, retained on replay and journal-of-journal runs. */
+  modelTier?: TierDisclosure;
   /**
    * Whether the call continued an earlier child (`agent({ resume })`).
    *
@@ -144,7 +153,8 @@ export function readJournal(path: string): WorkflowJournalEntry[] {
 /** Append one settled call. Failure to write is not failure to run. */
 export function appendJournal(path: string, entry: WorkflowJournalEntry): void {
   try {
-    appendFileSync(path, `${JSON.stringify(entry)}\n`, "utf-8");
+    const persisted = entry.modelTier ? { ...entry, modelTier: tierDisclosure(entry.modelTier) } : entry;
+    appendFileSync(path, `${JSON.stringify(persisted)}\n`, "utf-8");
   } catch {
     // A journal that cannot be written costs a future resume, nothing more.
   }
@@ -159,6 +169,8 @@ function isEntry(value: unknown): value is WorkflowJournalEntry {
     typeof entry.key === "string" &&
     typeof entry.ok === "boolean" &&
     (entry.text === undefined || typeof entry.text === "string") &&
+    (entry.modelNote === undefined || typeof entry.modelNote === "string") &&
+    (entry.modelTier === undefined || isTierDisclosure(entry.modelTier)) &&
     (entry.resumed === undefined || entry.resumed === true)
   );
 }

package/src/workflow/progress.ts

@@ -20,6 +20,7 @@
  * unit-testable without a terminal.
  */
 
+import type { TierDisclosure } from "../model-tiers.js";
 import type { WorkflowMeta, WorkflowPhaseMeta } from "./meta.js";
 
 /** Raw entry lifecycle, as written by the runtime. */
@@ -93,6 +94,9 @@ export interface WorkflowAgentEntry {
    * it.
    */
   requestedThinking?: string;
+  /** `Note:` line set when the child ran on the parent model because its configured one did not resolve. */
+  modelNote?: string;
+  modelTier?: TierDisclosure;
   fallbackModel?: string;
   isolation?: "worktree";
   error?: string;

package/src/workflow/runtime.ts

@@ -15,6 +15,7 @@
 
 import { cpus } from "node:os";
 import { Worker } from "node:worker_threads";
+import type { TierDisclosure } from "../model-tiers.js";
 import { type JournalKeyInput, journalKey, type WorkflowJournalEntry } from "./journal.js";
 import { type CompiledSchema, compileJsonSchema } from "./json-schema.js";
 import { extractMeta, type WorkflowMeta } from "./meta.js";
@@ -95,6 +96,9 @@ export interface WorkflowSpawnRequest {
     modelId?: string;
     thinking?: string;
     requestedThinking?: string;
+    /** `Note:` line when the child ran on the parent model because its configured one did not resolve. */
+    modelNote?: string;
+    modelTier?: TierDisclosure;
   }): void;
   /**
    * Compiled from the script's `agent({ schema })`.
@@ -125,6 +129,9 @@ export interface WorkflowSpawnResult {
   text?: string;
   /** Why it failed. Present when not `ok`. */
   error?: string;
+  /** `Note:` line when the child ran on a different model than configured; also leads `text`/`error` (not a schema'd payload). */
+  modelNote?: string;
+  modelTier?: TierDisclosure;
   /** The user dismissed it rather than it failing; renders as skipped. */
   skipped?: boolean;
   tokens?: number;
@@ -315,6 +322,8 @@ export interface WorkflowRunResult {
   /** The script's return value, JSON-checked at the boundary. */
   value?: unknown;
   error?: string;
+  /** Authored-source stack, kept separately from the concise failure message. */
+  errorStack?: string;
   /** The append-only log, in emission order. */
   progress: WorkflowEntry[];
   /** Agents scheduled, including those that failed. */
@@ -733,14 +742,14 @@ export async function runWorkflow(options: RunWorkflowOptions): Promise<Workflow
       options.onProgress?.(entries);
     };
 
-    const respond = (callId: number, ok: boolean, value?: unknown, error?: string, fatal?: boolean) => {
+    const respond = (callId: number, ok: boolean, value?: unknown, error?: string, fatal?: boolean, modelNote?: string) => {
       // Cleared before the settled check: a launch answered by a run that is
       // already finishing is not an unawaited launch either.
       openLaunches.delete(callId);
       if (settled) return;
       // `spent` rides on every response, so the worker's `budget.spent()` is a
       // mirror of this number rather than a second tally of its own.
-      worker.postMessage({ type: "response", callId, ok, value, error, fatal, spent: spentOutputTokens });
+      worker.postMessage({ type: "response", callId, ok, value, error, fatal, modelNote, spent: spentOutputTokens });
     };
 
     const finish = (result: Omit<WorkflowRunResult, "meta" | "progress" | "agentCount" | "replayedCount">) => {
@@ -908,6 +917,8 @@ export async function runWorkflow(options: RunWorkflowOptions): Promise<Workflow
             // dialog to annotate it "from resume journal" rather than letting a
             // 0ms agent look like one that did the work impossibly fast.
             cached: true,
+            ...(replayed.modelNote !== undefined ? { modelNote: replayed.modelNote } : {}),
+            ...(replayed.modelTier ? { modelTier: replayed.modelTier } : {}),
             resultPreview: preview(replayedText),
           },
         ]);
@@ -915,8 +926,8 @@ export async function runWorkflow(options: RunWorkflowOptions): Promise<Workflow
         // Re-recorded so this run's journal is complete on its own terms: a
         // resume of a resume must not have to walk back through a chain of
         // earlier files to find the prefix.
-        recordJournal?.({ index, key: replayed.key, ok: true, text: replayedText });
-        respond(callId, true, replayedText);
+        recordJournal?.({ index, key: replayed.key, ok: true, text: replayedText, ...(replayed.modelNote !== undefined ? { modelNote: replayed.modelNote } : {}), ...(replayed.modelTier ? { modelTier: replayed.modelTier } : {}) });
+        respond(callId, true, replayedText, undefined, undefined, replayed.modelNote);
         return;
       }
 
@@ -992,12 +1003,16 @@ export async function runWorkflow(options: RunWorkflowOptions): Promise<Workflow
             modelId?: string;
             thinking?: string;
             requestedThinking?: string;
+            modelNote?: string;
+            modelTier?: TierDisclosure;
           }) => {
             if (info.recordId !== undefined) base.recordId = info.recordId;
             if (info.modelName !== undefined) base.model = info.modelName;
             if (info.modelId !== undefined) base.modelId = info.modelId;
             if (info.thinking !== undefined) base.thinking = info.thinking;
             if (info.requestedThinking !== undefined) base.requestedThinking = info.requestedThinking;
+            if (info.modelNote !== undefined) base.modelNote = info.modelNote;
+            if (info.modelTier !== undefined) base.modelTier = info.modelTier;
             // `base.state` is still "start", so emitting after the row reached a
             // terminal state would revert it to running under last-write-wins.
             // Not reachable from this repo's host, which reports during startup
@@ -1091,13 +1106,15 @@ export async function runWorkflow(options: RunWorkflowOptions): Promise<Workflow
             durationMs: finishedAt - startedAt,
             ...(result.tokens !== undefined ? { tokens: result.tokens } : {}),
             ...(result.toolCalls !== undefined ? { toolCalls: result.toolCalls } : {}),
+            ...(result.modelNote !== undefined ? { modelNote: result.modelNote } : {}),
+            ...(result.modelTier ? { modelTier: result.modelTier } : {}),
           };
 
           if (result.ok) {
             const text = result.text ?? "";
             emit([{ ...common, state: "done", resultPreview: preview(text) }]);
-            recordJournal?.({ index, key, ok: true, text, ...resumeMark });
-            respond(callId, true, text);
+            recordJournal?.({ index, key, ok: true, text, ...(result.modelNote !== undefined ? { modelNote: result.modelNote } : {}), ...(result.modelTier ? { modelTier: result.modelTier } : {}), ...resumeMark });
+            respond(callId, true, text, undefined, undefined, result.modelNote);
             return;
           }
           // Recorded as a failure rather than left out: a gap would be read as an
@@ -1118,7 +1135,7 @@ export async function runWorkflow(options: RunWorkflowOptions): Promise<Workflow
               ...(result.skipped ? { skipped: true } : {}),
             },
           ]);
-          respond(callId, true, null);
+          respond(callId, true, null, undefined, undefined, result.modelNote);
           return;
         }
       } finally {
@@ -1198,7 +1215,7 @@ export async function runWorkflow(options: RunWorkflowOptions): Promise<Workflow
           break;
         }
         case "error":
-          finish({ status: "failed", error: message.message });
+          finish({ status: "failed", error: message.message, errorStack: message.stack });
           break;
       }
     });