pi-ultracode 0.1.2 → 0.3.0

package/src/prompts.ts

@@ -13,18 +13,13 @@ export const ULTRACODE_TAGLINE = "max thinking + dynamic workflow orchestration"
  * The standing system-prompt block injected on every turn while ultracode is on.
  * Mirrors the "Ultracode" section of the Workflow tool contract.
  */
-export function ultracodeSystemBlock(opts: { budgetTotal: number | null }): string {
-  const budgetLine =
-    opts.budgetTotal != null
-      ? `\n- Token budget for this session: ~${formatTokens(opts.budgetTotal)} output tokens. Treat it as a hard ceiling — scale workflow depth (fleet size, verification rounds) to fit it, and stop spawning agents as it runs out.`
-      : "";
-
+export function ultracodeSystemBlock(): string {
   return [
     "<ultracode>",
     "Ultracode is ON. This opt-in is standing: author and run a workflow for every substantive task by default.",
     "",
-    "The goal is the most exhaustive, correct answer you can produce — token cost is not a constraint.",
-    "For multi-phase work (understand → design → implement → review), run several workflows in sequence — one per phase — so you stay in the loop between them, reading each result before deciding the next phase.",
+    "The goal is a bounded, exhaustive-enough, correct answer: choose explicit fan-out and round limits before launching work.",
+    "For multi-phase work (understand → design → implement → review), prefer one bounded workflow and inspect the result before deciding whether another workflow is justified. Do not run consecutive workflows by default; continue only when new evidence changes the plan.",
     "",
     "Lean toward orchestrating with the workflow tool and adversarially verifying your findings, unless the work is trivial or already verified. Solo (no workflow) only on conversational turns or trivial mechanical edits.",
     "",
@@ -32,12 +27,11 @@ export function ultracodeSystemBlock(opts: { budgetTotal: number | null }): stri
     "- Adversarial verify: spawn N independent skeptics per finding, each prompted to REFUTE it; kill the finding if a majority refute. Stops plausible-but-wrong findings from surviving.",
     "- Perspective-diverse verify: when a finding can fail in more than one way, give each verifier a distinct lens (correctness, security, performance, does-it-reproduce) instead of N identical refuters.",
     "- Multi-modal sweep: parallel agents each searching a different way (by-container, by-content, by-entity, by-time); each is blind to what the others surface.",
-    "- Loop-until-dry: for unknown-size discovery (bugs, edge cases), keep spawning finders until K consecutive rounds return nothing new.",
+    "- Loop-until-dry: for unknown-size discovery (bugs, edge cases), run at most 2 rounds by default (3 only when the user explicitly asks for comprehensive coverage); stop sooner when no fresh evidence appears.",
     "- Completeness critic: a final agent that asks \"what's missing — a modality not run, a claim unverified, a source unread?\" What it finds becomes the next round of work.",
     "- No silent caps: if a workflow bounds coverage (top-N, no-retry, sampling), log() what was dropped.",
     "",
-    "Scale to the task: \"find any bugs\" → a few finders, single-vote verify; \"thoroughly audit\" / \"be comprehensive\" → larger finder pool, 3–5 vote adversarial pass, a synthesis stage." +
-      budgetLine,
+    "Scale to the task: \"find any bugs\" → a few finders, single-vote verify; \"thoroughly audit\" / \"be comprehensive\" → a larger but explicit finder pool, 3–5 vote adversarial pass, and a synthesis stage within maxAgents.",
     "</ultracode>",
   ].join("\n");
 }
@@ -49,35 +43,31 @@ export const ULTRACODE_ACTIVE_REMINDER =
 /** Tool description for the `workflow` tool. */
 export const WORKFLOW_TOOL_DESCRIPTION = [
   "Execute a deterministic JavaScript workflow that orchestrates multiple subagents to be comprehensive (decompose and cover in parallel), confident (independent perspectives and adversarial checks before committing), or to take on scale one context can't hold (migrations, audits, broad sweeps).",
-  "`script` is required raw JavaScript. It must begin with `export const meta = { name, description }` (a pure literal) and must call agent() at least once.",
-  "Available globals: agent(prompt, opts), parallel(thunks), pipeline(items, ...stages), phase(title), log(message), workflow(nameOrRef, args), args, cwd, budget.",
+  "Each invocation must provide workflow source via `script`, `scriptPath`, or `name`. Inline `script` must be raw JavaScript (no Markdown fences) beginning with `export const meta = { name, description }` (a pure literal) and should call agent() at least once for useful orchestration.",
+  "Available globals: agent(prompt, opts), parallel(thunks, options?), pipeline(items, ...stages), phase(title), log(message), workflow(nameOrRef, args), args, cwd. The tool accepts maxAgents (default 128, max 1024) as a lifetime live-agent admission cap across resumes, not a token budget; cache replay is free.",
 ].join(" ");
 
 /** One-line snippet for the Available tools section. */
 export const WORKFLOW_PROMPT_SNIPPET =
-  "Run a deterministic JS workflow that fans out subagents. Header: export const meta = { name: 'snake_case', description: '...' }. Globals: agent/parallel/pipeline/phase/log/workflow/args/budget.";
+  "Run a deterministic JS workflow that fans out subagents. Header: export const meta = { name: 'snake_case', description: '...' }. Globals: agent/parallel/pipeline/phase/log/workflow/args/cwd.";
 
 /** Guideline bullets appended to the Guidelines section when the tool is active. */
 export const WORKFLOW_GUIDELINES: string[] = [
   "While Ultracode is enabled, use the workflow tool to decompose-and-cover in parallel, gather independent perspectives that adversarially verify each other, or take on scale one context can't hold.",
-  "For the workflow tool, pass one raw JavaScript string in the required `script` parameter; no Markdown fences, no prose around the script.",
+  "For the workflow tool, provide workflow source with `script`, `scriptPath`, or `name`. Inline `script` must be one raw JavaScript string: no Markdown fences, no prose around the script.",
   "For the workflow tool, the script's first statement must be `export const meta = { name: 'short_snake_case', description: 'non-empty human description' }`. meta must be a pure literal: no variables, function calls, spreads, or template interpolation. meta.phases is optional and should mirror your phase() titles.",
-  "For the workflow tool, write plain JavaScript after the meta export. No TypeScript syntax, imports, require(), fs, network, Date.now(), Math.random(), or new Date() (they break determinism and resume). Stamp timestamps after the workflow returns; vary randomness by agent index.",
-  "For the workflow tool, every workflow must call agent() at least once. Each agent() call should pass a short unique label (2-5 words) so live status and error reporting stay readable.",
+  "For the workflow tool, write plain JavaScript after the meta export. No TypeScript syntax, imports, require(), fs, network, Date/Intl/Temporal, Math.random(), binary memory constructors, WebAssembly, or dynamic method calls such as value[key](...) (they bypass deterministic checks or resource bounds). Stamp timestamps after the workflow returns; vary randomness by agent index.",
+  "For the workflow tool, a useful workflow should call agent() at least once. Each agent() call should pass a short unique label (2-5 words) so live status and error reporting stay readable.",
   "For the workflow tool, DEFAULT TO pipeline(items, ...stages): items flow through stages independently with no barrier, so item A can be in stage 3 while item B is still in stage 1. Only use parallel() (a barrier that awaits all thunks) when a later stage genuinely needs ALL prior results together (dedup/merge across the full set, early-exit on zero, cross-item comparison).",
-  "For the workflow tool, parallel() takes functions, not promises: `await parallel(items.map(item => () => agent('...', { label: '...' })))`, never `await parallel(items.map(item => agent(...)))`. Results are returned in input order; a thunk that throws resolves to null, so .filter(Boolean) before using results.",
+  "For the workflow tool, parallel() takes functions, not promises: `await parallel(items.map(item => () => agent('...', { label: '...' })))`, never `await parallel(items.map(item => agent(...)))`. It reserves `options.reserveAgents ?? thunks.length` agent slots before any thunk starts; reserveAgents must cover every agent call in the panel because calls beyond it are fatal. Results are returned in input order; a normal thunk throw resolves to null, while policy/cancellation failures are fatal.",
   "For the workflow tool, pipeline(items, ...stages) passes each stage (previousValue, originalItem, index). A stage that throws drops that item to null and skips its remaining stages.",
-  "For the workflow tool, if agent() needs machine-readable output pass a plain JSON Schema via opts.schema; agent() then returns the validated object. Use JSON Schema, not TypeScript or TypeBox constructors.",
+  "For the workflow tool, if agent() needs machine-readable output pass an inline JSON Schema via opts.schema; agent() then returns the validated object. Use only the bounded subset: types, object/array structure, enum/const, anyOf/allOf, length/numeric constraints, and annotations. Unknown keywords, $ref variants, oneOf, format, pattern, and patternProperties are rejected. Keep schemas under 256 KiB / 64 levels and every agent/workflow output under 2 MiB. Use JSON Schema, not TypeScript or TypeBox constructors.",
   "For the workflow tool, when agent() is called WITHOUT a schema, its return value is the subagent's final assistant text (the last text the subagent produced). With a schema it returns the validated structured_output object. Prefer a schema for machine-readable results; use the text form only for prose summaries.",
   "For the workflow tool, agent opts also accept: model (override the subagent model by pattern), agentType (use a custom subagent role/system-prompt), isolation:'worktree' (run the agent in an isolated git worktree — use ONLY when agents mutate files in parallel and would conflict), and phase (assign the agent to a progress group explicitly inside parallel()/pipeline()).",
-  "For the workflow tool, use budget for dynamic depth: `while (budget.total && budget.remaining() > 50000) { ... }`. Guard the loop on budget.total — with no budget set, remaining() is Infinity and the loop runs to the agent cap.",
-  "For the workflow tool, workflow(nameOrRef, args) runs a saved workflow (by name) or a scriptPath inline as a sub-step, sharing this run's concurrency cap, agent counter, and token budget. Nesting is one level only.",
-  "For the workflow tool, failed agent()/parallel()/pipeline() branches return null and log the failure (unless the whole run is aborted). Check for nulls before synthesizing conclusions, and prefer a final synthesis/assertion agent that returns a compact JSON-serializable verdict.",
+  "For the workflow tool, workflow(nameOrRef, args) runs a saved workflow (by name) or a scriptPath inline as a sub-step, sharing this run's concurrency, maxAgents, active reservations, and agent counter. Nesting is one level only. Child subagent sessions explicitly exclude the workflow tool and cannot start an independent recursive workflow chain.",
+  "For workflow resumeFromRunId, reuse the exact same script and args. Resume is immutable, successful calls replay by stable structural call path, and maxAgents may only stay the same or increase; changed work must start a new run.",
+  "For the workflow tool, failed agent()/parallel()/pipeline() branches return null and log the failure (unless the whole run is aborted or a policy limit is hit). Check for nulls before synthesizing conclusions, and prefer a final synthesis/assertion agent that returns a compact JSON-serializable verdict.",
+  "For the workflow tool, directly await or return every orchestration promise (agent/parallel/pipeline/workflow). Native .then/.catch/.finally chains and Promise.all/allSettled/race/any are rejected; use parallel() or pipeline() so call identity stays deterministic. Unobserved, pending, or native same-scope concurrent orchestration is fatal.",
+  "Workflow helpers that call orchestration must be directly declared functions/function variables or static methods on a declared object/stored class instance. Do not alias them, assign them later, forward through this.otherMethod(), or call them from temporary/awaited factory receivers; rewrite those forms as a direct declared helper so resume identity remains stable.",
   "For the workflow tool, do not assume subagents share the parent's repository context; include enough task context and relevant file paths in each agent prompt.",
 ];
-
-function formatTokens(n: number): string {
-  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(n % 1_000_000 === 0 ? 0 : 1)}M`;
-  if (n >= 1_000) return `${Math.round(n / 1_000)}k`;
-  return String(n);
-}

package/src/workflow/admission.ts

@@ -0,0 +1,318 @@
+export const DEFAULT_MAX_AGENTS = 128;
+export const ABSOLUTE_MAX_AGENTS = 1024;
+export const MAX_ACTIVE_WORKFLOWS_PER_SESSION = 4;
+
+export const WORKFLOW_POLICY_ERROR_CODE = "WORKFLOW_POLICY_ERROR";
+export const WORKFLOW_ABORT_ERROR_CODE = "WORKFLOW_ABORTED";
+export const WORKFLOW_STALL_ERROR_CODE = "WORKFLOW_STALLED";
+export const WORKFLOW_CLEANUP_TIMEOUT_ERROR_CODE = "WORKFLOW_CLEANUP_TIMEOUT";
+
+export class WorkflowPolicyError extends Error {
+  readonly code = WORKFLOW_POLICY_ERROR_CODE;
+
+  constructor(message: string) {
+    super(message);
+    this.name = "WorkflowPolicyError";
+  }
+}
+
+export class WorkflowAbortError extends Error {
+  readonly code = WORKFLOW_ABORT_ERROR_CODE;
+
+  constructor(message = "workflow aborted") {
+    super(message);
+    this.name = "WorkflowAbortError";
+  }
+}
+
+export class WorkflowStallError extends Error {
+  readonly code = WORKFLOW_STALL_ERROR_CODE;
+
+  constructor(message: string) {
+    super(message);
+    this.name = "WorkflowStallError";
+  }
+}
+
+export class WorkflowCleanupTimeoutError extends Error {
+  readonly code = WORKFLOW_CLEANUP_TIMEOUT_ERROR_CODE;
+
+  constructor(timeoutMs: number) {
+    super(`workflow cleanup did not drain within ${timeoutMs}ms`);
+    this.name = "WorkflowCleanupTimeoutError";
+  }
+}
+
+export function isWorkflowPolicyError(error: unknown): error is WorkflowPolicyError {
+  return !!error && typeof error === "object" && (error as any).code === WORKFLOW_POLICY_ERROR_CODE;
+}
+
+export function isWorkflowAbortError(error: unknown): error is WorkflowAbortError {
+  return !!error && typeof error === "object" && (error as any).code === WORKFLOW_ABORT_ERROR_CODE;
+}
+
+export function isWorkflowStallError(error: unknown): error is WorkflowStallError {
+  return !!error && typeof error === "object" && (error as any).code === WORKFLOW_STALL_ERROR_CODE;
+}
+
+export function isWorkflowCleanupTimeoutError(error: unknown): error is WorkflowCleanupTimeoutError {
+  return !!error && typeof error === "object" && (error as any).code === WORKFLOW_CLEANUP_TIMEOUT_ERROR_CODE;
+}
+
+export function normalizeMaxAgents(value: unknown, name = "maxAgents"): number {
+  if (value === undefined || value === null) return DEFAULT_MAX_AGENTS;
+  if (typeof value !== "number" || !Number.isInteger(value)) {
+    throw new WorkflowPolicyError(`workflow ${name} must be an integer between 1 and ${ABSOLUTE_MAX_AGENTS}`);
+  }
+  if (value < 1 || value > ABSOLUTE_MAX_AGENTS) {
+    throw new WorkflowPolicyError(`workflow ${name} must be between 1 and ${ABSOLUTE_MAX_AGENTS} (got ${value})`);
+  }
+  return value;
+}
+
+export function normalizeReservationSize(value: unknown, fallback: number): number {
+  if (value === undefined || value === null) return fallback;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > ABSOLUTE_MAX_AGENTS) {
+    throw new WorkflowPolicyError(`parallel reserveAgents must be an integer between 0 and ${ABSOLUTE_MAX_AGENTS}`);
+  }
+  return value;
+}
+
+interface SlotEntry {
+  /**
+   * Return path for an unused slot. The first live reservation in this stack gets
+   * the slot back; if none remain, the slot returns to root capacity. This lets a
+   * nested panel transfer a sibling's branch slot without permanently stealing it
+   * from its immediate parent, while still preserving the parent's own upstream
+   * return path when that parent is released later.
+   */
+  returnStack: string[];
+}
+
+interface Reservation {
+  id: string;
+  slots: SlotEntry[];
+  contingentSlots: number;
+  contingentParentIds: string[];
+  released: boolean;
+}
+
+export interface PanelReservation {
+  panelReservationId: string;
+  branchReservationIds: string[];
+}
+
+export class AgentAdmission {
+  readonly maxAgents: number;
+  private rootFree: number;
+  private consumed = 0;
+  private nextReservation = 0;
+  private readonly reservations = new Map<string, Reservation>();
+
+  constructor(maxAgents: number, usedAgents = 0) {
+    this.maxAgents = normalizeMaxAgents(maxAgents);
+    if (!Number.isInteger(usedAgents) || usedAgents < 0 || usedAgents > this.maxAgents) {
+      throw new WorkflowPolicyError(
+        `workflow usedAgents must be an integer between 0 and maxAgents=${this.maxAgents}`,
+      );
+    }
+    this.consumed = usedAgents;
+    this.rootFree = this.maxAgents - usedAgents;
+  }
+
+  get usedAgents(): number {
+    return this.consumed;
+  }
+
+  get availableAgents(): number {
+    return this.rootFree;
+  }
+
+  reservePanel(requestedSlots: number, parentReservationIds: string[] = []): string {
+    const slots = normalizeReservationSize(requestedSlots, requestedSlots);
+    const parents = this.uniqueReservations(parentReservationIds);
+    const parentFree = parents.reduce((sum, reservation) => sum + reservation.slots.length, 0);
+    const totalFree = parentFree + this.rootFree;
+    if (totalFree < slots) {
+      throw new WorkflowPolicyError(
+        `parallel() needs ${slots} agent slot(s), but only ${totalFree} remain under maxAgents=${this.maxAgents}`,
+      );
+    }
+
+    const entries: SlotEntry[] = [];
+    let remaining = slots;
+    for (const parent of parents) {
+      while (remaining > 0 && parent.slots.length > 0) {
+        const slot = parent.slots.shift()!;
+        entries.push({ returnStack: [parent.id, ...slot.returnStack] });
+        remaining--;
+      }
+      if (remaining === 0) break;
+    }
+    if (remaining > 0) {
+      this.rootFree -= remaining;
+      for (let i = 0; i < remaining; i++) entries.push({ returnStack: [] });
+    }
+
+    return this.createReservation(entries).id;
+  }
+
+  reservePanelWithBranchNeeds(
+    requestedSlots: number,
+    branchNeedsSlot: boolean[],
+    parentReservationIds: string[] = [],
+    contingentSlots = 0,
+  ): PanelReservation {
+    const branchCount = branchNeedsSlot.length;
+    const requiredBranches = branchNeedsSlot.filter(Boolean).length;
+    const slots = normalizeReservationSize(requestedSlots, requestedSlots);
+    if (branchCount > ABSOLUTE_MAX_AGENTS) {
+      throw new WorkflowPolicyError(`parallel branch count must be at most ${ABSOLUTE_MAX_AGENTS}`);
+    }
+    if (slots < requiredBranches) {
+      throw new WorkflowPolicyError(
+        `parallel replay needs at least ${requiredBranches} live branch slot(s); got ${slots}`,
+      );
+    }
+    const contingent = normalizeReservationSize(contingentSlots, contingentSlots);
+    const panelReservationId = this.reservePanel(slots, parentReservationIds);
+    const panelReservation = this.requireReservation(panelReservationId);
+    panelReservation.contingentSlots = contingent;
+    panelReservation.contingentParentIds = [...parentReservationIds];
+    const branchReservationIds: string[] = [];
+    try {
+      for (const needsSlot of branchNeedsSlot) {
+        branchReservationIds.push(this.reservePanel(needsSlot ? 1 : 0, [panelReservationId]));
+      }
+      return { panelReservationId, branchReservationIds };
+    } catch (error) {
+      for (const id of branchReservationIds) this.releasePanel(id);
+      this.releasePanel(panelReservationId);
+      throw error;
+    }
+  }
+
+  reservePanelWithBranches(
+    requestedSlots: number,
+    branchCount: number,
+    parentReservationIds: string[] = [],
+  ): PanelReservation {
+    const slots = normalizeReservationSize(requestedSlots, requestedSlots);
+    if (!Number.isInteger(branchCount) || branchCount < 0 || branchCount > ABSOLUTE_MAX_AGENTS) {
+      throw new WorkflowPolicyError(`parallel branch count must be an integer between 0 and ${ABSOLUTE_MAX_AGENTS}`);
+    }
+    if (slots < branchCount) {
+      throw new WorkflowPolicyError(
+        `parallel reserveAgents must be at least the number of thunks (${branchCount}); got ${slots}`,
+      );
+    }
+
+    const panelReservationId = this.reservePanel(slots, parentReservationIds);
+    const branchReservationIds: string[] = [];
+    try {
+      for (let i = 0; i < branchCount; i++) {
+        branchReservationIds.push(this.reservePanel(1, [panelReservationId]));
+      }
+      return { panelReservationId, branchReservationIds };
+    } catch (error) {
+      for (const id of branchReservationIds) this.releasePanel(id);
+      this.releasePanel(panelReservationId);
+      throw error;
+    }
+  }
+
+  releasePanel(id: string): void {
+    const reservation = this.reservations.get(id);
+    if (!reservation || reservation.released) return;
+    reservation.released = true;
+    for (const slot of reservation.slots) this.returnSlot(slot);
+    reservation.slots = [];
+    this.reservations.delete(id);
+  }
+
+  consumeAgent(reservationIds: string[] = []): number {
+    const reservations = this.uniqueReservations(reservationIds);
+    for (const reservation of reservations) {
+      if (reservation.slots.length > 0) {
+        reservation.slots.shift();
+        this.consumed++;
+        return this.consumed;
+      }
+    }
+    for (const reservation of reservations) {
+      if (reservation.contingentSlots > 0 && this.acquireContingentSlot(reservation)) {
+        reservation.contingentSlots--;
+        this.consumed++;
+        return this.consumed;
+      }
+    }
+    if (reservationIds.length > 0) {
+      throw new WorkflowPolicyError(
+        "parallel() reservation has no agent slots left; increase reserveAgents for this panel or lower fan-out",
+      );
+    }
+    if (this.rootFree < 1) {
+      throw new WorkflowPolicyError(`workflow exceeded maxAgents=${this.maxAgents} (no agent slots remain)`);
+    }
+    this.rootFree--;
+    this.consumed++;
+    return this.consumed;
+  }
+
+  private createReservation(slots: SlotEntry[]): Reservation {
+    const id = `res_${++this.nextReservation}`;
+    const reservation: Reservation = {
+      id,
+      slots,
+      contingentSlots: 0,
+      contingentParentIds: [],
+      released: false,
+    };
+    this.reservations.set(id, reservation);
+    return reservation;
+  }
+
+  private uniqueReservations(ids: string[]): Reservation[] {
+    const out: Reservation[] = [];
+    const seen = new Set<string>();
+    for (const id of ids) {
+      if (!id || seen.has(id)) continue;
+      seen.add(id);
+      out.push(this.requireReservation(id));
+    }
+    return out;
+  }
+
+  private requireReservation(id: string): Reservation {
+    const reservation = this.reservations.get(id);
+    if (!reservation || reservation.released) {
+      throw new WorkflowPolicyError(`unknown or expired parallel reservation: ${id}`);
+    }
+    return reservation;
+  }
+
+  private acquireContingentSlot(reservation: Reservation): boolean {
+    for (const parent of this.uniqueReservations(reservation.contingentParentIds)) {
+      if (parent.slots.length === 0) continue;
+      parent.slots.shift();
+      return true;
+    }
+    if (this.rootFree < 1) return false;
+    this.rootFree--;
+    return true;
+  }
+
+  private returnSlot(slot: SlotEntry): void {
+    const [targetId, ...rest] = slot.returnStack;
+    if (!targetId) {
+      this.rootFree++;
+      return;
+    }
+    const target = this.reservations.get(targetId);
+    if (target && !target.released) {
+      target.slots.push({ returnStack: rest });
+      return;
+    }
+    this.returnSlot({ returnStack: rest });
+  }
+}

package/src/workflow/agent-runner.ts

@@ -60,6 +60,8 @@ export interface ModelRegistryLike {
   getAll?(): ModelLike[];
   getRegisteredProviderIds?(): readonly string[];
   getRegisteredProviderConfig?(provider: string): unknown;
+  /** Pi 0.81+ complete provider registration, distinct from legacy config providers. */
+  getRegisteredNativeProvider?(provider: string): any | undefined;
   getProviderAuthStatus?(provider: string): {
     configured: boolean;
     source?: string;
@@ -71,6 +73,8 @@ export interface ModelRegistryLike {
 export interface ModelRuntimeLike {
   getModel?(provider: string, modelId: string): ModelLike | undefined;
   registerProvider?(provider: string, config: any): void;
+  /** Pi 0.81+ complete provider registration. */
+  registerNativeProvider?(provider: any): void;
   refresh?(options?: { allowNetwork?: boolean }): Promise<unknown>;
   setRuntimeApiKey?(provider: string, apiKey: string): Promise<void>;
 }
@@ -306,6 +310,7 @@ export class WorkflowAgentRunner {
       sessionManager: SessionManager.inMemory(cwd),
       settingsManager: SettingsManager.create(cwd, agentDir),
       customTools,
+      excludeTools: ["workflow"],
       ...(model ? { model: model as any } : {}),
       ...(level ? { thinkingLevel: level as any } : {}),
       ...(toolAllowlist ? { tools: toolAllowlist } : {}),
@@ -519,6 +524,13 @@ export class WorkflowAgentRunner {
     const registeredProviderIds = this.modelRegistry?.getRegisteredProviderIds?.() ?? [];
     let providersChanged = false;
     for (const provider of registeredProviderIds) {
+      const nativeProvider = this.modelRegistry?.getRegisteredNativeProvider?.(provider);
+      if (nativeProvider !== undefined && runtime.registerNativeProvider) {
+        runtime.registerNativeProvider(nativeProvider);
+        providersChanged = true;
+        continue;
+      }
+
       const config = this.modelRegistry?.getRegisteredProviderConfig?.(provider);
       if (config === undefined || !runtime.registerProvider) continue;
       runtime.registerProvider(provider, config);

package/src/workflow/display.ts

@@ -31,6 +31,8 @@ export interface WorkflowAgentUsageSnapshot {
 
 export interface WorkflowAgentSnapshot {
   id: number;
+  /** Stable orchestration identity; display order continues to use id. */
+  callPath?: string;
   label: string;
   phase?: string;
   workflowPath?: string[];
@@ -84,16 +86,19 @@ export interface WorkflowSnapshot {
   spentTokens: number;
   newTokens: number;
   replayedTokens: number;
+  /** Effective logical agent-slot cap for this run; usage-only, not a token budget. */
+  maxAgents?: number;
+  /** Lifetime live-agent admissions across resume generations. */
+  agentsUsed?: number;
   /** Sanitized session-scoped workflow detail manifest for headless consumers. */
   detailsManifestPath?: string;
-  budgetTotal: number | null;
   durationMs?: number;
   result?: unknown;
   status: "running" | "completed" | "aborted" | "failed";
 }
 
 export interface RenderOptions {
-  maxAgents?: number;
+  maxAgentRows?: number;
   maxLogs?: number;
   showResultPreviews?: boolean;
   /** @deprecated No-op retained for source compatibility. */
@@ -102,7 +107,7 @@ export interface RenderOptions {
   now?: number;
 }
 
-export function createSnapshot(meta: WorkflowMeta, runId: string, budgetTotal: number | null): WorkflowSnapshot {
+export function createSnapshot(meta: WorkflowMeta, runId: string): WorkflowSnapshot {
   return {
     runId,
     name: safeDisplayText(meta.name, 120) || "workflow",
@@ -119,7 +124,6 @@ export function createSnapshot(meta: WorkflowMeta, runId: string, budgetTotal: n
     spentTokens: 0,
     newTokens: 0,
     replayedTokens: 0,
-    budgetTotal,
     status: "running",
   };
 }
@@ -134,7 +138,7 @@ export function recompute(snapshot: WorkflowSnapshot): WorkflowSnapshot {
 }
 
 export function renderWorkflowLines(snapshot: WorkflowSnapshot, options: RenderOptions = {}): string[] {
-  const maxAgents = options.maxAgents ?? 6;
+  const maxAgentRows = options.maxAgentRows ?? 6;
   const maxLogs = options.maxLogs ?? 2;
   const showResultPreviews = options.showResultPreviews ?? false;
   const now = options.now ?? Date.now();
@@ -145,9 +149,6 @@ export function renderWorkflowLines(snapshot: WorkflowSnapshot, options: RenderO
     : snapshot.spentTokens
       ? ` · ${formatTokens(snapshot.spentTokens)} output token`
       : "";
-  const budget = snapshot.budgetTotal
-    ? ` · ${formatTokens(snapshot.spentTokens)}/${formatTokens(snapshot.budgetTotal)} out`
-    : "";
   const stateParts = [
     snapshot.runningCount > 0 ? `${snapshot.runningCount} running` : undefined,
     snapshot.errorCount > 0 ? `${snapshot.errorCount} errors` : undefined,
@@ -155,7 +156,10 @@ export function renderWorkflowLines(snapshot: WorkflowSnapshot, options: RenderO
   ].filter(Boolean);
   const state = stateParts.length ? `, ${stateParts.join(", ")}` : "";
   const cached = snapshot.cachedCount ? ` · ${snapshot.cachedCount} cached` : "";
-  const header = `◆ ${statusMark(snapshot.status)} ${shorten(snapshot.name, 60)} (${snapshot.doneCount}/${snapshot.agentCount} done${state})${cached}${tokens}${budget}`;
+  const agentSlots = snapshot.maxAgents
+    ? ` · agents ${snapshot.agentsUsed ?? snapshot.agentCount}/${snapshot.maxAgents}`
+    : "";
+  const header = `◆ ${statusMark(snapshot.status)} ${shorten(snapshot.name, 60)} (${snapshot.doneCount}/${snapshot.agentCount} done${state})${cached}${agentSlots}${tokens}`;
   const lines = [header];
 
   const phaseNames = unique([
@@ -186,19 +190,19 @@ export function renderWorkflowLines(snapshot: WorkflowSnapshot, options: RenderO
     lines.push(
       `  ${marker} ${shorten(phase, 60)} ${done}/${agents.length}${running ? ` · ${running} running` : ""}${errors ? ` · ${errors} errors` : ""}${cancelled ? ` · ${cancelled} cancelled` : ""}`,
     );
-    for (const agent of agents.slice(-maxAgents)) {
+    for (const agent of agents.slice(-maxAgentRows)) {
       lines.push(...renderAgentLines(agent, { showResultPreviews, now }));
     }
-    if (agents.length > maxAgents) lines.push(`    … ${agents.length - maxAgents} earlier agents`);
+    if (agents.length > maxAgentRows) lines.push(`    … ${agents.length - maxAgentRows} earlier agents`);
   }
 
   const unphased = snapshot.agents.filter((a) => !rendered.has(a));
   if (unphased.length) {
     lines.push("  (unphased)");
-    for (const agent of unphased.slice(-maxAgents)) {
+    for (const agent of unphased.slice(-maxAgentRows)) {
       lines.push(...renderAgentLines(agent, { showResultPreviews, now }));
     }
-    if (unphased.length > maxAgents) lines.push(`    … ${unphased.length - maxAgents} earlier agents`);
+    if (unphased.length > maxAgentRows) lines.push(`    … ${unphased.length - maxAgentRows} earlier agents`);
   }
 
   for (const log of snapshot.logs.slice(-maxLogs)) lines.push(`  log: ${shorten(log, 100)}`);