@nredd/pi-subagents 0.22.0-nredd.7 → 0.22.0-nredd.9

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,15 +42,31 @@ 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)}`;
+  // Ahead of the stats for the same reason: truncation must not cut it.
+  const resume = d.resumeHint ? [theme.fg("warning", `resume ${d.id} to continue`)] : [];
   const stats = statParts(d, showCost).map(p => theme.fg("dim", p));
-  return [head, ...stats].join(dot);
+  return [head, ...resume, ...stats].join(dot);
 }
 
 /** `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 +85,8 @@ 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.resumeHint) lines.push(indent + theme.fg("warning", d.resumeHint));
+  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

@@ -45,7 +45,8 @@ import {
   type WorkflowEntry,
   type WorkflowRunStatus,
 } from "../workflow/progress.js";
-import type { Theme } from "./agent-widget.js";
+import { formatCompactTokens, 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,
@@ -183,13 +184,6 @@ export interface WorkflowCardInput {
  * Formatting
  * ------------------------------------------------------------------------- */
 
-/** `18.4k` / `1.2M` — bare magnitude, since the row already reads as a stat. */
-export function formatCompactTokens(count: number): string {
-  if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(1)}M`;
-  if (count >= 1_000) return `${(count / 1_000).toFixed(1)}k`;
-  return `${count}`;
-}
-
 /**
  * One label for the model pair. A fallback that never differed from the primary
  * would just be noise, so it only shows when the run actually has two models in
@@ -355,12 +349,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 +367,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

@@ -61,11 +61,11 @@ import {
   type WorkflowDisplayState,
   type WorkflowEntry,
 } from "../workflow/progress.js";
-import { SPINNER, type Theme } from "./agent-widget.js";
+import { formatCompactTokens, SPINNER, type Theme } from "./agent-widget.js";
+import { boundedWrappedRows, fallbackFlagText, hasFallback, withLeadingFlag } from "./fallback-flag.js";
 import {
   ASCII_GLYPHS,
   clampLine,
-  formatCompactTokens,
   formatModel,
   formatThinking,
   REPLAYED_ANNOTATION,
@@ -104,6 +104,8 @@ export const MIN_PANE_BODY_ROWS = 6;
 export const PROMPT_COLLAPSED_LINES = 4;
 /** Spinner cadence. Unlike the card's 1s header tick, this row really animates. */
 export const WORKFLOW_DIALOG_SPINNER_MS = 80;
+/** Maximum physical detail rows a fallback note may occupy. */
+const MODEL_NOTE_ROWS = 4;
 
 /* ------------------------------------------------------------------------- *
  * Glyphs
@@ -458,12 +460,6 @@ export function leftPaneWidth(width: number): number {
   return Math.max(1, Math.min(LEFT_PANE_WIDTH, Math.floor(available / 3), available - 1));
 }
 
-/** Fill a title out to the cell width with rule, so the corners stay put. */
-function padTitle(line: WorkflowCardLine, width: number, horizontal: string): WorkflowCardLine {
-  const gap = Math.max(0, width - lineWidth(line));
-  return gap > 0 ? [...line, { text: horizontal.repeat(gap), color: "dim" }] : line;
-}
-
 /** One pane row, padded to exactly `width` so the frame stays vertical. */
 function padCell(line: WorkflowCardLine, width: number): WorkflowCardLine {
   const clamped = clampLine(line, width);
@@ -518,9 +514,9 @@ function paneFrame(options: {
   const lines: WorkflowCardLine[] = [];
   lines.push([
     { text: box.topLeft, color: "dim" },
-    ...padTitle(frameTitle(options.leftTitle, left, glyphs), left, box.horizontal),
+    ...frameTitle(options.leftTitle, left, glyphs),
     { text: box.topTee, color: "dim" },
-    ...padTitle(frameTitle(options.rightTitle, right, glyphs), right, box.horizontal),
+    ...frameTitle(options.rightTitle, right, glyphs),
     { text: box.topRight, color: "dim" },
   ]);
 
@@ -637,16 +633,33 @@ function agentRow(options: {
 }): WorkflowCardLine {
   const { entry, selected, glyphs, width } = options;
   const display = displayState(entry, options.workflowActive);
-  const head: WorkflowCardLine = [
+  const prefix: WorkflowCardLine = [
     { text: " " },
     { text: selected ? glyphs.pointer : " ", color: "accent" },
     { text: " " },
     dialogRowGlyph(display, glyphs, options.spinnerFrame),
     { text: " " },
+  ];
+  const flag = entry.modelTier || hasFallback(entry) ? fallbackFlagText(1, entry) : "";
+  const flagColor = hasFallback(entry) ? "warning" as const : "dim" as const;
+  // The narrow pane holds the label and nothing else; reserve its status prefix,
+  // then let the shared flag degrade rather than clipping it to `[fal…`.
+  if (options.compact && flag) {
+    const flagWidth = Math.max(0, width - lineWidth(prefix));
+    const compactFlag = withLeadingFlag("", flag, "", flagWidth);
+    const labelWidth = Math.max(0, flagWidth - visibleWidth(compactFlag) - 1);
+    const label = truncateToWidth(entry.label, labelWidth, "");
+    return [
+      ...prefix,
+      { text: compactFlag, color: flagColor },
+      ...(label ? [{ text: ` ${label}`, color: selected ? "accent" as const : undefined }] : []),
+    ];
+  }
+  const head: WorkflowCardLine = [
+    ...prefix,
+    ...(flag ? [{ text: `${flag} `, color: flagColor }] : []),
     { text: entry.label, color: selected ? "accent" : undefined },
   ];
-  // The narrow pane holds the label and nothing else; there is no room for a
-  // stat tail, and clamping one would just spend columns on a truncated word.
   if (options.compact) return clampLine(head, width);
 
   const model = formatModel(entry);
@@ -796,6 +809,16 @@ 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.
+    // Bound physical rows, not text width: a configured value can contain
+    // newlines, each of which otherwise displaces the final diagnosis below the
+    // pane's fixed row budget.
+    if (entry.modelNote) {
+      const noteWidth = Math.max(1, rightWidth - 1);
+      for (const line of boundedWrappedRows(entry.modelNote, noteWidth, MODEL_NOTE_ROWS, glyphs.ellipsis)) {
+        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,15 +162,11 @@ 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. */
-const GATE_SHELL: readonly [string, string] =
-  process.platform === "win32" ? ["cmd", "/c"] : ["sh", "-c"];
-
 export function createWorkflowHost(deps: WorkflowHostOptions): WorkflowHost {
   const { pi, ctx, manager } = deps;
   /** Runtime agent id → the manager record it spawned. Never pruned mid-run. */
@@ -174,7 +185,10 @@ export function createWorkflowHost(deps: WorkflowHostOptions): WorkflowHost {
    * decided from one behaviour, whichever route the command took.
    */
   async function executeGate(command: string, cwd: string): Promise<WorkflowGateResult> {
-    const result = await pi.exec(GATE_SHELL[0], [GATE_SHELL[1], command], {
+    // The shell a user would type the command into. Read per call rather than
+    // at import, so the choice follows the platform the gate actually runs on.
+    const [shell, flag] = process.platform === "win32" ? ["cmd", "/c"] : ["sh", "-c"];
+    const result = await pi.exec(shell, [flag, command], {
       cwd,
       timeout: deps.gateTimeoutMs ?? DEFAULT_GATE_TIMEOUT_MS,
       ...(deps.signal !== undefined ? { signal: deps.signal } : {}),
@@ -196,45 +210,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 +284,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 +330,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 +355,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 +376,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 +384,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/meta.ts

@@ -38,6 +38,8 @@ export interface WorkflowMeta {
 
 export interface MetaExtraction {
   meta: WorkflowMeta;
+  /** Byte offset immediately after the validated meta object literal. */
+  metaEnd: number;
   /**
    * The script with the leading `export ` stripped, so `const meta = {...}`
    * compiles inside the vm. Byte offsets after the keyword are untouched, which
@@ -175,8 +177,9 @@ function scanObjectLiteral(source: string, open: number): ScanResult {
  */
 function isRegexPosition(source: string, i: number): boolean {
   let j = i - 1;
-  while (j >= 0 && /\s/.test(source[j])) j--;
-  if (j < 0) return true;
+  // Never runs off the front: the scan starts at the literal's `{`, so the
+  // walk back always stops on it or something after it.
+  while (/\s/.test(source[j])) j--;
   const prev = source[j];
   // Identifier/number/closer before `/` means division.
   return !/[\w$)\]]/.test(prev);
@@ -289,7 +292,7 @@ export function extractMeta(source: string): MetaExtraction {
   const exportAt = source.indexOf("export", declaration.index);
   const body = `${source.slice(0, exportAt)}${" ".repeat(6)}${source.slice(exportAt + 6)}`;
 
-  return { meta, body };
+  return { meta, metaEnd: close, body };
 }
 
 /**
@@ -309,7 +312,7 @@ export function workflowCallName(args: { script?: string; scriptPath?: string; n
   if (source === undefined || source === "") {
     // A path-only call would need a synchronous file read per rebuild to do
     // better than this, and the file name is what the author will recognize.
-    if (args.scriptPath !== undefined) return args.scriptPath.split(/[/\\]/).pop() ?? "workflow";
+    if (args.scriptPath !== undefined) return args.scriptPath.replace(/^[\s\S]*[/\\]/, "");
     // A saved workflow is already named by the caller; no read needed at all.
     return args.name !== undefined && args.name !== "" ? args.name : "workflow";
   }