@jameslovespancakes/pi-plus 1.0.19 → 1.0.21

package/src/domains/workflows/runtime/agent-attempt.ts

@@ -1,6 +1,6 @@
 import type { Api, Model } from "@earendil-works/pi-ai";
 import { assertWorkflowBudgetAvailable } from "./budget.ts";
-import { isWorkflowPauseError } from "./cancellation.ts";
+import { isWorkflowPauseError, WorkflowAgentStoppedError } from "./cancellation.ts";
 import type { WorkflowAgentReservation } from "./agent-limits.ts";
 import {
   type AgentExecutionOptions,
@@ -132,7 +132,7 @@ export async function executeAgentAttempt(input: {
       tags,
     });
     const result = await workspace.wrapResult(rawResult);
-    if (!identity) return { kind: "live-unrecordable", result };
+    if (!identity || handle.interacted) return { kind: "live-unrecordable", result };
     if (!isReplayEnabled(replay) || !evidence) throw new Error("Replay identity produced without complete replay evidence.");
 
     const contract = await validateReplayIdentity({
@@ -156,7 +156,7 @@ export async function executeAgentAttempt(input: {
     if (
       workspace?.kind === "isolated"
       && liveStarted
-      && !rc.signal?.aborted
+      && (!rc.signal?.aborted || rc.signal.reason instanceof WorkflowAgentStoppedError)
       && !isWorkflowPauseError(error)
     ) {
       rc.worktrees.preserve(workspace.cwd);

package/src/domains/workflows/runtime/agent-options.ts

@@ -0,0 +1,18 @@
+import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
+import type { AgentOptions } from "./types.ts";
+
+export const WORKFLOW_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const satisfies readonly ThinkingLevel[];
+
+export function isWorkflowThinkingLevel(value: string): value is ThinkingLevel {
+  return (WORKFLOW_THINKING_LEVELS as readonly string[]).includes(value);
+}
+
+/** Validate before admission or any model session can be created. */
+export function assertAgentOptions(options: unknown): asserts options is AgentOptions {
+  const opts = options as Partial<AgentOptions> | undefined;
+  if (!opts || typeof opts.label !== "string" || !opts.label.trim()
+    || typeof opts.model !== "string" || !opts.model.trim()
+    || typeof opts.thinkingLevel !== "string" || !isWorkflowThinkingLevel(opts.thinkingLevel)) {
+    throw new Error("Every agent() requires explicit label, model, and thinkingLevel.");
+  }
+}

package/src/domains/workflows/runtime/agent-runner-types.ts

@@ -13,6 +13,7 @@ import type { WorkflowJournal } from "./journal.ts";
 import type { PerfSink } from "./perf.ts";
 import type { AgentOptions, WorkflowProgressEvent } from "./types.ts";
 import type { AgentChatRole } from "./progress-types.ts";
+import type { AgentTranscript } from "./live-agent.ts";
 import type { WorkflowUsageSink } from "./usage.ts";
 import type { WorktreeBaseline, WorktreeRegistry } from "./worktree.ts";
 
@@ -34,16 +35,19 @@ export type AgentRunnerSession = Pick<
   | "getLastAssistantText"
   | "isStreaming"
   | "followUp"
->;
+> & Partial<Pick<AgentSession, "setModel" | "setThinkingLevel" | "steer" | "getSteeringMessages" | "getFollowUpMessages">>;
 
 export type CreateAgentSession = (options: CreateAgentSessionOptions) => Promise<{ session: AgentRunnerSession }>;
 
 export interface AgentProgress {
-  agentQueued(phase: string | undefined, label: string, model?: string): number;
+  agentQueued(phase: string | undefined, label: string, model?: string, modelName?: string, thinkingLevel?: string): number;
+  bindAgentStop?(id: number, stop: () => void): () => void;
   agentStart(phase: string | undefined, label: string, id?: number, model?: string): void;
   agentTool(label: string, tool: string, id?: number): void;
   agentMessage(id: number, role: AgentChatRole, text: string): void;
-  bindAgentFollowUp(id: number, send: (message: string) => Promise<void>): () => void;
+  bindAgentFollowUp(id: number, send: (message: string, steer?: boolean) => Promise<void>): () => void;
+  bindAgentTranscript?(id: number, read: () => AgentTranscript): () => void;
+  agentChanged?(id: number, model?: string, modelName?: string, thinkingLevel?: string): void;
   agentDone(label: string, id?: number): void;
   agentFailed(label: string, error: unknown, id?: number): void;
   event(event: WorkflowProgressEvent): void;

package/src/domains/workflows/runtime/agent-runner.ts

@@ -1,7 +1,8 @@
+import { assertAgentOptions } from "./agent-options.ts";
 import { assertWorkflowBudgetAvailable } from "./budget.ts";
 import { combinedAgentAttemptError } from "./agent-failure.ts";
 import { WorkflowAgentTimeoutError } from "./agent-limits.ts";
-import { abortReason, linkAbortSignal, throwIfAborted } from "./cancellation.ts";
+import { abortReason, linkAbortSignal, throwIfAborted, WorkflowAgentStoppedError } from "./cancellation.ts";
 import { executeAgentAttempt } from "./agent-attempt.ts";
 import {
   createAgentReplayPlan,
@@ -53,7 +54,8 @@ export async function runAgent(
     throw new Error(`agent() prompt must be a string; received ${describeAgentPrompt(prompt)}`);
   }
 
-  const label = opts.label ?? "agent";
+  assertAgentOptions(opts);
+  const label = opts.label;
   const phase = opts.phase ?? "Workflow";
   const tags: AgentRunTags = { label, phase };
 
@@ -62,14 +64,15 @@ export async function runAgent(
     const routing = resolveAgentRouting(rc, opts, label);
     const effectiveOpts = routing.thinkingLevel === opts.thinkingLevel
       ? opts
-      : { ...opts, thinkingLevel: routing.thinkingLevel };
+      : { ...opts, thinkingLevel: routing.thinkingLevel ?? opts.thinkingLevel };
     const replay = createAgentReplayPlan(prompt, effectiveOpts);
     if (!isReplayEnabled(replay)) assertWorkflowBudgetAvailable(rc.budget);
 
     const modelLabel = describeAgentModel(routing.model);
-    const rowId = rc.progress.agentQueued(opts.phase, label, modelLabel);
+    const rowId = rc.progress.agentQueued(opts.phase, label, modelLabel, routing.model?.name, effectiveOpts.thinkingLevel);
     rc.progress.agentMessage(rowId, "task", prompt);
     const liveScope = createAgentLiveScope(rc, label);
+    const unbindStop = rc.progress.bindAgentStop?.(rowId, liveScope.stop);
     try {
       return await rc.semaphore.run(
         async () => {
@@ -129,18 +132,20 @@ export async function runAgent(
               }
               continue;
             }
+            throwIfAborted(agentRc.signal);
             const settlement = await settleAgentAttempt({ rc: agentRc, label, tags, replay: attemptPlan, outcome });
             if (settlement.kind === "retry-live") {
               attemptPlan = { kind: "off" };
               continue;
             }
+            throwIfAborted(agentRc.signal);
             rc.progress.agentDone(label, rowId);
             return settlement.result;
           }
         },
         {
           onQueueWaitMs: (durationMs) => rc.perf.observe("agent.queue_wait_ms", durationMs, tags),
-          signal: rc.signal,
+          signal: liveScope.signal,
         },
       );
     } catch (error) {
@@ -151,6 +156,7 @@ export async function runAgent(
       rc.progress.log(`${label} failed: ${unknownErrorMessage(failure)}`);
       throw failure;
     } finally {
+      unbindStop?.();
       liveScope.dispose();
     }
   }, tags);
@@ -164,6 +170,8 @@ function createAgentLiveScope(rc: RunContext, label: string) {
 
   return {
     signal: controller.signal,
+    // A local stop is recoverable by parallel(); it must not abort sibling agents.
+    stop: () => controller.abort(new WorkflowAgentStoppedError(`Agent ${label} stopped by user.`)),
     reserve() {
       const reservation = rc.agentLimiter.reserve(controller.signal);
       let committed = false;
@@ -194,7 +202,7 @@ function resolveAgentRouting(
   rc: RunContext,
   opts: AgentExecutionOptions,
   label: string,
-): { readonly model: ResolvedAgentModel["model"]; readonly thinkingLevel: AgentExecutionOptions["thinkingLevel"] } {
+): { readonly model: ResolvedAgentModel["model"]; readonly thinkingLevel: AgentExecutionOptions["thinkingLevel"] | undefined } {
   try {
     return resolveAgentModelProfile(
       {

package/src/domains/workflows/runtime/agent-session.ts

@@ -1,3 +1,5 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import { sendAgentInput, type AgentTranscript } from "./live-agent.ts";
 import type { Api, Model } from "@earendil-works/pi-ai";
 import {
   createAgentSessionFromServices,
@@ -45,7 +47,9 @@ export interface ResolvedAgentModel {
 }
 
 export interface AgentSessionHandle {
+  interacted?: boolean;
   readonly session: AgentRunnerSession;
+  readonly cwd?: string;
   readonly selectedSkills: readonly Skill[];
   hasStructuredResult(): boolean;
   structuredResult(): unknown;
@@ -124,6 +128,7 @@ export async function openAgentSession(input: {
     throwIfAborted(rc.signal);
     return {
       session,
+      cwd,
       selectedSkills: resources.selectedSkills,
       hasStructuredResult: () => captured,
       structuredResult: () => structuredResult,
@@ -149,13 +154,38 @@ export async function promptAgentSession(input: {
 }): Promise<unknown> {
   const { rc, handle, prompt, opts, label, rowId, tags } = input;
   const { session } = handle;
-  const unbindFollowUp = rc.progress.bindAgentFollowUp(rowId, async (message) => {
-    if (!session.isStreaming) throw new Error("This agent has already finished its current turn.");
-    await session.followUp(message);
+  let streaming: AgentMessage | undefined;
+  const toolUpdates = new Map<string, NonNullable<AgentTranscript["toolUpdates"]> extends ReadonlyMap<string, infer V> ? V : never>();
+  const refresh = () => rc.progress.agentChanged?.(rowId,
+    session.model ? `${session.model.provider}/${session.model.id}` : undefined,
+    session.model?.name, session.thinkingLevel);
+  const unbindTranscript = rc.progress.bindAgentTranscript?.(rowId, () => ({
+    messages: session.messages, streaming, cwd: handle.cwd, toolUpdates,
+    steering: session.getSteeringMessages?.() ?? [],
+    followUp: session.getFollowUpMessages?.() ?? [],
+  }));
+  const unbindFollowUp = rc.progress.bindAgentFollowUp(rowId, async (message, steer) => {
+    await sendAgentInput(session, rc, message, steer);
+    handle.interacted = true;
+    refresh();
   });
   const unsubscribe = session.subscribe((event) => {
+    if (event.type === "message_update" || event.type === "message_start") streaming = event.message;
+    if (event.type === "message_end") streaming = undefined;
+    if (event.type === "tool_execution_update") {
+      toolUpdates.set(event.toolCallId, { result: event.partialResult, isPartial: true, isError: false });
+    } else if (event.type === "tool_execution_end") {
+      toolUpdates.set(event.toolCallId, { result: event.result, isPartial: false, isError: event.isError });
+    }
+    refresh();
+    if (event.type === "tool_execution_end") {
+      const output = event.result.content.filter((part: { type: string }) => part.type === "text")
+        .map((part: { text?: string }) => part.text ?? "").join("\n");
+      rc.progress.agentMessage(rowId, "tool", `${event.toolName}: ${output}`);
+    }
     if (event.type === "tool_execution_start" && event.toolName !== undefined && event.toolName !== FINAL_TOOL) {
       rc.progress.agentTool(label, event.toolName, rowId);
+      rc.progress.agentMessage(rowId, "tool", `${event.toolName} ${JSON.stringify(event.args)}`);
       return;
     }
     if (event.type === "message_end" && event.message.role === "assistant") {
@@ -217,6 +247,7 @@ export async function promptAgentSession(input: {
       unlinkPromptAbort();
     }
   } finally {
+    unbindTranscript?.();
     unbindFollowUp();
     unsubscribe();
   }

package/src/domains/workflows/runtime/cancellation.ts

@@ -1,3 +1,8 @@
+/** Agent-local cancellation is recoverable and must not stop sibling tasks. */
+export class WorkflowAgentStoppedError extends Error {
+  override readonly name = "WorkflowAgentStoppedError";
+}
+
 export class WorkflowAbortError extends Error {
   constructor(message = "Workflow aborted") {
     super(message);

package/src/domains/workflows/runtime/engine.ts

@@ -3,6 +3,7 @@ import type { Static, TSchema } from "typebox";
 import { bindParallel, bindPipeline, Semaphore } from "./concurrency.ts";
 import { WorkflowAgentLimiter } from "./agent-limits.ts";
 import { defaultAgentRetryScheduler, type AgentRetryScheduler } from "./agent-retry.ts";
+import { assertAgentOptions } from "./agent-options.ts";
 import { resolveWorkflowModelProfiles, type ResolvedWorkflowModelProfiles } from "./model-profiles.ts";
 import { abortReason, isWorkflowPauseError, linkAbortSignal, throwIfAborted } from "./cancellation.ts";
 import { createBudget } from "./budget.ts";
@@ -15,8 +16,6 @@ import {
   type ResolvedWorkflowRunOptions,
 } from "./options.ts";
 import type { AgentOptions, IsolatedAgentResult, LoadedWorkflow, WorkflowApi, WorkflowProgressEvent, WorkflowRef, WorkflowRunOptions } from "./types.ts";
-import { WorkflowInspector } from "./ui/workflow-inspector.ts";
-import { WORKFLOW_VIEWER_OVERLAY_OPTIONS } from "./ui/workflow-viewer-layout.ts";
 import { createWorkflowJournal, createWorkflowRunId, pruneWorkflowJournals, workflowJournalPath } from "./journal.ts";
 import { WorktreeRegistry } from "./worktree.ts";
 import { runFinalizers } from "./finalizers.ts";
@@ -101,7 +100,9 @@ export async function runResolvedWorkflow(
   const progressSource = {
     snapshot: () => progress.snapshot(),
     conversation: (agentId: number) => progress.conversation(agentId),
-    followUp: (agentId: number, message: string) => progress.followUp(agentId, message),
+    stopAgent: (agentId: number) => progress.stopAgent(agentId),
+    transcript: (agentId: number) => progress.transcript(agentId),
+    followUp: (agentId: number, message: string, steer?: boolean) => progress.followUp(agentId, message, steer),
     subscribe: (listener: () => void) => progress.subscribe(listener),
   };
   const perf = resolvedOptions.perfRecorder ?? createPerfRecorder(resolvedOptions.perf);
@@ -133,33 +134,6 @@ export async function runResolvedWorkflow(
   const unlinkOptionAbortSignal = linkAbortSignal(resolvedOptions.signal, runAbortController);
   const workflowOutcome = await captureOutcome(async () => {
     await notifyLifecycleObserver(progress, "progress source callback", () => resolvedOptions.onProgressSource?.(progressSource));
-    if (resolvedOptions.inspect && ctx.hasUI && ctx.mode === "tui") {
-      let unsubscribe: (() => void) | undefined;
-      void ctx.ui
-        .custom<void>(
-          (tui, theme, _keybindings, done) => {
-            unsubscribe = progressSource.subscribe(() => tui.requestRender());
-            return new WorkflowInspector(
-              () => progress.snapshot(),
-              tui,
-              theme,
-              () => done(undefined),
-              undefined,
-              progressSource,
-            );
-          },
-          WORKFLOW_VIEWER_OVERLAY_OPTIONS,
-        )
-        .catch((error: unknown) => {
-          try {
-            progress.log(`inspector failed: ${unknownErrorMessage(error)}`);
-          } catch {
-            // Inspector reporting is detached and must never become another rejection.
-          }
-        })
-        .finally(() => unsubscribe?.());
-    }
-
     const journal = await createWorkflowJournal({ resumePath, writePath: journalPath });
     durableRun.transition({ state: "running", progress: progress.snapshot() });
     await durableRun.flush().catch(() => undefined);
@@ -185,7 +159,7 @@ export async function runResolvedWorkflow(
       agentLimiter: new WorkflowAgentLimiter(resolvedOptions.maxAgents),
       agentTimeoutMs: resolvedOptions.agentTimeoutMs,
       agentRetries: resolvedOptions.agentRetries,
-      pauseOnProviderUsageLimit: resolvedOptions.background !== undefined,
+      pauseOnProviderUsageLimit: resolvedOptions.origin !== undefined,
       resumeEditedWorkflow: resolvedOptions.resumeEditedWorkflow,
       retryScheduler: dependencies.retryScheduler ?? defaultAgentRetryScheduler,
       modelProfiles,
@@ -214,11 +188,8 @@ export async function runResolvedWorkflow(
     ? undefined
     : backgroundPauseError(workflowOutcome.error, ctx.signal, resolvedOptions.signal);
   const willPauseWorkflow = workflowPause !== undefined
-    && (!(workflowPause instanceof WorkflowProviderUsageLimitError) || resolvedOptions.background !== undefined);
-  const preserveFailedWorktrees = !workflowOutcome.ok
-    && !willPauseWorkflow
-    && !ctx.signal?.aborted
-    && !resolvedOptions.signal?.aborted;
+    && (!(workflowPause instanceof WorkflowProviderUsageLimitError) || resolvedOptions.origin !== undefined);
+  const preserveFailedWorktrees = !workflowOutcome.ok && !willPauseWorkflow;
   if (preserveFailedWorktrees) worktrees.preserveRecoverable();
   const finalizationOutcome = await captureOutcome(() =>
     finalizeWorkflowRun({
@@ -229,7 +200,7 @@ export async function runResolvedWorkflow(
       progress,
       runStore,
       worktrees,
-      preserveWorktrees: preserveFailedWorktrees,
+      preserveWorktrees: preserveFailedWorktrees || worktrees.preservedPaths.length > 0,
       unlinkSignals: [unlinkContextAbortSignal, unlinkOptionAbortSignal],
     }),
   );
@@ -259,7 +230,7 @@ export async function runResolvedWorkflow(
     const pauseError = backgroundPauseError(pauseCandidate, ctx.signal, resolvedOptions.signal);
     if (pauseError) {
       if (pauseError instanceof WorkflowProviderUsageLimitError) {
-        if (resolvedOptions.background === undefined) {
+        if (resolvedOptions.origin === undefined) {
           durableRun.transition({
             state: "failed",
             progress: progress.snapshot(),
@@ -428,6 +399,7 @@ function createWorkflowAgent(
   function agent<S extends TSchema>(prompt: string, opts: AgentOptions<S> & { schema: S }): Promise<Static<S>>;
   function agent(prompt: string, opts?: AgentOptions): Promise<string>;
   function agent(prompt: string, agentOpts?: AgentOptions): Promise<unknown> {
+    assertAgentOptions(agentOpts);
     const scopedOptions = scope.agentOptions(agentOpts);
     const executionOptions: AgentExecutionOptions =
       scopedOptions.isolation === "worktree" && mod.isolatedWorktreeBaseline !== undefined
@@ -486,6 +458,13 @@ export async function runWorkflowWithContext(
         };
 
   const api: WorkflowApi = {
+    modelProfile(name) {
+      const profile = rc.modelProfiles[name];
+      if (!profile || profile.source === "host" || !profile.model || !profile.thinkingLevel) {
+        throw new Error(`Configure workflow profile ${name} with an explicit model and thinkingLevel in workflow-models.json.`);
+      }
+      return { model: `${profile.model.provider}/${profile.model.id}`, thinkingLevel: profile.thinkingLevel };
+    },
     agent,
     workflow,
     parallel: bindParallel({
@@ -510,7 +489,7 @@ export async function runWorkflowWithContext(
 }
 
 interface WorkflowScope {
-  agentOptions(opts: AgentOptions | undefined): AgentOptions;
+  agentOptions(opts: AgentOptions): AgentOptions;
   phase(title: string): void;
   log(message: string): void;
   event(event: WorkflowProgressEvent): void;
@@ -523,7 +502,7 @@ function createWorkflowScope(progress: WorkflowProgress, prefix: string, namespa
   return {
     agentOptions(opts) {
       const phase = opts?.phase ? display(opts.phase) : currentPhase;
-      return opts ? { ...opts, phase } : { phase };
+      return { ...opts, phase };
     },
     phase(title) {
       currentPhase = display(title);

package/src/domains/workflows/runtime/journal.ts

@@ -81,12 +81,12 @@ export function workflowJournalPath(cwd: string, runId: string): string {
   return join(workflowRunsDir(cwd), `${validateWorkflowRunId(runId)}.jsonl`);
 }
 
-export function agentJournalKey(prompt: string, opts: AgentOptions = {}, worktreeBaseline?: WorktreeBaseline): string {
+export function agentJournalKey(prompt: string, opts: Partial<AgentOptions> = {}, worktreeBaseline?: WorktreeBaseline): string {
   const capture = captureAgentJournalKey(prompt, opts, worktreeBaseline);
   return capture.kind === "verified" ? capture.key : `agent:unverifiable:${randomUUID()}`;
 }
 
-export function hashAgentCall(prompt: string, opts: AgentOptions = {}, worktreeBaseline?: WorktreeBaseline): string {
+export function hashAgentCall(prompt: string, opts: Partial<AgentOptions> = {}, worktreeBaseline?: WorktreeBaseline): string {
   const capture = captureAgentCallHash(prompt, opts, worktreeBaseline);
   return capture.kind === "verified"
     ? capture.hash
@@ -96,7 +96,7 @@ export function hashAgentCall(prompt: string, opts: AgentOptions = {}, worktreeB
 /** Capture a replay key without allowing hostile or oversized schemas to escape as exceptions. */
 export function captureAgentJournalKey(
   prompt: string,
-  opts: AgentOptions = {},
+  opts: Partial<AgentOptions> = {},
   worktreeBaseline?: WorktreeBaseline,
 ): AgentJournalKeyCapture {
   const behavior = captureAgentCallHash(prompt, opts, worktreeBaseline);
@@ -118,7 +118,7 @@ type AgentCallHashCapture =
 
 function captureAgentCallHash(
   prompt: string,
-  opts: AgentOptions,
+  opts: Partial<AgentOptions>,
   worktreeBaseline: WorktreeBaseline | undefined,
 ): AgentCallHashCapture {
   try {

package/src/domains/workflows/runtime/live-agent.ts

@@ -0,0 +1,37 @@
+import type { AgentMessage, AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { AgentRunnerSession, RunContext } from "./agent-runner-types.ts";
+import { isWorkflowThinkingLevel } from "./agent-options.ts";
+import { resolveAgentModel } from "./agent-session.ts";
+
+export interface AgentTranscript {
+  readonly cwd?: string;
+  readonly messages: readonly AgentMessage[];
+  readonly streaming?: AgentMessage;
+  readonly steering: readonly string[];
+  readonly followUp: readonly string[];
+  readonly toolUpdates?: ReadonlyMap<string, { result: AgentToolResult<unknown>; isPartial: boolean; isError: boolean }>;
+}
+
+/** Commands are scoped to the child SDK session; parent command handlers never run here. */
+export async function sendAgentInput(session: AgentRunnerSession, rc: RunContext, text: string, steer = false): Promise<void> {
+  const [command, ...rest] = text.trim().split(/\s+/);
+  const argument = rest.join(" ");
+  if (command === "/model") {
+    if (!argument || !session.setModel) throw new Error("Usage: /model provider/model");
+    const model = resolveAgentModel(argument, rc.modelRegistry, rc.hostModel).model;
+    if (!model) throw new Error("Model is unavailable.");
+    await session.setModel(model);
+    return;
+  }
+  if (command === "/thinking") {
+    if (!isWorkflowThinkingLevel(argument) || !session.setThinkingLevel) {
+      throw new Error("Usage: /thinking off|minimal|low|medium|high|xhigh|max");
+    }
+    session.setThinkingLevel(argument);
+    return;
+  }
+  if (command.startsWith("/")) throw new Error("Supported agent commands: /model provider/model, /thinking level.");
+  if (!session.isStreaming) throw new Error("This agent has finished its current turn.");
+  if (steer && session.steer) await session.steer(text);
+  else await session.followUp(text);
+}

package/src/domains/workflows/runtime/model-profiles.ts

@@ -6,6 +6,7 @@ import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
 import { getAgentDir, type ModelRegistry } from "@earendil-works/pi-coding-agent";
 import { isMissingPathError } from "./filesystem-error.ts";
 import { unknownErrorMessage } from "./unknown-error.ts";
+import { isWorkflowThinkingLevel } from "./agent-options.ts";
 
 export const WORKFLOW_MODEL_PROFILE_NAMES = ["small", "medium", "big"] as const;
 export type WorkflowModelProfileName = (typeof WORKFLOW_MODEL_PROFILE_NAMES)[number];
@@ -56,8 +57,7 @@ export class WorkflowModelProfileConfigError extends Error {
   }
 }
 
-export const WORKFLOW_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const satisfies readonly ThinkingLevel[];
-const THINKING_LEVELS = new Set<ThinkingLevel>(WORKFLOW_THINKING_LEVELS);
+export { WORKFLOW_THINKING_LEVELS, isWorkflowThinkingLevel } from "./agent-options.ts";
 const HOST_FALLBACK_THINKING: Record<WorkflowModelProfileName, ThinkingLevel> = {
   small: "low",
   medium: "medium",
@@ -184,10 +184,6 @@ export function isWorkflowModelProfileName(value: string): value is WorkflowMode
   return WORKFLOW_MODEL_PROFILE_NAMES.includes(value as WorkflowModelProfileName);
 }
 
-export function isWorkflowThinkingLevel(value: string): value is ThinkingLevel {
-  return THINKING_LEVELS.has(value as ThinkingLevel);
-}
-
 function parseWorkflowModelProfileFile(value: unknown, configPath: string): WorkflowModelProfileFile {
   if (!isRecord(value)) throw invalidConfig(configPath, "the root must be an object");
   assertOnlyKeys(value, ["profiles"], configPath);

package/src/domains/workflows/runtime/progress-types.ts

@@ -1,6 +1,6 @@
 import type { WorkflowUsageSnapshot } from "./usage.ts";
 
-export type AgentRowStatus = "queued" | "running" | "done" | "failed";
+export type AgentRowStatus = "queued" | "running" | "stopping" | "stopped" | "done" | "failed";
 export type AgentChatRole = "task" | "user" | "assistant" | "tool" | "status";
 export type WorkflowLaneItemStatus = "pending" | "running" | "success" | "warning" | "error";
 
@@ -15,6 +15,8 @@ export interface AgentRowSnapshot {
   readonly label: string;
   /** provider/id of the model actually routed to this agent. */
   readonly model?: string;
+  readonly modelName?: string;
+  readonly thinkingLevel?: string;
   readonly status: AgentRowStatus;
   readonly startedAt?: number;
   readonly doneAt?: number;