@quintinshaw/pi-dynamic-workflows 1.9.0 → 1.9.2

package/src/workflow-ui.ts

@@ -63,6 +63,14 @@ interface AgentRow {
   status: string;
   phase?: string;
   tokens?: number;
+  model?: string;
+}
+
+/** Short, human-friendly model label: drop the provider prefix for display. */
+function shortModel(model: string | undefined): string | undefined {
+  if (!model) return undefined;
+  const slash = model.indexOf("/");
+  return slash > 0 ? model.slice(slash + 1) : model;
 }
 
 /** Reads run/phase/agent data from the manager, preferring live snapshots. */
@@ -127,7 +135,7 @@ export class NavigatorModel {
     if (!snap) return [];
     return snap.agents
       .filter((a) => (a.phase ?? "(no phase)") === phase)
-      .map((a) => ({ id: a.id, label: a.label, status: a.status, phase: a.phase, tokens: a.tokens }));
+      .map((a) => ({ id: a.id, label: a.label, status: a.status, phase: a.phase, tokens: a.tokens, model: a.model }));
   }
 
   agentDetail(runId: string, agentId: number): WorkflowAgentSnapshot | undefined {
@@ -150,6 +158,7 @@ function persistedToSnapshot(p: PersistedRunState): WorkflowSnapshot {
       resultPreview:
         a.result == null ? undefined : String(typeof a.result === "string" ? a.result : JSON.stringify(a.result)),
       error: a.error,
+      model: a.model,
     })),
     agentCount: p.agents.length,
     runningCount: p.agents.filter((a) => a.status === "running").length,
@@ -293,8 +302,9 @@ export function renderNavigator(
     lines.push(theme.bold(`${model.runName(state.runId)} › ${state.phase}`));
     agents.forEach((a, i) => {
       const icon = STATUS_ICON[a.status] ?? "?";
-      const tok = a.tokens ? dim(` ${fmtTokens(a.tokens)}`) : "";
-      lines.push(sel(i, `${icon} ${a.label}${tok}`));
+      const mdl = shortModel(a.model);
+      const meta = [mdl, a.tokens ? fmtTokens(a.tokens) : undefined].filter(Boolean).join(" · ");
+      lines.push(sel(i, `${icon} ${a.label}${meta ? dim(`  ${meta}`) : ""}`));
     });
   } else if (state.kind === "detail" && state.runId && state.agentId != null) {
     const a = model.agentDetail(state.runId, state.agentId);
@@ -302,6 +312,7 @@ export function renderNavigator(
     if (a) {
       const body: string[] = [];
       body.push(dim("Status: ") + (a.status ?? ""));
+      if (a.model) body.push(dim("Model: ") + (shortModel(a.model) ?? ""));
       if (a.error) body.push(dim("Error: ") + a.error);
       body.push("", dim("Prompt:"));
       body.push(...wrap(a.prompt ?? "", width));
@@ -454,9 +465,20 @@ export function openWorkflowNavigator(
             if (id) ui.notify(manager.stop(id) ? `Stopped ${id}` : `Cannot stop ${id}`, "info");
             break;
           }
-          case "restart":
-            ui.notify("Restarting a single agent isn't supported yet", "warning");
+          case "restart": {
+            // Restart re-runs the whole workflow from scratch as a fresh
+            // background run (per-agent restart isn't meaningful — agents are
+            // driven by the script). The new run auto-delivers when it finishes.
+            const id = state.activeRunId(model);
+            const run = id ? manager.listRuns().find((r) => r.runId === id) : undefined;
+            if (!run?.script) {
+              ui.notify(id ? `Cannot restart ${id} (no script saved)` : "No run selected to restart", "warning");
+              break;
+            }
+            const { runId: newId } = manager.startInBackground(run.script, run.args);
+            ui.notify(`Restarted ${run.workflowName || "workflow"} as ${newId}`, "info");
             break;
+          }
           case "save": {
             const id = state.activeRunId(model);
             const run = id ? manager.listRuns().find((r) => r.runId === id) : undefined;

package/src/workflow.ts

@@ -48,6 +48,8 @@ export interface SharedRuntime {
 export interface WorkflowRunOptions extends WorkflowAgentOptions {
   args?: unknown;
   agent?: Pick<WorkflowAgent, "run">;
+  /** The session's main model (provider/id), shown in /workflows for default agents. */
+  mainModel?: string;
   concurrency?: number;
   tokenBudget?: number | null;
   signal?: AbortSignal;
@@ -72,7 +74,14 @@ export interface WorkflowRunOptions extends WorkflowAgentOptions {
   onLog?: (message: string) => void;
   onPhase?: (title: string) => void;
   onAgentStart?: (event: { label: string; phase?: string; prompt: string; model?: string }) => void;
-  onAgentEnd?: (event: { label: string; phase?: string; result: unknown; tokens?: number; worktree?: string }) => void;
+  onAgentEnd?: (event: {
+    label: string;
+    phase?: string;
+    result: unknown;
+    tokens?: number;
+    worktree?: string;
+    model?: string;
+  }) => void;
   onTokenUsage?: (usage: { input: number; output: number; total: number; cost: number }) => void;
 }
 
@@ -96,6 +105,12 @@ export interface AgentOptions<TSchemaDef extends TSchema | undefined = TSchema |
   label?: string;
   phase?: string;
   schema?: TSchemaDef;
+  /**
+   * Run this agent on a specific model (`provider/modelId` or a bare `modelId`).
+   * The workflow author chooses per-agent models per the routing policy in the
+   * tool guidelines (e.g. a lighter model for exploration, the main model for
+   * analysis). When omitted, the session's main model is used.
+   */
   model?: string;
   isolation?: "worktree";
   agentType?: string;
@@ -203,6 +218,10 @@ export async function runWorkflow<T = unknown>(
     const requestedLabel = agentOptions.label?.trim();
     // Precedence: explicit agentOptions.model > phase model (meta.phases[].model).
     const modelSpec = agentOptions.model ?? resolveModelForPhase(assignedPhase, routingConfig);
+    // For display in /workflows: the model this agent runs on — its explicit/phase
+    // spec, else the session's main model. The real resolved id overrides this via
+    // onModelResolved once the subagent session is created.
+    let displayModel = modelSpec ?? options.mainModel;
 
     // Deterministic resume key: assigned at lexical call time, before the limiter,
     // so parallel()/pipeline() fan-out is reproducible for a fixed script.
@@ -215,8 +234,8 @@ export async function runWorkflow<T = unknown>(
     if (cached && cached.hash === callHash) {
       shared.agentCount++;
       const label = requestedLabel || defaultAgentLabel(assignedPhase, shared.agentCount);
-      options.onAgentStart?.({ label, phase: assignedPhase, prompt, model: modelSpec });
-      options.onAgentEnd?.({ label, phase: assignedPhase, result: cached.result, tokens: 0 });
+      options.onAgentStart?.({ label, phase: assignedPhase, prompt, model: displayModel });
+      options.onAgentEnd?.({ label, phase: assignedPhase, result: cached.result, tokens: 0, model: displayModel });
       return cached.result;
     }
 
@@ -225,7 +244,7 @@ export async function runWorkflow<T = unknown>(
       const label = requestedLabel || defaultAgentLabel(assignedPhase, shared.agentCount);
       const timeout = agentOptions.timeoutMs ?? agentTimeoutMs;
 
-      options.onAgentStart?.({ label, phase: assignedPhase, prompt, model: modelSpec });
+      options.onAgentStart?.({ label, phase: assignedPhase, prompt, model: displayModel });
 
       // Optional per-agent worktree isolation (deterministic name -> stable resume keys).
       let worktree: Worktree | undefined;
@@ -262,6 +281,9 @@ export async function runWorkflow<T = unknown>(
             instructions: buildAgentInstructions(assignedPhase, agentOptions),
             model: modelSpec,
             cwd: runCwd,
+            onModelResolved: (id: string) => {
+              displayModel = id;
+            },
             onUsage: (u: AgentUsage) => {
               usage = u;
             },
@@ -274,7 +296,7 @@ export async function runWorkflow<T = unknown>(
 
         const tokens = recordTokens(result);
         options.onAgentJournal?.({ index: callIndex, hash: callHash, result });
-        options.onAgentEnd?.({ label, phase: assignedPhase, result, tokens, worktree: runCwd });
+        options.onAgentEnd?.({ label, phase: assignedPhase, result, tokens, worktree: runCwd, model: displayModel });
         return result;
       } catch (error) {
         if (options.signal?.aborted) throw error;