pi-workflow-engine 0.5.0 → 0.7.0

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

@@ -1,10 +1,14 @@
 import { fileURLToPath } from "node:url";
 import { Type } from "typebox";
-import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
-import type { WorkflowModule, WorkflowRunOptions } from "./src/types.ts";
+import type { WorkflowProgressSnapshot } from "./src/progress.ts";
+import type { WorkflowModule, WorkflowProgressSource, WorkflowRef, 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). */
@@ -60,8 +64,76 @@ async function createInvocationPerf(options: WorkflowRunOptions): Promise<PerfSi
   return createPerfRecorder(true);
 }
 
+/**
+ * Resolve an `api.workflow()` reference to a registered workflow module. Throws on an unknown name.
+ */
+export async function resolveWorkflowRef(ref: WorkflowRef, perf?: PerfSink): Promise<WorkflowModule> {
+  const { discoverWorkflows } = await loadDiscovery();
+  const workflows = await discoverWorkflows(EXTENSION_DIR, { perf });
+  const mod = workflows.get(ref);
+  if (!mod) {
+    const available = [...workflows.keys()].join(", ") || "(none)";
+    throw new Error(`Unknown workflow "${ref}". Available: ${available}`);
+  }
+  return mod;
+}
+
 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;
+}
+
+export interface ActiveWorkflowInspection {
+  readonly name: string;
+  readonly args: string;
+  readonly startedAt: number;
+  readonly snapshot: () => WorkflowProgressSnapshot;
+}
+
+let lastWorkflowInspection: LastWorkflowInspection | undefined;
+let activeWorkflowInspection: ActiveWorkflowInspection | undefined;
+
+export function getLastWorkflowInspection(): LastWorkflowInspection | undefined {
+  return lastWorkflowInspection;
+}
+
+export function getActiveWorkflowInspection(): ActiveWorkflowInspection | undefined {
+  return activeWorkflowInspection;
+}
+
+export async function openWorkflowInspector(ctx: ExtensionContext, inspection: LastWorkflowInspection | ActiveWorkflowInspection): Promise<void> {
+  await ctx.ui.custom<void>(
+    (tui, theme, _keybindings, done) => new WorkflowInspector(snapshotGetter(inspection), tui, theme, () => done(undefined)),
+    { overlay: true, overlayOptions: { anchor: "right-center", width: "60%", maxHeight: "80%", margin: 1 } },
+  );
+}
+
+async function openAvailableWorkflowInspector(ctx: ExtensionContext): Promise<void> {
+  if (!ctx.hasUI) {
+    ctx.ui.notify("Workflow inspector requires the TUI", "warning");
+    return;
+  }
+  const inspection = activeWorkflowInspection ?? lastWorkflowInspection;
+  if (!inspection) {
+    ctx.ui.notify("No workflow inspector is available yet", "warning");
+    return;
+  }
+  await openWorkflowInspector(ctx, inspection);
+}
+
+function snapshotGetter(inspection: LastWorkflowInspection | ActiveWorkflowInspection): () => WorkflowProgressSnapshot {
+  const snapshot = inspection.snapshot;
+  return typeof snapshot === "function" ? snapshot : () => snapshot;
+}
+
+function bindActiveWorkflowInspection(name: string, args: string, source: WorkflowProgressSource): ActiveWorkflowInspection {
+  return { name, args, startedAt: Date.now(), snapshot: () => source.snapshot() };
+}
+
 export interface WorkflowInvocation {
   name: string;
   args: string;
@@ -98,6 +170,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;
@@ -182,7 +262,7 @@ export function inlineCompileErrorResult(message: string): WorkflowToolErrorResu
   return { content: [{ type: "text", text: `Inline workflow did not compile: ${message}` }], details: { error: "inline_compile_error", message } };
 }
 
-async function pickWorkflow(
+export async function pickWorkflow(
   workflows: ReadonlyMap<string, WorkflowModule>,
   ctx: ExtensionCommandContext,
 ): Promise<WorkflowInvocation | undefined> {
@@ -203,11 +283,10 @@ async function pickWorkflow(
   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,
@@ -218,16 +297,44 @@ async function sendWorkflowResult(
 ): Promise<void> {
   const { runWorkflow } = await loadEngine();
   let perfSnapshot: PerfSnapshot | undefined;
+  let liveInspection: ActiveWorkflowInspection | undefined;
   const result = await runWorkflow(ctx, mod, args, {
     ...options,
     perf: options.perf ?? perfRecorder !== undefined,
     perfRecorder,
+    resolveWorkflow: (ref) => resolveWorkflowRef(ref, perfRecorder),
+    onProgressSource(source) {
+      if (source) {
+        liveInspection = bindActiveWorkflowInspection(name, args, source);
+        activeWorkflowInspection = liveInspection;
+      } else if (activeWorkflowInspection === liveInspection) {
+        activeWorkflowInspection = undefined;
+        liveInspection = undefined;
+      }
+      options.onProgressSource?.(source);
+    },
     onPerfSnapshot(snapshot) {
       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 },
@@ -235,7 +342,7 @@ async function sendWorkflowResult(
 }
 
 export default function workflowEngine(pi: ExtensionAPI): void {
-  registerDynamax(pi);
+  registerDynamax(pi, undefined, { openInspector: openAvailableWorkflowInspector });
 
   pi.registerMessageRenderer("workflow-result", (message, { expanded }, theme) => {
     const details = message.details;
@@ -243,6 +350,18 @@ export default function workflowEngine(pi: ExtensionAPI): void {
     return renderWorkflowResult("workflow", details ?? message.content, expanded, theme);
   });
 
+  pi.registerCommand("workflow:inspector", {
+    description: "Open the current or last 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;
+      }
+      await openAvailableWorkflowInspector(ctx);
+    },
+  });
+
   // /workflow <name> [args] — user-invoked.
   pi.registerCommand("workflow", {
     description: "Run a multi-agent workflow: /workflow <name> [args]",
@@ -279,13 +398,14 @@ export default function workflowEngine(pi: ExtensionAPI): void {
     name: "workflow",
     label: "Workflow",
     description:
-      "ONLY call workflow when the user opted into multi-agent orchestration via the literal token `dynamax`, sticky `/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.",
+      "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`, `/dynamax on`, an explicit request to run/author a workflow, or a command/skill instruction.",
+      "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().",
+      "Inline scripts may compose registered workflows in-process via `api.workflow(\"<name>\", args)` (e.g. `await api.workflow(\"code-review\", \"HEAD~3\")`); it returns the sub-workflow's result and nests one level only.",
       "Every workflow tool call must provide exactly one of `name` or `script`, never both.",
     ],
     parameters: Type.Object({
@@ -318,6 +438,7 @@ export default function workflowEngine(pi: ExtensionAPI): void {
       if (request.kind === "error") return invalidWorkflowInvocationResult();
 
       const runOptions: WorkflowRunOptions = {
+        inspect: ctx.hasUI,
         concurrency: params.concurrency,
         parallelSubmissionLimit: params.parallelSubmissionLimit,
         perf: params.perf,
@@ -353,13 +474,30 @@ export default function workflowEngine(pi: ExtensionAPI): void {
 
       const { runWorkflow } = await loadEngine();
       let perfSnapshot: PerfSnapshot | undefined;
-      const result = await runWorkflow(ctx, mod, params.args ?? "", {
+      let liveInspection: ActiveWorkflowInspection | undefined;
+      const resultArgs = params.args ?? "";
+      const result = await runWorkflow(ctx, mod, resultArgs, {
         ...runOptions,
         perf: runOptions.perf ?? perfRecorder !== undefined,
         perfRecorder,
+        resolveWorkflow: (ref) => resolveWorkflowRef(ref, perfRecorder),
+        onProgressSource(source) {
+          if (source) {
+            liveInspection = bindActiveWorkflowInspection(resultName, resultArgs, source);
+            activeWorkflowInspection = liveInspection;
+          } else if (activeWorkflowInspection === liveInspection) {
+            activeWorkflowInspection = undefined;
+            liveInspection = undefined;
+          }
+        },
         onPerfSnapshot: (snapshot) => {
           perfSnapshot = snapshot;
         },
+        onProgressSnapshot: (snapshot) => {
+          // Record the run so /workflow:inspector can reopen it — tool-invoked (dynamax) runs were
+          // previously uninspectable, unlike the /workflow command path.
+          lastWorkflowInspection = { name: resultName, args: resultArgs, completedAt: snapshot.doneAt ?? Date.now(), snapshot };
+        },
       });
       const perf = compactPerfSnapshot(perfSnapshot);
       const perfLine = formatPerfLine(perf);

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

@@ -0,0 +1,75 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import type { KeyId } from "@earendil-works/pi-tui";
+
+export const DEFAULT_DYNAMAX_INSPECTOR_SHORTCUT = "ctrl+shift+m" satisfies KeyId;
+
+const CONFIG_FILE_NAME = "pi-workflow-engine.json";
+
+export interface DynamaxShortcuts {
+  inspector: KeyId | null;
+}
+
+interface DynamaxShortcutConfig {
+  inspector?: unknown;
+}
+
+export function dynamaxShortcutsConfigPath(agentDir: string = getAgentDir()): string {
+  return join(agentDir, "extensions", CONFIG_FILE_NAME);
+}
+
+export function resolveDynamaxShortcuts(configPath: string = dynamaxShortcutsConfigPath()): DynamaxShortcuts {
+  if (!existsSync(configPath)) return defaultDynamaxShortcuts();
+
+  const config = readShortcutConfig(configPath);
+  if (!config) return defaultDynamaxShortcuts();
+
+  return {
+    inspector: shortcutFromConfig(config.inspector, DEFAULT_DYNAMAX_INSPECTOR_SHORTCUT),
+  };
+}
+
+function readShortcutConfig(configPath: string): DynamaxShortcutConfig | null {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(readFileSync(configPath, "utf-8"));
+  } catch {
+    warnUsingDefaults("Could not read", configPath);
+    return null;
+  }
+
+  const shortcuts = isRecord(parsed) ? parsed.shortcuts : undefined;
+  if (shortcuts === undefined) return {};
+  if (!isRecord(shortcuts) || !hasValidShortcutValues(shortcuts)) {
+    warnUsingDefaults("Invalid", configPath);
+    return null;
+  }
+
+  return shortcuts;
+}
+
+function hasValidShortcutValues(shortcuts: Record<string, unknown>): boolean {
+  return isValidShortcutConfigValue(shortcuts.inspector);
+}
+
+function isValidShortcutConfigValue(value: unknown): value is string | null | undefined {
+  return value === undefined || value === null || (typeof value === "string" && value.trim().length > 0);
+}
+
+function shortcutFromConfig(configured: unknown, fallback: KeyId): KeyId | null {
+  if (configured === null) return null;
+  return typeof configured === "string" ? (configured.trim() as KeyId) : fallback;
+}
+
+function defaultDynamaxShortcuts(): DynamaxShortcuts {
+  return { inspector: DEFAULT_DYNAMAX_INSPECTOR_SHORTCUT };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function warnUsingDefaults(reason: "Could not read" | "Invalid", configPath: string): void {
+  console.warn(`${reason} pi-workflow-engine config at ${configPath}; using default Dynamax shortcuts.`);
+}

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

@@ -1,12 +1,27 @@
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { KeyId } from "@earendil-works/pi-tui";
+import { resolveDynamaxShortcuts, type DynamaxShortcuts } from "./dynamax-shortcuts.ts";
 
 export interface DynamaxState {
   sticky: boolean;
   oneShotPending: boolean;
+  turnActive: boolean;
+}
+
+export interface DynamaxRuntime {
+  state: DynamaxState;
+  runningWorkflow?: string;
+}
+
+export type DynamaxRuntimeStore = Map<string, DynamaxRuntime>;
+export interface DynamaxRegistrationOptions {
+  openInspector?: (ctx: ExtensionContext) => Promise<void> | void;
 }
 
 export const DYNAMAX_TOKEN_PATTERN = /(^|[^A-Za-z0-9_])dynamax([^A-Za-z0-9_]|$)/i;
+export const DYNAMAX_STATUS_KEY = "dynamax";
+export const DYNAMAX_WIDGET_KEY = "workflow-dynamax";
 
 export const DYNAMAX_REMINDER = `
 ## dynamax workflow opt-in
@@ -23,7 +38,24 @@ Inline workflow rules:
 const DYNAMAX_CONTEXT_CUSTOM_TYPE = "workflow-dynamax-reminder";
 
 export function createDynamaxState(): DynamaxState {
-  return { sticky: false, oneShotPending: false };
+  return { sticky: false, oneShotPending: false, turnActive: false };
+}
+
+export function createDynamaxRuntime(): DynamaxRuntime {
+  return { state: createDynamaxState() };
+}
+
+export function dynamaxSessionKey(ctx: Pick<ExtensionContext, "sessionManager">): string {
+  return ctx.sessionManager.getSessionFile() ?? ctx.sessionManager.getSessionId();
+}
+
+export function getDynamaxRuntime(store: DynamaxRuntimeStore, ctx: Pick<ExtensionContext, "sessionManager">): DynamaxRuntime {
+  const key = dynamaxSessionKey(ctx);
+  const existing = store.get(key);
+  if (existing) return existing;
+  const runtime = createDynamaxRuntime();
+  store.set(key, runtime);
+  return runtime;
 }
 
 export function hasDynamaxToken(text: string): boolean {
@@ -36,12 +68,16 @@ export function markDynamaxOneShot(state: DynamaxState): void {
 
 export function setDynamaxSticky(state: DynamaxState, sticky: boolean): void {
   state.sticky = sticky;
-  if (!sticky) state.oneShotPending = false;
+  if (!sticky) {
+    state.oneShotPending = false;
+    state.turnActive = false;
+  }
 }
 
 export function clearDynamax(state: DynamaxState): void {
   state.sticky = false;
   state.oneShotPending = false;
+  state.turnActive = false;
 }
 
 export function consumeDynamaxOneShot(state: DynamaxState): boolean {
@@ -51,12 +87,32 @@ export function consumeDynamaxOneShot(state: DynamaxState): boolean {
 }
 
 export function isDynamaxActive(state: DynamaxState): boolean {
-  return state.sticky || state.oneShotPending;
+  return state.sticky || state.oneShotPending || state.turnActive;
+}
+
+export function describeDynamaxState(state: DynamaxState): string {
+  const sticky = state.sticky ? "on" : "off";
+  const oneShot = state.oneShotPending ? "pending" : "clear";
+  const turn = state.turnActive ? "; active for current turn" : "";
+  return `sticky ${sticky}; one-shot ${oneShot}${turn}`;
+}
+
+export function dynamaxWidgetLine(state: DynamaxState, shortcut: KeyId | null, runningWorkflow?: string): string {
+  const modes = [
+    runningWorkflow ? `running ${runningWorkflow}` : undefined,
+    state.sticky ? "sticky on" : undefined,
+    !state.sticky && state.turnActive ? "active this turn" : undefined,
+    state.oneShotPending ? "one-shot pending" : undefined,
+  ].filter((value): value is string => value !== undefined);
+  const mode = modes.join(" + ") || "off";
+  const inspectorHint = shortcut ? `${shortcut} inspector` : "/workflow:inspector";
+  return `dynamax: ${mode} | /workflow:dynamax on|off | ${inspectorHint}`;
 }
 
 export function appendDynamaxSystemReminder(systemPrompt: string, state: DynamaxState): string {
-  if (!isDynamaxActive(state)) return systemPrompt;
+  if (!state.sticky && !state.oneShotPending) return systemPrompt;
   state.oneShotPending = false;
+  state.turnActive = true;
   return `${systemPrompt}\n\n${DYNAMAX_REMINDER.trim()}`;
 }
 
@@ -65,52 +121,174 @@ export function appendDynamaxContextReminder(messages: AgentMessage[], state: Dy
   return [...messages, createDynamaxContextMessage()];
 }
 
-export function registerDynamax(pi: ExtensionAPI): void {
-  const state = createDynamaxState();
+export function registerDynamax(
+  pi: ExtensionAPI,
+  shortcuts: DynamaxShortcuts = resolveDynamaxShortcuts(),
+  options: DynamaxRegistrationOptions = {},
+): void {
+  const runtimes: DynamaxRuntimeStore = new Map();
+  const openInspector =
+    options.openInspector ??
+    ((ctx: ExtensionContext): void => {
+      ctx.ui.notify("No workflow inspector is available yet", "warning");
+    });
+  const refreshIfVisible = (ctx: ExtensionContext): void => {
+    const runtime = getDynamaxRuntime(runtimes, ctx);
+    if (isDynamaxActive(runtime.state) || runtime.runningWorkflow) {
+      updateDynamaxSurfaces(ctx, runtime, shortcuts);
+    }
+  };
+
+  pi.on("session_start", (_event, ctx) => {
+    updateDynamaxSurfaces(ctx, getDynamaxRuntime(runtimes, ctx), shortcuts);
+  });
+
+  pi.on("session_shutdown", (_event, ctx) => {
+    clearDynamaxSurfaces(ctx, getDynamaxRuntime(runtimes, ctx));
+  });
 
-  pi.on("input", (event) => {
+  pi.on("input", (event, ctx) => {
     if (event.source === "extension") return { action: "continue" };
-    if (hasDynamaxToken(event.text)) markDynamaxOneShot(state);
+    const runtime = getDynamaxRuntime(runtimes, ctx);
+    if (hasDynamaxToken(event.text)) {
+      markDynamaxOneShot(runtime.state);
+      updateDynamaxSurfaces(ctx, runtime, shortcuts);
+    }
     return { action: "continue" };
   });
 
-  pi.on("before_agent_start", (event) => {
-    const systemPrompt = appendDynamaxSystemReminder(event.systemPrompt, state);
+  pi.on("before_agent_start", (event, ctx) => {
+    const runtime = getDynamaxRuntime(runtimes, ctx);
+    const systemPrompt = appendDynamaxSystemReminder(event.systemPrompt, runtime.state);
     if (systemPrompt === event.systemPrompt) return undefined;
+    updateDynamaxSurfaces(ctx, runtime, shortcuts);
     return { systemPrompt };
   });
 
-  pi.on("context", (event) => {
-    const messages = appendDynamaxContextReminder(event.messages, state);
+  pi.on("agent_start", (_event, ctx) => {
+    refreshIfVisible(ctx);
+  });
+
+  pi.on("message_start", (_event, ctx) => {
+    refreshIfVisible(ctx);
+  });
+
+  pi.on("message_update", (_event, ctx) => {
+    refreshIfVisible(ctx);
+  });
+
+  pi.on("message_end", (_event, ctx) => {
+    refreshIfVisible(ctx);
+  });
+
+  pi.on("turn_end", (_event, ctx) => {
+    refreshIfVisible(ctx);
+  });
+
+  pi.on("agent_end", (_event, ctx) => {
+    const runtime = getDynamaxRuntime(runtimes, ctx);
+    runtime.runningWorkflow = undefined;
+    if (!runtime.state.sticky) runtime.state.turnActive = false;
+    updateDynamaxSurfaces(ctx, runtime, shortcuts);
+  });
+
+  pi.on("tool_execution_start", (event, ctx) => {
+    const runtime = getDynamaxRuntime(runtimes, ctx);
+    if (event.toolName === "workflow") {
+      runtime.runningWorkflow = workflowLabel(event.args);
+    }
+    updateDynamaxSurfaces(ctx, runtime, shortcuts);
+    return undefined;
+  });
+
+  pi.on("tool_execution_update", (_event, ctx) => {
+    refreshIfVisible(ctx);
+  });
+
+  pi.on("tool_execution_end", (event, ctx) => {
+    const runtime = getDynamaxRuntime(runtimes, ctx);
+    if (event.toolName === "workflow") {
+      runtime.runningWorkflow = undefined;
+    }
+    updateDynamaxSurfaces(ctx, runtime, shortcuts);
+    return undefined;
+  });
+
+  pi.on("context", (event, ctx) => {
+    const runtime = getDynamaxRuntime(runtimes, ctx);
+    const messages = appendDynamaxContextReminder(event.messages, runtime.state);
     if (messages === event.messages) return undefined;
     return { messages };
   });
 
-  pi.registerCommand("dynamax", {
-    description: "Toggle dynamax workflow orchestration opt-in: /dynamax on|off|status",
+  if (shortcuts.inspector) {
+    pi.registerShortcut(shortcuts.inspector, {
+      description: "Open workflow inspector",
+      handler: async (ctx) => {
+        await openInspector(ctx);
+      },
+    });
+  }
+
+  pi.registerCommand("workflow:dynamax", {
+    description: "Toggle Dynamax workflow orchestration: /workflow:dynamax [on|off|status]",
     handler: async (args, ctx) => {
+      const runtime = getDynamaxRuntime(runtimes, ctx);
       const action = args.trim().toLowerCase();
+      if (action === "") {
+        ctx.ui.notify(`Dynamax ${describeDynamaxState(runtime.state)}. Usage: /workflow:dynamax [on|off|status]`, "info");
+        return;
+      }
       if (action === "on") {
-        setDynamaxSticky(state, true);
-        ctx.ui.notify("dynamax workflow orchestration is on for this session", "info");
+        setDynamaxSticky(runtime.state, true);
+        updateDynamaxSurfaces(ctx, runtime, shortcuts);
+        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");
+        clearDynamax(runtime.state);
+        updateDynamaxSurfaces(ctx, runtime, shortcuts);
+        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");
+        ctx.ui.notify(`Dynamax ${describeDynamaxState(runtime.state)}`, "info");
         return;
       }
-      ctx.ui.notify("Usage: /dynamax on|off|status", "warning");
+      ctx.ui.notify("Usage: /workflow:dynamax [on|off|status]", "warning");
     },
   });
 }
 
+export function updateDynamaxSurfaces(ctx: Pick<ExtensionContext, "hasUI" | "ui">, runtime: DynamaxRuntime, shortcuts: DynamaxShortcuts): void {
+  if (!ctx.hasUI) return;
+  ctx.ui.setWidget(DYNAMAX_WIDGET_KEY, undefined);
+  ctx.ui.setStatus(DYNAMAX_WIDGET_KEY, undefined);
+  if (!isDynamaxActive(runtime.state) && !runtime.runningWorkflow) {
+    clearDynamaxSurfaces(ctx, runtime);
+    return;
+  }
+
+  const status = dynamaxWidgetLine(runtime.state, shortcuts.inspector, runtime.runningWorkflow);
+  ctx.ui.setStatus(DYNAMAX_STATUS_KEY, status);
+}
+
+export function clearDynamaxSurfaces(ctx: Pick<ExtensionContext, "hasUI" | "ui">, runtime: DynamaxRuntime): void {
+  if (!ctx.hasUI) return;
+  ctx.ui.setWidget(DYNAMAX_WIDGET_KEY, undefined);
+  ctx.ui.setStatus(DYNAMAX_STATUS_KEY, undefined);
+  ctx.ui.setStatus(DYNAMAX_WIDGET_KEY, undefined);
+}
+
+function workflowLabel(args: unknown): string {
+  if (!isRecord(args)) return "workflow";
+  const name = args.name;
+  if (typeof name === "string" && name.trim()) return name.trim();
+  const script = args.script;
+  if (typeof script === "string" && script.trim()) return "inline workflow";
+  return "workflow";
+}
+
 function createDynamaxContextMessage(): AgentMessage {
   return {
     role: "custom",
@@ -121,3 +299,7 @@ function createDynamaxContextMessage(): AgentMessage {
     timestamp: Date.now(),
   };
 }
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}