pi-workflow-engine 0.4.0 → 0.6.1

package/.pi/extensions/pi-workflow-engine/index.ts

@@ -2,8 +2,13 @@ import { fileURLToPath } from "node:url";
 import { Type } from "typebox";
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
+import type { WorkflowProgressSnapshot } from "./src/progress.ts";
 import type { WorkflowModule, WorkflowRunOptions } from "./src/types.ts";
+import { WorkflowInspector } from "./src/ui/workflow-inspector.ts";
 import type { PerfSink, PerfSnapshot } from "./src/perf.ts";
+import { registerDynamax } from "./src/dynamax.ts";
+import { handleReviewViewerAction } from "./src/review/review-actions.ts";
+import { decideReviewResultsPresentation, extensionContextMode, maybeShowReviewResultsViewer } from "./src/review/review-results-flow.ts";
 import { isWorkflowResult, renderWorkflowResult, type WorkflowPerfDetails, type WorkflowResultEnvelope } from "./src/ui/workflow-result-renderer.ts";
 
 /** Extension root (this file lives in <repo>/.pi/extensions/pi-workflow-engine/index.ts). */
@@ -38,6 +43,7 @@ function formatPerfLine(perf: WorkflowPerfDetails | undefined): string | undefin
 
 type DiscoveryModule = typeof import("./src/discovery.ts");
 type EngineModule = typeof import("./src/engine.ts");
+type InlineWorkflowModule = typeof import("./src/inline-workflow.ts");
 
 async function loadDiscovery(): Promise<DiscoveryModule> {
   return await import("./src/discovery.ts");
@@ -47,6 +53,10 @@ async function loadEngine(): Promise<EngineModule> {
   return await import("./src/engine.ts");
 }
 
+async function loadInlineWorkflow(): Promise<InlineWorkflowModule> {
+  return await import("./src/inline-workflow.ts");
+}
+
 async function createInvocationPerf(options: WorkflowRunOptions): Promise<PerfSink | undefined> {
   const enabled = options.perf ?? process.env.PI_WORKFLOW_PERF === "1";
   if (!enabled) return undefined;
@@ -54,11 +64,34 @@ async function createInvocationPerf(options: WorkflowRunOptions): Promise<PerfSi
   return createPerfRecorder(true);
 }
 
+const AUTHOR_TEMP_WORKFLOW_CHOICE = "✍ Author temporary one-shot workflow…";
+
+export interface LastWorkflowInspection {
+  readonly name: string;
+  readonly args: string;
+  readonly completedAt: number;
+  readonly snapshot: WorkflowProgressSnapshot;
+}
+
+let lastWorkflowInspection: LastWorkflowInspection | undefined;
+
+export function getLastWorkflowInspection(): LastWorkflowInspection | undefined {
+  return lastWorkflowInspection;
+}
+
+export async function openWorkflowInspector(ctx: ExtensionCommandContext, inspection: LastWorkflowInspection): Promise<void> {
+  await ctx.ui.custom<void>(
+    (tui, theme, _keybindings, done) => new WorkflowInspector(() => inspection.snapshot, tui, theme, () => done(undefined)),
+    { overlay: true, overlayOptions: { anchor: "right-center", width: "60%", maxHeight: "80%", margin: 1 } },
+  );
+}
+
 export interface WorkflowInvocation {
   name: string;
   args: string;
   options: WorkflowRunOptions;
   refreshDiscovery?: boolean;
+  authorBrief?: string;
 }
 
 export function parseWorkflowInvocation(input: string): WorkflowInvocation {
@@ -89,6 +122,14 @@ function parseWorkflowOptions(input: string): { args: string; options: WorkflowR
       options.perf = true;
       continue;
     }
+    if (token === "--result-viewer" || token === "--review-viewer") {
+      options.resultViewer = "open";
+      continue;
+    }
+    if (token === "--no-result-viewer" || token === "--no-review-viewer") {
+      options.resultViewer = "skip";
+      continue;
+    }
     if (token.startsWith("--concurrency=")) {
       options.concurrency = parseNumericOption(token.slice("--concurrency=".length));
       continue;
@@ -120,22 +161,84 @@ function parseNumericOption(value: string | undefined): number | undefined {
   return Number.isFinite(parsed) ? parsed : undefined;
 }
 
-async function pickWorkflow(
+function compactInlinePreview(script: string | undefined): string {
+  if (!script) return "";
+  const compact = script.replace(/\s+/g, " ").trim();
+  return compact.length > 60 ? `${compact.slice(0, 57)}…` : compact;
+}
+
+export function buildTemporaryWorkflowAuthorPrompt(brief: string): string {
+  return `dynamax author and run a temporary one-shot inline workflow.
+
+User brief:
+${brief.trim()}
+
+Use the workflow tool with a script argument, not a saved workflow name.
+The script must start with export const meta = { ... } and default-export an async workflow function.
+Use the injected Type object for schemas. Do not import anything or use dynamic import().
+Set thinkingLevel explicitly on each agent() call.
+Do not edit files unless the user explicitly requested edits.`;
+}
+
+export interface WorkflowToolRequestParams {
+  readonly name?: string;
+  readonly script?: string;
+}
+
+export type WorkflowToolRequest =
+  | { readonly kind: "named"; readonly name: string }
+  | { readonly kind: "inline"; readonly script: string }
+  | { readonly kind: "error"; readonly error: "invalid_workflow_invocation"; readonly message: string };
+
+export interface WorkflowToolErrorResult {
+  readonly content: Array<{ readonly type: "text"; readonly text: string }>;
+  readonly details: { readonly error: "invalid_workflow_invocation" } | { readonly error: "inline_compile_error"; readonly message: string };
+}
+
+const INVALID_WORKFLOW_INVOCATION_MESSAGE = "Provide exactly one workflow name or inline workflow script.";
+
+export function normalizeWorkflowToolRequest(params: WorkflowToolRequestParams): WorkflowToolRequest {
+  const name = params.name?.trim() ?? "";
+  const script = params.script?.trim() ?? "";
+  const hasName = name.length > 0;
+  const hasScript = script.length > 0;
+  if (hasName === hasScript) return { kind: "error", error: "invalid_workflow_invocation", message: INVALID_WORKFLOW_INVOCATION_MESSAGE };
+  return hasName ? { kind: "named", name } : { kind: "inline", script };
+}
+
+export function invalidWorkflowInvocationResult(): WorkflowToolErrorResult {
+  return { content: [{ type: "text", text: INVALID_WORKFLOW_INVOCATION_MESSAGE }], details: { error: "invalid_workflow_invocation" } };
+}
+
+export function inlineCompileErrorResult(message: string): WorkflowToolErrorResult {
+  return { content: [{ type: "text", text: `Inline workflow did not compile: ${message}` }], details: { error: "inline_compile_error", message } };
+}
+
+export async function pickWorkflow(
   workflows: ReadonlyMap<string, WorkflowModule>,
   ctx: ExtensionCommandContext,
 ): Promise<WorkflowInvocation | undefined> {
-  const choices = [...workflows.values()].map((mod) => `${mod.meta.name} — ${mod.meta.description}`);
+  const choices = [AUTHOR_TEMP_WORKFLOW_CHOICE, ...[...workflows.values()].map((mod) => `${mod.meta.name} — ${mod.meta.description}`)];
   const choice = await ctx.ui.select("Run workflow", choices);
   if (!choice) return undefined;
 
+  if (choice === AUTHOR_TEMP_WORKFLOW_CHOICE) {
+    const brief = await ctx.ui.editor(
+      "Describe temporary workflow",
+      "Goal:\n\nAgents to run:\n- \n\nFinal output should include:\n- summary\n- findings\n- next steps\n",
+    );
+    const trimmed = brief?.trim();
+    if (!trimmed) return undefined;
+    return { name: "", args: "", options: {}, authorBrief: trimmed };
+  }
+
   const separator = choice.indexOf(" — ");
   const name = separator === -1 ? choice : choice.slice(0, separator);
   const args = name === "code-review" ? (await ctx.ui.input("Code-review target/instructions", "Blank = auto-detect diff"))?.trim() ?? "" : "";
-  const inspect = await ctx.ui.confirm("Open inspector?", "Open a live workflow inspector while this workflow runs?");
-  return { name, args, options: { inspect } };
+  return { name, args, options: {} };
 }
 
-async function sendWorkflowResult(
+export async function sendWorkflowResult(
   pi: ExtensionAPI,
   ctx: ExtensionCommandContext,
   name: string,
@@ -154,8 +257,24 @@ async function sendWorkflowResult(
       perfSnapshot = snapshot;
       options.onPerfSnapshot?.(snapshot);
     },
+    onProgressSnapshot(snapshot) {
+      lastWorkflowInspection = { name, args, completedAt: snapshot.doneAt ?? Date.now(), snapshot };
+      options.onProgressSnapshot?.(snapshot);
+    },
   });
   const perf = compactPerfSnapshot(perfSnapshot);
+  const reviewDecision = decideReviewResultsPresentation({
+    workflowName: name,
+    result,
+    mode: extensionContextMode(ctx),
+    hasUI: ctx.hasUI,
+    resultViewer: options.resultViewer,
+    invocationKind: "command",
+  });
+  const reviewAction = await maybeShowReviewResultsViewer(ctx, reviewDecision);
+  if (reviewDecision.kind !== "send") {
+    await handleReviewViewerAction(pi, ctx, reviewAction, reviewDecision.issues, reviewDecision.report.reviewContext);
+  }
   pi.sendMessage(
     { customType: "workflow-result", content: formatMessageContent(name, result, perf), display: true, details: workflowEnvelope(name, result, perf) },
     { triggerTurn: false },
@@ -163,12 +282,35 @@ async function sendWorkflowResult(
 }
 
 export default function workflowEngine(pi: ExtensionAPI): void {
+  registerDynamax(pi);
+
   pi.registerMessageRenderer("workflow-result", (message, { expanded }, theme) => {
     const details = message.details;
     if (isWorkflowResult(details)) return renderWorkflowResult(details.name, details.result, expanded, theme);
     return renderWorkflowResult("workflow", details ?? message.content, expanded, theme);
   });
 
+  pi.registerCommand("workflow:inspector", {
+    description: "Open the last completed workflow inspector",
+    handler: async (args: string, ctx: ExtensionCommandContext) => {
+      const trimmed = args.trim();
+      if (trimmed && trimmed !== "last") {
+        ctx.ui.notify("Usage: /workflow:inspector [last]", "warning");
+        return;
+      }
+      if (!ctx.hasUI) {
+        ctx.ui.notify("Workflow inspector requires the TUI", "warning");
+        return;
+      }
+      const inspection = lastWorkflowInspection;
+      if (!inspection) {
+        ctx.ui.notify("No completed workflow inspector is available yet", "warning");
+        return;
+      }
+      await openWorkflowInspector(ctx, inspection);
+    },
+  });
+
   // /workflow <name> [args] — user-invoked.
   pi.registerCommand("workflow", {
     description: "Run a multi-agent workflow: /workflow <name> [args]",
@@ -185,6 +327,11 @@ export default function workflowEngine(pi: ExtensionAPI): void {
         return;
       }
 
+      if (invocation.authorBrief) {
+        pi.sendUserMessage(buildTemporaryWorkflowAuthorPrompt(invocation.authorBrief));
+        return;
+      }
+
       const mod = workflows.get(invocation.name);
       if (!mod) {
         ctx.ui.notify(`Unknown workflow "${invocation.name}". Available: ${available}`, "error");
@@ -200,9 +347,18 @@ export default function workflowEngine(pi: ExtensionAPI): void {
     name: "workflow",
     label: "Workflow",
     description:
-      "Run a named multi-agent workflow (fan-out → verify → synthesize) and return its structured result. Use for thorough reviews or audits.",
+      "ONLY call workflow when the user opted into multi-agent orchestration via the literal token `dynamax`, sticky `/workflow:dynamax on`, an explicit request to run or author a workflow, or a command/skill instruction. Runs either a registered named workflow or an inline one-off workflow script (fan-out → verify → synthesize) and returns its structured result.",
+    promptSnippet: "Run an existing named workflow or an inline one-off workflow script",
+    promptGuidelines: [
+      "Use workflow only when the user opted into workflow orchestration via `dynamax`, `/workflow:dynamax on`, an explicit request to run/author a workflow, or a command/skill instruction.",
+      "Use workflow with `name` for existing registered workflows such as code-review, diagnose, refactor-scout, or perf-review.",
+      "Use workflow with `script` for a new one-off inline workflow; the script must start with `export const meta = { ... }` and default-export an async workflow function.",
+      "Inline workflow scripts must use the injected `Type` object for schemas and must not contain imports or dynamic import().",
+      "Every workflow tool call must provide exactly one of `name` or `script`, never both.",
+    ],
     parameters: Type.Object({
-      name: Type.String({ description: "Workflow name, e.g. code-review" }),
+      name: Type.Optional(Type.String({ description: "Workflow name, e.g. code-review. Provide exactly one of name or script." })),
+      script: Type.Optional(Type.String({ description: "Inline workflow script. Provide exactly one of script or name." })),
       args: Type.Optional(Type.String({ description: "Arguments for the workflow (e.g. target or focus)" })),
       concurrency: Type.Optional(Type.Number({ description: "Optional per-run agent concurrency cap" })),
       parallelSubmissionLimit: Type.Optional(Type.Number({ description: "Optional limit for eagerly submitted parallel thunks" })),
@@ -210,7 +366,12 @@ export default function workflowEngine(pi: ExtensionAPI): void {
     }),
     renderCall(args, theme) {
       const suffix = args.args ? ` ${theme.fg("dim", args.args)}` : "";
-      return new Text(`▸ ${theme.fg("toolTitle", theme.bold("workflow"))} ${theme.fg("accent", args.name)}${suffix}`, 0, 0);
+      if (args.name?.trim()) {
+        return new Text(`▸ ${theme.fg("toolTitle", theme.bold("workflow"))} ${theme.fg("accent", args.name.trim())}${suffix}`, 0, 0);
+      }
+      const preview = compactInlinePreview(args.script);
+      const previewSuffix = preview ? ` ${theme.fg("dim", preview)}` : "";
+      return new Text(`▸ ${theme.fg("toolTitle", theme.bold("workflow"))} ${theme.fg("accent", "inline")}${suffix}${previewSuffix}`, 0, 0);
     },
     renderResult(result, { expanded, isPartial }, theme) {
       if (isPartial) return new Text(theme.fg("accent", "Running workflow…"), 0, 0);
@@ -221,6 +382,9 @@ export default function workflowEngine(pi: ExtensionAPI): void {
       return new Text(theme.fg("muted", text), 0, 0);
     },
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      const request = normalizeWorkflowToolRequest(params);
+      if (request.kind === "error") return invalidWorkflowInvocationResult();
+
       const runOptions: WorkflowRunOptions = {
         concurrency: params.concurrency,
         parallelSubmissionLimit: params.parallelSubmissionLimit,
@@ -228,16 +392,33 @@ export default function workflowEngine(pi: ExtensionAPI): void {
         signal,
       };
       const perfRecorder = await createInvocationPerf(runOptions);
-      const { discoverWorkflows } = await loadDiscovery();
-      const workflows = await discoverWorkflows(EXTENSION_DIR, { perf: perfRecorder });
-      const mod = workflows.get(params.name);
-      if (!mod) {
-        const available = [...workflows.keys()].join(", ") || "(none)";
-        return {
-          content: [{ type: "text", text: `Unknown workflow "${params.name}". Available: ${available}` }],
-          details: { error: "unknown_workflow", available },
-        };
+      let mod: WorkflowModule;
+      let resultName: string;
+
+      if (request.kind === "named") {
+        const { discoverWorkflows } = await loadDiscovery();
+        const workflows = await discoverWorkflows(EXTENSION_DIR, { perf: perfRecorder });
+        const named = workflows.get(request.name);
+        if (!named) {
+          const available = [...workflows.keys()].join(", ") || "(none)";
+          return {
+            content: [{ type: "text", text: `Unknown workflow "${request.name}". Available: ${available}` }],
+            details: { error: "unknown_workflow", available },
+          };
+        }
+        mod = named;
+        resultName = request.name;
+      } else {
+        const inline = await loadInlineWorkflow();
+        try {
+          mod = inline.compileInlineWorkflow(request.script);
+        } catch (error) {
+          if (error instanceof inline.InlineWorkflowCompileError) return inlineCompileErrorResult(error.message);
+          throw error;
+        }
+        resultName = mod.meta.name;
       }
+
       const { runWorkflow } = await loadEngine();
       let perfSnapshot: PerfSnapshot | undefined;
       const result = await runWorkflow(ctx, mod, params.args ?? "", {
@@ -250,7 +431,7 @@ export default function workflowEngine(pi: ExtensionAPI): void {
       });
       const perf = compactPerfSnapshot(perfSnapshot);
       const perfLine = formatPerfLine(perf);
-      return { content: [{ type: "text", text: `${summarize(result)}${perfLine ? `\n\n${perfLine}` : ""}` }], details: workflowEnvelope(params.name, result, perf) };
+      return { content: [{ type: "text", text: `${summarize(result)}${perfLine ? `\n\n${perfLine}` : ""}` }], details: workflowEnvelope(resultName, result, perf) };
     },
   });
 }

package/.pi/extensions/pi-workflow-engine/src/discovery.ts

@@ -2,15 +2,11 @@ import { readdir } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
-import type { WorkflowMeta, WorkflowModule } from "./types.ts";
+import type { WorkflowModule } from "./types.ts";
 import type { PerfSink } from "./perf.ts";
+import { parseWorkflowModule } from "./workflow-module.ts";
 import { BUILTIN_WORKFLOW_FILES, BUILTIN_WORKFLOWS } from "./workflows.ts";
 
-type WorkflowModuleCandidate = {
-  meta?: { name?: unknown; description?: unknown; phases?: unknown };
-  default?: unknown;
-};
-
 export interface DiscoverWorkflowsOptions {
   readonly refresh?: boolean;
   readonly perf?: PerfSink;
@@ -19,33 +15,6 @@ export interface DiscoverWorkflowsOptions {
 
 const discoveryCache = new Map<string, Map<string, WorkflowModule>>();
 
-function parseWorkflowModule(value: unknown): { module: WorkflowModule } | { reason: string } {
-  if (!value || typeof value !== "object") return { reason: "module export is not an object" };
-  const candidate = value as WorkflowModuleCandidate;
-  const meta = candidate.meta;
-  if (!meta || typeof meta !== "object") return { reason: "missing meta export" };
-  if (typeof meta.name !== "string") return { reason: "meta.name must be a string" };
-
-  const description = meta.description;
-  if (description !== undefined && typeof description !== "string") return { reason: "meta.description must be a string when provided" };
-
-  const phases = meta.phases;
-  if (phases !== undefined && !isWorkflowPhases(phases)) return { reason: "meta.phases must be an array of { title: string }" };
-  if (!isWorkflowRun(candidate.default)) return { reason: "default export must be a function" };
-
-  const workflowMeta: WorkflowMeta = { name: meta.name, description: description ?? "" };
-  if (phases !== undefined) workflowMeta.phases = phases;
-  return { module: { meta: workflowMeta, default: candidate.default } };
-}
-
-function isWorkflowRun(value: unknown): value is WorkflowModule["default"] {
-  return typeof value === "function";
-}
-
-function isWorkflowPhases(value: unknown): value is Array<{ title: string }> {
-  return Array.isArray(value) && value.every((phase) => typeof phase === "object" && phase !== null && typeof (phase as { title?: unknown }).title === "string");
-}
-
 /** Best-effort dynamic load of every `*.ts` workflow in a directory. */
 async function loadDir(dir: string, excludeFiles: ReadonlySet<string> = new Set()): Promise<WorkflowModule[]> {
   let entries: string[];

package/.pi/extensions/pi-workflow-engine/src/dynamax.ts

@@ -0,0 +1,123 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+export interface DynamaxState {
+  sticky: boolean;
+  oneShotPending: boolean;
+}
+
+export const DYNAMAX_TOKEN_PATTERN = /(^|[^A-Za-z0-9_])dynamax([^A-Za-z0-9_]|$)/i;
+
+export const DYNAMAX_REMINDER = `
+## dynamax workflow opt-in
+
+The user has opted into dynamax multi-agent orchestration. The workflow tool is permitted for this task. You may either run an existing named workflow or author a new inline workflow script when that best serves the user's request.
+
+Inline workflow rules:
+- Use the injected Type object for schemas, for example Type.Object({ ok: Type.Boolean() }); do not import typebox.
+- Do not use import statements or dynamic import() in inline workflow scripts.
+- Set thinkingLevel explicitly on each agent() call so fan-out remains bounded.
+- Provide exactly one of workflow.name or workflow.script.
+`;
+
+const DYNAMAX_CONTEXT_CUSTOM_TYPE = "workflow-dynamax-reminder";
+
+export function createDynamaxState(): DynamaxState {
+  return { sticky: false, oneShotPending: false };
+}
+
+export function hasDynamaxToken(text: string): boolean {
+  return DYNAMAX_TOKEN_PATTERN.test(text);
+}
+
+export function markDynamaxOneShot(state: DynamaxState): void {
+  state.oneShotPending = true;
+}
+
+export function setDynamaxSticky(state: DynamaxState, sticky: boolean): void {
+  state.sticky = sticky;
+  if (!sticky) state.oneShotPending = false;
+}
+
+export function clearDynamax(state: DynamaxState): void {
+  state.sticky = false;
+  state.oneShotPending = false;
+}
+
+export function consumeDynamaxOneShot(state: DynamaxState): boolean {
+  const pending = state.oneShotPending;
+  state.oneShotPending = false;
+  return pending;
+}
+
+export function isDynamaxActive(state: DynamaxState): boolean {
+  return state.sticky || state.oneShotPending;
+}
+
+export function appendDynamaxSystemReminder(systemPrompt: string, state: DynamaxState): string {
+  if (!isDynamaxActive(state)) return systemPrompt;
+  state.oneShotPending = false;
+  return `${systemPrompt}\n\n${DYNAMAX_REMINDER.trim()}`;
+}
+
+export function appendDynamaxContextReminder(messages: AgentMessage[], state: DynamaxState): AgentMessage[] {
+  if (!state.sticky) return messages;
+  return [...messages, createDynamaxContextMessage()];
+}
+
+export function registerDynamax(pi: ExtensionAPI): void {
+  const state = createDynamaxState();
+
+  pi.on("input", (event) => {
+    if (event.source === "extension") return { action: "continue" };
+    if (hasDynamaxToken(event.text)) markDynamaxOneShot(state);
+    return { action: "continue" };
+  });
+
+  pi.on("before_agent_start", (event) => {
+    const systemPrompt = appendDynamaxSystemReminder(event.systemPrompt, state);
+    if (systemPrompt === event.systemPrompt) return undefined;
+    return { systemPrompt };
+  });
+
+  pi.on("context", (event) => {
+    const messages = appendDynamaxContextReminder(event.messages, state);
+    if (messages === event.messages) return undefined;
+    return { messages };
+  });
+
+  pi.registerCommand("workflow:dynamax", {
+    description: "Toggle dynamax workflow orchestration opt-in: /workflow:dynamax on|off|status",
+    handler: async (args, ctx) => {
+      const action = args.trim().toLowerCase();
+      if (action === "on") {
+        setDynamaxSticky(state, true);
+        ctx.ui.notify("dynamax workflow orchestration is on for this session", "info");
+        return;
+      }
+      if (action === "off") {
+        clearDynamax(state);
+        ctx.ui.notify("dynamax workflow orchestration is off", "info");
+        return;
+      }
+      if (action === "status") {
+        const sticky = state.sticky ? "on" : "off";
+        const oneShot = state.oneShotPending ? "; one-shot opt-in pending" : "";
+        ctx.ui.notify(`dynamax sticky mode is ${sticky}${oneShot}`, "info");
+        return;
+      }
+      ctx.ui.notify("Usage: /workflow:dynamax on|off|status", "warning");
+    },
+  });
+}
+
+function createDynamaxContextMessage(): AgentMessage {
+  return {
+    role: "custom",
+    customType: DYNAMAX_CONTEXT_CUSTOM_TYPE,
+    content: DYNAMAX_REMINDER.trim(),
+    display: false,
+    details: { dynamax: true, sticky: true },
+    timestamp: Date.now(),
+  };
+}

package/.pi/extensions/pi-workflow-engine/src/engine.ts

@@ -68,14 +68,18 @@ export async function runWorkflow(
   try {
     return await perf.time("workflow.total_ms", () => mod.default(api));
   } finally {
-    const snapshot = perf.snapshot();
-    if (resolvedOptions.perf) {
-      resolvedOptions.onPerfSnapshot?.(snapshot);
-      progress.log(formatPerfSummary(snapshot));
+    try {
+      const snapshot = perf.snapshot();
+      if (resolvedOptions.perf) {
+        resolvedOptions.onPerfSnapshot?.(snapshot);
+        progress.log(formatPerfSummary(snapshot));
+      }
+      progress.done();
+      resolvedOptions.onProgressSnapshot?.(progress.snapshot());
+    } finally {
+      unlinkContextAbortSignal();
+      unlinkOptionAbortSignal();
     }
-    unlinkContextAbortSignal();
-    unlinkOptionAbortSignal();
-    progress.done();
   }
 }