pi-workflow-engine 0.13.0 → 1.1.0

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

@@ -1,5 +1,6 @@
 import { performance } from "node:perf_hooks";
 import { abortReason, isFatalWorkflowError, throwIfAborted } from "./cancellation.ts";
+import { isFiniteNumber } from "./guards.ts";
 import { unknownErrorMessage } from "./unknown-error.ts";
 
 /**
@@ -59,10 +60,6 @@ export class Semaphore {
         cleanup();
         reject(abortReason(signal));
       };
-      if (signal?.aborted) {
-        reject(abortReason(signal));
-        return;
-      }
       this.waiters.push(waiter);
       signal?.addEventListener("abort", onAbort, { once: true });
     });
@@ -138,13 +135,6 @@ export async function parallel<T>(
 }
 
 export function bindParallel(options: ParallelOptions): WorkflowParallel {
-  const executionOptions: ParallelOptions = {
-    signal: options.signal,
-    abortController: options.abortController,
-    limit: options.limit,
-    drainTimeoutMs: options.drainTimeoutMs,
-  };
-
   function boundParallel<T>(thunks: Array<() => Promise<T>>): Promise<Array<T | null>>;
   function boundParallel<T>(
     thunks: Array<() => Promise<T>>,
@@ -155,9 +145,9 @@ export function bindParallel(options: ParallelOptions): WorkflowParallel {
     workflowOptions?: ParallelSettledOptions,
   ): Promise<Array<T | null> | Array<ParallelSettledResult<T>>> {
     if (workflowOptions?.settled) {
-      return await parallel(thunks, { ...executionOptions, settled: true });
+      return await parallel(thunks, { ...options, settled: true });
     }
-    return await parallel(thunks, executionOptions);
+    return await parallel(thunks, options);
   }
 
   return boundParallel;
@@ -224,7 +214,6 @@ async function runParallel<T, Result>(
     };
 
     options.signal?.addEventListener("abort", onAbort, { once: true });
-    if (options.signal?.aborted) onAbort();
     for (let worker = 0; worker < limit; worker++) {
       void runWorker().then(completeWorker, (error) => {
         recordFatalFailure(error);
@@ -264,7 +253,7 @@ function readSerializableDetails(
         typeof detail === "string" ||
         typeof detail === "boolean" ||
         detail === null ||
-        (typeof detail === "number" && Number.isFinite(detail))
+        isFiniteNumber(detail)
       ) {
         details[key] = detail;
       }
@@ -285,12 +274,12 @@ function readProperty(value: unknown, property: string): unknown {
 }
 
 function normalizeLimit(limit: number | undefined, itemCount: number): number {
-  if (limit === undefined || !Number.isFinite(limit)) return Math.max(1, itemCount);
+  if (!isFiniteNumber(limit)) return Math.max(1, itemCount);
   return Math.max(1, Math.min(itemCount, Math.trunc(limit)));
 }
 
 function normalizeDrainTimeout(timeoutMs: number | undefined): number {
-  if (timeoutMs === undefined || !Number.isFinite(timeoutMs)) return DEFAULT_FATAL_DRAIN_TIMEOUT_MS;
+  if (!isFiniteNumber(timeoutMs)) return DEFAULT_FATAL_DRAIN_TIMEOUT_MS;
   return Math.max(0, Math.trunc(timeoutMs));
 }
 
@@ -302,48 +291,7 @@ function normalizeDrainTimeout(timeoutMs: number | undefined): number {
  *
  * Each stage receives (previousResult, originalItem, index).
  */
-export async function pipeline<Item, A>(
-  items: readonly Item[],
-  stage1: (prev: Item, item: Item, index: number) => Promise<A>,
-): Promise<Array<A | null>>;
-export async function pipeline<Item, A, B>(
-  items: readonly Item[],
-  stage1: (prev: Item, item: Item, index: number) => Promise<A>,
-  stage2: (prev: A, item: Item, index: number) => Promise<B>,
-): Promise<Array<B | null>>;
-export async function pipeline<Item, A, B, C>(
-  items: readonly Item[],
-  stage1: (prev: Item, item: Item, index: number) => Promise<A>,
-  stage2: (prev: A, item: Item, index: number) => Promise<B>,
-  stage3: (prev: B, item: Item, index: number) => Promise<C>,
-): Promise<Array<C | null>>;
-export async function pipeline<Item, A, B, C, D>(
-  items: readonly Item[],
-  stage1: (prev: Item, item: Item, index: number) => Promise<A>,
-  stage2: (prev: A, item: Item, index: number) => Promise<B>,
-  stage3: (prev: B, item: Item, index: number) => Promise<C>,
-  stage4: (prev: C, item: Item, index: number) => Promise<D>,
-): Promise<Array<D | null>>;
-export async function pipeline<Item, A, B, C, D, E>(
-  items: readonly Item[],
-  stage1: (prev: Item, item: Item, index: number) => Promise<A>,
-  stage2: (prev: A, item: Item, index: number) => Promise<B>,
-  stage3: (prev: B, item: Item, index: number) => Promise<C>,
-  stage4: (prev: C, item: Item, index: number) => Promise<D>,
-  stage5: (prev: D, item: Item, index: number) => Promise<E>,
-): Promise<Array<E | null>>;
-export async function pipeline(
-  items: readonly unknown[],
-  ...stages: Array<(prev: unknown, item: unknown, index: number) => Promise<unknown>>
-): Promise<Array<unknown | null>>;
-export async function pipeline(
-  items: readonly unknown[],
-  ...stages: Array<(prev: unknown, item: unknown, index: number) => Promise<unknown>>
-): Promise<Array<unknown | null>> {
-  return pipelineWithOptions(items, stages);
-}
-
-export function bindPipeline(options: PipelineOptions): Pipeline {
+export function bindPipeline(options: PipelineOptions) {
   async function boundPipeline<Item, A>(
     items: readonly Item[],
     stage1: (prev: Item, item: Item, index: number) => Promise<A>,
@@ -374,33 +322,30 @@ export function bindPipeline(options: PipelineOptions): Pipeline {
     stage4: (prev: C, item: Item, index: number) => Promise<D>,
     stage5: (prev: D, item: Item, index: number) => Promise<E>,
   ): Promise<Array<E | null>>;
+  async function boundPipeline(
+    items: readonly unknown[],
+    ...stages: Array<(prev: unknown, item: unknown, index: number) => Promise<unknown>>
+  ): Promise<Array<unknown | null>>;
   async function boundPipeline(
     items: readonly unknown[],
     ...stages: Array<(prev: unknown, item: unknown, index: number) => Promise<unknown>>
   ): Promise<Array<unknown | null>> {
-    return pipelineWithOptions(items, stages, options);
+    return await parallel(
+      items.map((item, index) => async () => {
+        let acc: unknown = item;
+        for (const stage of stages) {
+          throwIfAborted(options.signal);
+          acc = await stage(acc, item, index);
+        }
+        return acc;
+      }),
+      options,
+    );
   }
   return boundPipeline;
 }
 
-export async function pipelineWithOptions(
-  items: readonly unknown[],
-  stages: Array<(prev: unknown, item: unknown, index: number) => Promise<unknown>>,
-  options: PipelineOptions = {},
-): Promise<Array<unknown | null>> {
-  throwIfAborted(options.signal);
-  return await parallel(
-    items.map((item, index) => async () => {
-      throwIfAborted(options.signal);
-      let acc: unknown = item;
-      for (const stage of stages) {
-        throwIfAborted(options.signal);
-        acc = await stage(acc, item, index);
-      }
-      return acc;
-    }),
-    options,
-  );
-}
+export type Pipeline = ReturnType<typeof bindPipeline>;
 
-export type Pipeline = typeof pipeline;
+/** `pipeline` without a run's abort signal (tests, benchmarks). */
+export const pipeline: Pipeline = bindPipeline({});

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

@@ -1,13 +1,12 @@
 import { readdir } from "node:fs/promises";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import type { LoadedWorkflow, WorkflowSourceIdentity } from "./types.ts";
 import type { PerfSink } from "./perf.ts";
 import { loadWorkflow, parseWorkflowModule } from "./workflow-module.ts";
 import { BUILTIN_SOURCE_ROOT, BUILTIN_WORKFLOW_DEFINITIONS, BUILTIN_WORKFLOW_FILES } from "./workflows.ts";
-import { captureTreeFingerprint } from "./tree-fingerprint.ts";
-import { FINGERPRINT_EXCLUDED_RELATIVE_PATHS } from "./resume-context.ts";
+import { captureSourceTreeFingerprint, type FingerprintCapture } from "./tree-fingerprint.ts";
 import { unknownErrorMessage } from "./unknown-error.ts";
 
 export interface DiscoverWorkflowsOptions {
@@ -16,16 +15,13 @@ export interface DiscoverWorkflowsOptions {
   readonly userWorkflowDir?: string;
 }
 
-const DISCOVERY_FINGERPRINT_MAX_BYTES = 32 << 20;
-const DISCOVERY_FINGERPRINT_MAX_FILES = 4096;
-
 const discoveryCache = new Map<string, Map<string, LoadedWorkflow>>();
 /** Best-effort dynamic load of every `*.ts` workflow in a directory. */
 async function loadDir(
   dir: string,
   sourceIdentity: (path: string) => WorkflowSourceIdentity,
   excludeFiles: ReadonlySet<string> = new Set(),
-  provenanceRoot?: string,
+  captureProvenance?: () => Promise<FingerprintCapture>,
 ): Promise<LoadedWorkflow[]> {
   let entries: string[];
   try {
@@ -33,12 +29,15 @@ async function loadDir(
   } catch {
     return [];
   }
+  const candidates = entries.filter(
+    (name) => !excludeFiles.has(name) && name.endsWith(".ts") && !name.startsWith("_") && !name.startsWith("."),
+  );
+  // The shipped workflows/ dir holds only excluded built-ins; skip the tree hash when nothing will be imported.
+  if (candidates.length === 0) return [];
 
-  const before = provenanceRoot ? await captureDiscoveryFingerprint(provenanceRoot) : undefined;
+  const before = await captureProvenance?.();
   const modules: Array<{ readonly path: string; readonly module: Parameters<typeof loadWorkflow>[0] }> = [];
-  for (const name of entries) {
-    if (excludeFiles.has(name)) continue;
-    if (!name.endsWith(".ts") || name.startsWith("_") || name.startsWith(".")) continue;
+  for (const name of candidates) {
     try {
       const path = join(dir, name);
       const importUrl = pathToFileURL(path);
@@ -56,15 +55,6 @@ async function loadDir(
   return modules.map(({ path, module }) => loadWorkflow(module, sourceIdentity(path)));
 }
 
-async function captureDiscoveryFingerprint(root: string) {
-  return await captureTreeFingerprint({
-    root,
-    excludedRelativePaths: FINGERPRINT_EXCLUDED_RELATIVE_PATHS,
-    maxBytes: DISCOVERY_FINGERPRINT_MAX_BYTES,
-    maxFiles: DISCOVERY_FINGERPRINT_MAX_FILES,
-  });
-}
-
 /**
  * All available workflows by name. Static registry wins on name collisions, so the
  * bundled example is always the verified one even if a same-named file is dropped in.
@@ -80,14 +70,14 @@ export async function discoverWorkflows(repoDir: string, options: DiscoverWorkfl
 
   const byName = await timed(options.perf, "discovery.total_ms", async () => {
     const next = new Map<string, LoadedWorkflow>();
-    const builtinSource = await captureDiscoveryFingerprint(BUILTIN_SOURCE_ROOT);
+    const builtinSource = await captureSourceTreeFingerprint(BUILTIN_SOURCE_ROOT);
     for (const definition of BUILTIN_WORKFLOW_DEFINITIONS) {
       const source: WorkflowSourceIdentity =
         builtinSource.kind === "verified"
           ? {
               kind: "file",
               path: definition.path,
-              root: definition.root,
+              root: BUILTIN_SOURCE_ROOT,
               fingerprint: builtinSource.fingerprint,
             }
           : {
@@ -98,6 +88,9 @@ export async function discoverWorkflows(repoDir: string, options: DiscoverWorkfl
     }
 
     const repoWorkflowDir = join(repoDir, "workflows");
+    // The shipped extension dir is both the built-in root and the drop-in root; hash that tree once.
+    const repoProvenance =
+      resolve(repoDir) === resolve(BUILTIN_SOURCE_ROOT) ? async () => builtinSource : () => captureSourceTreeFingerprint(repoDir);
     const [repoDynamic, userDynamic] = await Promise.all([
       timed(options.perf, "discovery.repo_dir_ms", () =>
         loadDir(
@@ -107,7 +100,7 @@ export async function discoverWorkflows(repoDir: string, options: DiscoverWorkfl
             reason: "dynamic workflow module graphs are not loaded from an immutable source snapshot",
           }),
           BUILTIN_WORKFLOW_FILES,
-          repoDir,
+          repoProvenance,
         ),
       ),
       timed(options.perf, "discovery.user_dir_ms", () =>

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

@@ -2,6 +2,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { Key, type KeyId } from "@earendil-works/pi-tui";
+import { isRecord } from "./guards.ts";
 
 export const DEFAULT_DYNAMAX_INSPECTOR_SHORTCUT = "ctrl+shift+m" satisfies KeyId;
 export const DEFAULT_REVIEW_RESULTS_SHORTCUT = "ctrl+shift+r" satisfies KeyId;
@@ -112,10 +113,6 @@ function defaultDynamaxShortcuts(): DynamaxShortcuts {
   return { inspector: DEFAULT_DYNAMAX_INSPECTOR_SHORTCUT, results: DEFAULT_REVIEW_RESULTS_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 workflow shortcuts.`);
 }

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

@@ -1,10 +1,11 @@
-import type { AgentMessage } from "@earendil-works/pi-agent-core";
-import { CustomEditor, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { EditorComponent, KeyId } from "@earendil-works/pi-tui";
+import { CustomEditor, type ExtensionAPI, type ExtensionContext, type Theme } from "@earendil-works/pi-coding-agent";
+import type { EditorComponent } from "@earendil-works/pi-tui";
 import { completeCurrentArgument } from "./command-completions.ts";
-import { resolveDynamaxShortcuts, type DynamaxShortcuts } from "./dynamax-shortcuts.ts";
+import type { DynamaxShortcuts } from "./dynamax-shortcuts.ts";
 import { sessionKey } from "./session-identity.ts";
 import { unknownErrorMessage } from "./unknown-error.ts";
+import { dot, GLYPH } from "./ui/kit.ts";
+import { setWorkflowInspectorShortcut } from "./ui/workflow-widget.ts";
 import {
   decorateDynamaxEditor,
   resolveDynamaxEffect,
@@ -21,17 +22,21 @@ export interface DynamaxState {
 
 export interface DynamaxRuntime {
   state: DynamaxState;
-  runningWorkflow?: string;
 }
 
 export type DynamaxRuntimeStore = Map<string, DynamaxRuntime>;
 
 export interface DynamaxRegistrationOptions {
-  openInspector?: (ctx: ExtensionContext) => Promise<void> | void;
+  openInspector: (ctx: ExtensionContext) => Promise<void> | void;
   effect?: DynamaxEffect;
   animationScheduler?: DynamaxAnimationScheduler;
 }
 
+export interface DynamaxHandle {
+  /** Opt the next agent run in. The `input` hook ignores prompts this extension sends (pi tags them `source: "extension"`). */
+  markOneShot(ctx: ExtensionContext): void;
+}
+
 export const DYNAMAX_TOKEN_PATTERN = /(^|[^A-Za-z0-9_])dynamax([^A-Za-z0-9_]|$)/i;
 export const DYNAMAX_STATUS_KEY = "dynamax";
 
@@ -63,22 +68,13 @@ Adaptive multi-pass workflows are optional. Use a simple single-pass fan-out whe
 - synthesize the first-pass and follow-up results together.
 Do not generate a second pass when the first pass is sufficient, and do not invent iteration, quorum, graph, reduction, or retry primitives for this pattern.`;
 
-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 profile to "small", "medium", or "big" on each agent() call so routing remains explicit; use model/thinkingLevel only for an intentional override.
-- Subagents receive no skills by default. Add \`skills: ["skill-name"]\` per agent only when that stage should load that skill; grant the smallest useful set.
-- Provide exactly one of workflow.name or workflow.script.
+/** System prompt section pi wraps as `<dynamax>`; adding or dropping it appends a section patch instead of rewriting the prompt. */
+export const DYNAMAX_SECTION = "dynamax";
 
-${ADAPTIVE_WORKFLOW_GUIDANCE}
-`;
-
-const DYNAMAX_CONTEXT_CUSTOM_TYPE = "workflow-dynamax-reminder";
+/** Only the opt-in itself: the authoring rules already reach the model as the workflow tool's guidelines. */
+export const DYNAMAX_REMINDER =
+  "The user opted into dynamax multi-agent orchestration for this request, so the workflow tool is permitted. " +
+  "Run a registered workflow by name, or author an inline workflow script when none fits, following the workflow tool's guidelines.";
 
 export function createDynamaxState(): DynamaxState {
   return { sticky: false, oneShotPending: false, turnActive: false };
@@ -126,43 +122,39 @@ export function describeDynamaxState(state: DynamaxState): string {
   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}`;
+/**
+ * Footer status: `◆ dynamax` while sticky, `◆ dynamax · next prompt` while a one-shot waits for its
+ * prompt, `◆ dynamax · this turn` while that turn runs. A running workflow names itself in its own
+ * status (`◆ repo-scan · Scan 2/3 · 4s`), so this one only states the mode.
+ */
+export function dynamaxStatusText(state: DynamaxState, theme: Theme): string {
+  const mode = state.sticky ? undefined : state.oneShotPending ? "next prompt" : state.turnActive ? "this turn" : undefined;
+  const label = `${theme.fg("accent", GLYPH.workflow)} ${theme.fg("accent", "dynamax")}`;
+  return mode ? `${label}${dot(theme)}${theme.fg("muted", mode)}` : label;
 }
 
-export function appendDynamaxSystemReminder(systemPrompt: string, state: DynamaxState): string {
-  if (!state.sticky && !state.oneShotPending) return systemPrompt;
+/**
+ * Add the opt-in section for this run and consume a pending one-shot. pi rebuilds `sections` for every
+ * run, so an inactive run simply leaves it out and pi records the removal as a patch.
+ */
+export function applyDynamaxPromptSection(sections: Record<string, string>, state: DynamaxState): boolean {
+  if (!state.sticky && !state.oneShotPending) return false;
   state.oneShotPending = false;
   state.turnActive = true;
-  return `${systemPrompt}\n\n${DYNAMAX_REMINDER.trim()}`;
-}
-
-export function appendDynamaxContextReminder(messages: AgentMessage[], state: DynamaxState): AgentMessage[] {
-  if (!state.sticky) return messages;
-  return [...messages, createDynamaxContextMessage()];
+  sections[DYNAMAX_SECTION] = DYNAMAX_REMINDER;
+  return true;
 }
 
-export function registerDynamax(
-  pi: ExtensionAPI,
-  shortcuts: DynamaxShortcuts = resolveDynamaxShortcuts(),
-  options: DynamaxRegistrationOptions = {},
-): void {
+export function registerDynamax(pi: ExtensionAPI, shortcuts: DynamaxShortcuts, options: DynamaxRegistrationOptions): DynamaxHandle {
   const runtimes: DynamaxRuntimeStore = new Map();
   const effect = options.effect ?? resolveDynamaxEffect();
+  setWorkflowInspectorShortcut(shortcuts.inspector);
   let editorInstallation: DynamaxEditorInstallation | undefined;
-  const openInspector =
-    options.openInspector ??
-    ((ctx: ExtensionContext): void => {
-      ctx.ui.notify("No workflow inspector is available yet", "warning");
-    });
+  const markOneShot = (ctx: ExtensionContext): void => {
+    const runtime = getDynamaxRuntime(runtimes, ctx);
+    markDynamaxOneShot(runtime.state);
+    updateDynamaxSurfaces(ctx, runtime);
+  };
   const installEditor = (ctx: ExtensionContext): void => {
     if (ctx.mode !== "tui" || effect === "off") return;
     const previousFactory = ctx.ui.getEditorComponent();
@@ -229,7 +221,7 @@ export function registerDynamax(
 
   pi.on("session_start", (_event, ctx) => {
     installEditor(ctx);
-    updateDynamaxSurfaces(ctx, getDynamaxRuntime(runtimes, ctx), shortcuts);
+    updateDynamaxSurfaces(ctx, getDynamaxRuntime(runtimes, ctx));
   });
 
   pi.on("session_shutdown", (_event, ctx) => {
@@ -238,58 +230,31 @@ export function registerDynamax(
   });
 
   pi.on("input", (event, ctx) => {
-    if (event.source === "extension") return { action: "continue" };
-    const runtime = getDynamaxRuntime(runtimes, ctx);
-    if (hasDynamaxToken(event.text)) {
-      markDynamaxOneShot(runtime.state);
-      updateDynamaxSurfaces(ctx, runtime, shortcuts);
-    }
+    if (event.source !== "extension" && hasDynamaxToken(event.text)) markOneShot(ctx);
     return { action: "continue" };
   });
 
   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 };
+    const options = event.systemPromptOptions;
+    if (!applyDynamaxPromptSection(options.sections, runtime.state)) return undefined;
+    updateDynamaxSurfaces(ctx, runtime);
+    // An earlier extension forced the whole prompt, and pi renders no sections then; append to its text instead.
+    if (options.forceSystemPrompt === undefined) return undefined;
+    return { systemPrompt: `${options.forceSystemPrompt}\n\n<${DYNAMAX_SECTION}>\n${DYNAMAX_REMINDER}\n</${DYNAMAX_SECTION}>` };
   });
 
   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) => {
-    if (event.toolName !== "workflow") return undefined;
-    const runtime = getDynamaxRuntime(runtimes, ctx);
-    runtime.runningWorkflow = workflowLabel(event.args);
-    updateDynamaxSurfaces(ctx, runtime, shortcuts);
-    return undefined;
-  });
-
-  pi.on("tool_execution_end", (event, ctx) => {
-    if (event.toolName !== "workflow") return undefined;
-    const runtime = getDynamaxRuntime(runtimes, ctx);
-    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 };
+    updateDynamaxSurfaces(ctx, runtime);
   });
 
   if (shortcuts.inspector) {
     pi.registerShortcut(shortcuts.inspector, {
       description: "Open workflow inspector",
       handler: async (ctx) => {
-        await openInspector(ctx);
+        await options.openInspector(ctx);
       },
     });
   }
@@ -306,13 +271,13 @@ export function registerDynamax(
       }
       if (action === "on") {
         enableDynamaxSticky(runtime.state);
-        updateDynamaxSurfaces(ctx, runtime, shortcuts);
+        updateDynamaxSurfaces(ctx, runtime);
         ctx.ui.notify("Dynamax workflow orchestration is on for this session", "info");
         return;
       }
       if (action === "off") {
         clearDynamax(runtime.state);
-        updateDynamaxSurfaces(ctx, runtime, shortcuts);
+        updateDynamaxSurfaces(ctx, runtime);
         ctx.ui.notify("Dynamax workflow orchestration is off", "info");
         return;
       }
@@ -323,44 +288,20 @@ export function registerDynamax(
       ctx.ui.notify("Usage: /workflow:dynamax [on|off|status]", "warning");
     },
   });
+
+  return { markOneShot };
 }
 
-export function updateDynamaxSurfaces(ctx: Pick<ExtensionContext, "hasUI" | "ui">, runtime: DynamaxRuntime, shortcuts: DynamaxShortcuts): void {
+export function updateDynamaxSurfaces(ctx: Pick<ExtensionContext, "hasUI" | "ui">, runtime: DynamaxRuntime): void {
   if (!ctx.hasUI) return;
-  if (!isDynamaxActive(runtime.state) && !runtime.runningWorkflow) {
+  if (!isDynamaxActive(runtime.state)) {
     clearDynamaxSurfaces(ctx);
     return;
   }
-
-  const status = dynamaxWidgetLine(runtime.state, shortcuts.inspector, runtime.runningWorkflow);
-  ctx.ui.setStatus(DYNAMAX_STATUS_KEY, status);
+  ctx.ui.setStatus(DYNAMAX_STATUS_KEY, dynamaxStatusText(runtime.state, ctx.ui.theme));
 }
 
 export function clearDynamaxSurfaces(ctx: Pick<ExtensionContext, "hasUI" | "ui">): void {
   if (!ctx.hasUI) return;
   ctx.ui.setStatus(DYNAMAX_STATUS_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",
-    customType: DYNAMAX_CONTEXT_CUSTOM_TYPE,
-    content: DYNAMAX_REMINDER.trim(),
-    display: false,
-    details: { dynamax: true, sticky: true },
-    timestamp: Date.now(),
-  };
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null;
-}