pi-workflow-engine 0.11.0 → 0.12.0

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

@@ -78,6 +78,8 @@ export interface ParallelSettledOptions {
 export interface ParallelSettledError {
   readonly name?: string;
   readonly message: string;
+  readonly code?: string;
+  readonly details?: Readonly<Record<string, string | number | boolean | null>>;
 }
 
 export type ParallelSettledResult<T> =
@@ -229,14 +231,48 @@ async function runParallel<T, Result>(
 function serializeParallelError(error: unknown): ParallelSettledError {
   const message = readStringProperty(error, "message") ?? unknownErrorMessage(error);
   const name = readStringProperty(error, "name");
-  return name && name.length > 0 ? { name, message } : { message };
+  const code = readStringProperty(error, "code");
+  const details = readSerializableDetails(error);
+  return {
+    ...(name && name.length > 0 ? { name } : {}),
+    message,
+    ...(code && code.length > 0 ? { code } : {}),
+    ...(details ? { details } : {}),
+  };
+}
+
+function readStringProperty(value: unknown, property: "message" | "name" | "code"): string | undefined {
+  const candidate = readProperty(value, property);
+  return typeof candidate === "string" ? candidate : undefined;
+}
+
+function readSerializableDetails(
+  value: unknown,
+): Readonly<Record<string, string | number | boolean | null>> | undefined {
+  const candidate = readProperty(value, "details");
+  if (typeof candidate !== "object" || candidate === null) return undefined;
+  try {
+    const details: Record<string, string | number | boolean | null> = {};
+    for (const [key, detail] of Object.entries(candidate)) {
+      if (
+        typeof detail === "string" ||
+        typeof detail === "boolean" ||
+        detail === null ||
+        (typeof detail === "number" && Number.isFinite(detail))
+      ) {
+        details[key] = detail;
+      }
+    }
+    return Object.keys(details).length > 0 ? details : undefined;
+  } catch {
+    return undefined;
+  }
 }
 
-function readStringProperty(value: unknown, property: "message" | "name"): string | undefined {
+function readProperty(value: unknown, property: string): unknown {
   if ((typeof value !== "object" && typeof value !== "function") || value === null) return undefined;
   try {
-    const candidate = Reflect.get(value, property);
-    return typeof candidate === "string" ? candidate : undefined;
+    return Reflect.get(value, property);
   } catch {
     return undefined;
   }
@@ -275,6 +311,21 @@ export async function pipeline<Item, A, B, C>(
   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>>
@@ -302,6 +353,21 @@ export function bindPipeline(options: PipelineOptions): Pipeline {
     stage2: (prev: A, item: Item, index: number) => Promise<B>,
     stage3: (prev: B, item: Item, index: number) => Promise<C>,
   ): Promise<Array<C | null>>;
+  async function boundPipeline<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>>;
+  async function boundPipeline<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>>;
   async function boundPipeline(
     items: readonly unknown[],
     ...stages: Array<(prev: unknown, item: unknown, index: number) => Promise<unknown>>

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

@@ -1,30 +1,21 @@
-import { Type, type Static } from "typebox";
-import { Value } from "typebox/value";
 import type { PerfSink } from "./perf.ts";
 import { runBoundedProcess, type BoundedProcessFailure } from "./process-runner.ts";
-
-export type GitDiffBaselineTarget =
-  | { readonly kind: "working-tree" }
-  | { readonly kind: "index" }
-  | { readonly kind: "range"; readonly ref: string };
-
-export const GitReviewDiffTargetSchema = Type.Object({
-  kind: Type.Literal("git"),
-  args: Type.Array(Type.String()),
-});
-
-export const PullRequestReviewDiffTargetSchema = Type.Object({
-  kind: Type.Literal("pull-request"),
-  number: Type.Integer({ minimum: 1 }),
-});
-
-export const ReviewDiffTargetSchema = Type.Union([GitReviewDiffTargetSchema, PullRequestReviewDiffTargetSchema]);
-
-export type GitReviewDiffTarget = Static<typeof GitReviewDiffTargetSchema>;
-export type PullRequestReviewDiffTarget = Static<typeof PullRequestReviewDiffTargetSchema>;
-
-/** Serializable semantic identity of the diff being reviewed. */
-export type ReviewDiffTarget = Static<typeof ReviewDiffTargetSchema>;
+import { parseAllowedDiffCommand, reviewDiffCommand, type ReviewDiffTarget } from "./review-diff-target.ts";
+
+export {
+  formatReviewDiffTarget,
+  GitReviewDiffTargetSchema,
+  isReviewDiffTarget,
+  parseAllowedDiffCommand,
+  PullRequestReviewDiffTargetSchema,
+  reviewDiffCommand,
+  ReviewDiffTargetSchema,
+  reviewGitDiffBaseline,
+  type GitDiffBaselineTarget,
+  type GitReviewDiffTarget,
+  type PullRequestReviewDiffTarget,
+  type ReviewDiffTarget,
+} from "./review-diff-target.ts";
 
 interface DiffCaptureResultBase {
   readonly stdout: string;
@@ -48,78 +39,6 @@ export interface DiffCaptureOptions {
   readonly killGraceMs?: number;
 }
 
-const SAFE_REF_OR_PATH = /^[A-Za-z0-9_./:@~+=,\-]+$/;
-const SAFE_GH_DIFF_FLAGS = new Set(["--color=never"]);
-const SAFE_GIT_DIFF_FLAGS = new Set(["--binary", "--cached", "--staged", "--no-color", "--color=never", "--no-ext-diff"]);
-
-export function parseAllowedDiffCommand(command: string): ReviewDiffTarget | { error: string } {
-  const tokens = command.trim().split(/\s+/).filter(Boolean);
-  if (tokens.length < 2) return { error: "empty or incomplete diff command" };
-  if (tokens[0] === "git" && tokens[1] === "diff") {
-    const parsed = parseGitDiff(tokens);
-    return "error" in parsed ? parsed : parsed.target;
-  }
-  if (tokens[0] === "gh" && tokens[1] === "pr" && tokens[2] === "diff" && /^\d+$/.test(tokens[3] ?? "")) {
-    const number = Number(tokens[3]);
-    if (!Number.isSafeInteger(number) || number <= 0) return { error: "pull-request number must be a positive safe integer" };
-    const flags = tokens.slice(4);
-    if (flags.includes("--patch")) return { error: "gh pr diff --patch is not supported because reviews require the cumulative pull-request diff" };
-    const unsupported = flags.find((token) => !SAFE_GH_DIFF_FLAGS.has(token));
-    if (unsupported) return { error: `unsupported gh pr diff option: ${unsupported}` };
-    return { kind: "pull-request", number };
-  }
-  return { error: "diff command is not in the git/gh allowlist" };
-}
-
-function parseGitDiff(
-  tokens: readonly string[],
-): { readonly target: GitReviewDiffTarget; readonly baseline: GitDiffBaselineTarget } | { readonly error: string } {
-  const args = tokens.slice(2);
-  const safeArgs = ["diff", "--no-ext-diff"];
-  const operands: string[] = [];
-  let staged = false;
-  let pathMode = false;
-
-  for (const token of args) {
-    if (!SAFE_REF_OR_PATH.test(token)) return { error: `unsupported git diff token: ${token}` };
-    if (token === "--") {
-      pathMode = true;
-      safeArgs.push(token);
-      continue;
-    }
-    if (!pathMode && token.startsWith("-")) {
-      if (!isAllowedGitDiffFlag(token)) return { error: `unsupported git diff option: ${token}` };
-      staged ||= token === "--cached" || token === "--staged";
-      if (token !== "--no-ext-diff") safeArgs.push(token);
-      continue;
-    }
-    if (!pathMode) operands.push(token);
-    safeArgs.push(token);
-  }
-
-  const baseline = classifyGitDiffBaseline(staged, operands);
-  return "error" in baseline ? baseline : { target: { kind: "git", args: safeArgs }, baseline };
-}
-
-function classifyGitDiffBaseline(staged: boolean, operands: readonly string[]): GitDiffBaselineTarget | { readonly error: string } {
-  if (operands.length > 1) {
-    return { error: "ambiguous git diff operands; use A..B or A...B for revisions, or -- before multiple paths" };
-  }
-  if (staged) return { kind: "index" };
-
-  const range = operands.find((operand) => operand.includes(".."));
-  if (range) {
-    const separator = range.includes("...") ? "..." : "..";
-    return { kind: "range", ref: range.slice(range.indexOf(separator) + separator.length) || "HEAD" };
-  }
-
-  return { kind: "working-tree" };
-}
-
-function isAllowedGitDiffFlag(token: string): boolean {
-  return SAFE_GIT_DIFF_FLAGS.has(token) || /^-U\d+$/.test(token) || /^--unified=\d+$/.test(token) || /^--inter-hunk-context=\d+$/.test(token);
-}
-
 export async function captureDiff(command: string, options: DiffCaptureOptions): Promise<DiffCaptureResult> {
   const parsed = parseAllowedDiffCommand(command);
   if ("error" in parsed) {
@@ -157,39 +76,6 @@ export async function captureDiffTarget(target: ReviewDiffTarget, options: DiffC
   return result;
 }
 
-export function reviewDiffCommand(target: ReviewDiffTarget): { readonly file: "git" | "gh"; readonly args: readonly string[] } {
-  return target.kind === "pull-request"
-    ? { file: "gh", args: ["pr", "diff", String(target.number), "--color=never"] }
-    : { file: "git", args: target.args };
-}
-
-/** Canonical display form. Never execute this string directly; use reviewDiffCommand(). */
-export function formatReviewDiffTarget(target: ReviewDiffTarget): string {
-  const command = reviewDiffCommand(target);
-  return [command.file, ...command.args].join(" ");
-}
-
-/** Derive reconstruction semantics from the canonical git command instead of persisting duplicate state. */
-export function reviewGitDiffBaseline(target: GitReviewDiffTarget): GitDiffBaselineTarget {
-  const parsed = parseGitDiff(["git", ...target.args]);
-  if ("error" in parsed) throw new Error(`Invalid persisted git review target: ${parsed.error}`);
-  return parsed.baseline;
-}
-
-/** Validate persisted targets by round-tripping through the single command allowlist parser. */
-export function isReviewDiffTarget(value: unknown): value is ReviewDiffTarget {
-  if (!Value.Check(ReviewDiffTargetSchema, value)) return false;
-  const parsed = parseAllowedDiffCommand(formatReviewDiffTarget(value));
-  return !("error" in parsed) && sameReviewDiffTarget(parsed, value);
-}
-
-function sameReviewDiffTarget(left: ReviewDiffTarget, right: ReviewDiffTarget): boolean {
-  if (left.kind !== right.kind) return false;
-  if (left.kind === "pull-request") return right.kind === "pull-request" && left.number === right.number;
-  if (right.kind !== "git" || left.args.length !== right.args.length) return false;
-  return left.args.every((arg, index) => arg === right.args[index]);
-}
-
 function diffCaptureEnv(env: NodeJS.ProcessEnv | undefined): NodeJS.ProcessEnv {
   return { ...(env ?? process.env), GIT_EXTERNAL_DIFF: "", GIT_DIFF_OPTS: "" };
 }

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

@@ -1,13 +1,14 @@
 import { readdir } from "node:fs/promises";
-import { homedir } from "node:os";
 import { join } 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 { unknownErrorMessage } from "./unknown-error.ts";
 
 export interface DiscoverWorkflowsOptions {
   readonly refresh?: boolean;
@@ -15,6 +16,9 @@ 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(
@@ -46,7 +50,7 @@ async function loadDir(
     } catch (error) {
       // Drop-in loading depends on the runtime resolving TS + the bundled typebox.
       // Failures here are non-fatal: the static registry still works.
-      console.error(`[workflow-engine] skipped ${name}: ${error instanceof Error ? error.message : String(error)}`);
+      console.error(`[workflow-engine] skipped ${name}: ${unknownErrorMessage(error)}`);
     }
   }
   return modules.map(({ path, module }) => loadWorkflow(module, sourceIdentity(path)));
@@ -56,8 +60,8 @@ async function captureDiscoveryFingerprint(root: string) {
   return await captureTreeFingerprint({
     root,
     excludedRelativePaths: FINGERPRINT_EXCLUDED_RELATIVE_PATHS,
-    maxBytes: 32 << 20,
-    maxFiles: 4096,
+    maxBytes: DISCOVERY_FINGERPRINT_MAX_BYTES,
+    maxFiles: DISCOVERY_FINGERPRINT_MAX_FILES,
   });
 }
 
@@ -66,7 +70,7 @@ async function captureDiscoveryFingerprint(root: string) {
  * bundled example is always the verified one even if a same-named file is dropped in.
  */
 export async function discoverWorkflows(repoDir: string, options: DiscoverWorkflowsOptions = {}): Promise<Map<string, LoadedWorkflow>> {
-  const userWorkflowDir = options.userWorkflowDir ?? join(homedir(), ".pi", "agent", "workflows");
+  const userWorkflowDir = options.userWorkflowDir ?? join(getAgentDir(), "workflows");
   const cacheKey = `${repoDir}\0${userWorkflowDir}`;
   const cached = discoveryCache.get(cacheKey);
   if (cached && !options.refresh) {

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

@@ -1,7 +1,17 @@
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { KeyId } from "@earendil-works/pi-tui";
+import { CustomEditor, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { EditorComponent, KeyId } from "@earendil-works/pi-tui";
+import { completeCurrentArgument } from "./command-completions.ts";
 import { resolveDynamaxShortcuts, type DynamaxShortcuts } from "./dynamax-shortcuts.ts";
+import { sessionKey } from "./session-identity.ts";
+import { unknownErrorMessage } from "./unknown-error.ts";
+import {
+  decorateDynamaxEditor,
+  resolveDynamaxEffect,
+  type DynamaxAnimationScheduler,
+  type DynamaxEditorDecoration,
+  type DynamaxEffect,
+} from "./ui/dynamax-editor-decoration.ts";
 
 export interface DynamaxState {
   sticky: boolean;
@@ -15,13 +25,34 @@ export interface DynamaxRuntime {
 }
 
 export type DynamaxRuntimeStore = Map<string, DynamaxRuntime>;
+
 export interface DynamaxRegistrationOptions {
   openInspector?: (ctx: ExtensionContext) => Promise<void> | void;
+  effect?: DynamaxEffect;
+  animationScheduler?: DynamaxAnimationScheduler;
 }
 
 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";
+
+type EditorFactory = NonNullable<ReturnType<ExtensionContext["ui"]["getEditorComponent"]>>;
+
+interface DynamaxEditorInstallation {
+  factory: EditorFactory;
+  previousFactory: EditorFactory | undefined;
+  decorations: Set<DynamaxEditorDecoration>;
+}
+
+function disposeDynamaxDecorations(decorations: Set<DynamaxEditorDecoration>): void {
+  for (const decoration of decorations) decoration.dispose();
+  decorations.clear();
+}
+
+const DYNAMAX_ACTION_COMPLETIONS = [
+  { value: "on", description: "Keep Dynamax enabled for this session" },
+  { value: "off", description: "Disable sticky and pending Dynamax modes" },
+  { value: "status", description: "Show the current Dynamax state" },
+] as const;
 
 export const ADAPTIVE_WORKFLOW_GUIDANCE = `
 Adaptive multi-pass workflows are optional. Use a simple single-pass fan-out when it is sufficient. When the first pass may expose gaps, conflicts, weak claims, or missing evidence:
@@ -40,7 +71,7 @@ The user has opted into dynamax multi-agent orchestration. The workflow tool is
 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.
+- 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.
 
@@ -57,12 +88,8 @@ 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 key = sessionKey(ctx);
   const existing = store.get(key);
   if (existing) return existing;
   const runtime = createDynamaxRuntime();
@@ -78,12 +105,8 @@ 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;
-    state.turnActive = false;
-  }
+export function enableDynamaxSticky(state: DynamaxState): void {
+  state.sticky = true;
 }
 
 export function clearDynamax(state: DynamaxState): void {
@@ -92,12 +115,6 @@ export function clearDynamax(state: DynamaxState): void {
   state.turnActive = 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 || state.turnActive;
 }
@@ -139,23 +156,84 @@ export function registerDynamax(
   options: DynamaxRegistrationOptions = {},
 ): void {
   const runtimes: DynamaxRuntimeStore = new Map();
+  const effect = options.effect ?? resolveDynamaxEffect();
+  let editorInstallation: DynamaxEditorInstallation | undefined;
   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);
+  const installEditor = (ctx: ExtensionContext): void => {
+    if (ctx.mode !== "tui" || effect === "off") return;
+    const previousFactory = ctx.ui.getEditorComponent();
+    if (editorInstallation && editorInstallation.factory === previousFactory) return;
+
+    const decorations = new Set<DynamaxEditorDecoration>();
+    const installation: DynamaxEditorInstallation = {
+      previousFactory,
+      decorations,
+      factory: (tui, theme, keybindings) => {
+        const decorate = (editor: EditorComponent): EditorComponent => {
+          const decoration = decorateDynamaxEditor(editor, () => tui.requestRender(), {
+            effect,
+            scheduler: options.animationScheduler,
+            isActive: () => editorInstallation === installation && ctx.ui.getEditorComponent() === installation.factory,
+          });
+          decorations.add(decoration);
+          return decoration.editor;
+        };
+        if (!previousFactory) return decorate(new CustomEditor(tui, theme, keybindings));
+
+        let editor: EditorComponent;
+        try {
+          editor = previousFactory(tui, theme, keybindings);
+        } catch (error) {
+          ctx.ui.notify(
+            `Dynamax could not compose the existing custom editor (${unknownErrorMessage(error)}); using pi's stock-compatible CustomEditor so highlighting stays enabled`,
+            "warning",
+          );
+          installation.previousFactory = undefined;
+          return decorate(new CustomEditor(tui, theme, keybindings));
+        }
+
+        try {
+          return decorate(editor);
+        } catch (error) {
+          ctx.ui.notify(
+            `Dynamax could not decorate the existing custom editor (${unknownErrorMessage(error)}); using pi's stock-compatible CustomEditor so highlighting stays enabled`,
+            "warning",
+          );
+          return decorate(new CustomEditor(tui, theme, keybindings));
+        }
+      },
+    };
+
+    try {
+      ctx.ui.setEditorComponent(installation.factory);
+    } catch (error) {
+      disposeDynamaxDecorations(decorations);
+      ctx.ui.notify(`Dynamax highlighting could not be installed: ${unknownErrorMessage(error)}`, "error");
+      throw error;
+    }
+    editorInstallation = installation;
+  };
+  const uninstallEditor = (ctx: ExtensionContext): void => {
+    const installation = editorInstallation;
+    if (!installation) return;
+    editorInstallation = undefined;
+    disposeDynamaxDecorations(installation.decorations);
+    if (ctx.mode === "tui" && ctx.ui.getEditorComponent() === installation.factory) {
+      ctx.ui.setEditorComponent(installation.previousFactory);
     }
   };
 
   pi.on("session_start", (_event, ctx) => {
+    installEditor(ctx);
     updateDynamaxSurfaces(ctx, getDynamaxRuntime(runtimes, ctx), shortcuts);
   });
 
   pi.on("session_shutdown", (_event, ctx) => {
+    uninstallEditor(ctx);
     clearDynamaxSurfaces(ctx);
   });
 
@@ -177,26 +255,6 @@ export function registerDynamax(
     return { systemPrompt };
   });
 
-  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;
@@ -205,23 +263,17 @@ export function registerDynamax(
   });
 
   pi.on("tool_execution_start", (event, ctx) => {
+    if (event.toolName !== "workflow") return undefined;
     const runtime = getDynamaxRuntime(runtimes, ctx);
-    if (event.toolName === "workflow") {
-      runtime.runningWorkflow = workflowLabel(event.args);
-    }
+    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) => {
+    if (event.toolName !== "workflow") return undefined;
     const runtime = getDynamaxRuntime(runtimes, ctx);
-    if (event.toolName === "workflow") {
-      runtime.runningWorkflow = undefined;
-    }
+    runtime.runningWorkflow = undefined;
     updateDynamaxSurfaces(ctx, runtime, shortcuts);
     return undefined;
   });
@@ -244,6 +296,7 @@ export function registerDynamax(
 
   pi.registerCommand("workflow:dynamax", {
     description: "Toggle Dynamax workflow orchestration: /workflow:dynamax [on|off|status]",
+    getArgumentCompletions: (argumentPrefix) => completeCurrentArgument(argumentPrefix, DYNAMAX_ACTION_COMPLETIONS),
     handler: async (args, ctx) => {
       const runtime = getDynamaxRuntime(runtimes, ctx);
       const action = args.trim().toLowerCase();
@@ -252,7 +305,7 @@ export function registerDynamax(
         return;
       }
       if (action === "on") {
-        setDynamaxSticky(runtime.state, true);
+        enableDynamaxSticky(runtime.state);
         updateDynamaxSurfaces(ctx, runtime, shortcuts);
         ctx.ui.notify("Dynamax workflow orchestration is on for this session", "info");
         return;
@@ -274,8 +327,6 @@ export function registerDynamax(
 
 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);
     return;
@@ -287,9 +338,7 @@ export function updateDynamaxSurfaces(ctx: Pick<ExtensionContext, "hasUI" | "ui"
 
 export function clearDynamaxSurfaces(ctx: Pick<ExtensionContext, "hasUI" | "ui">): 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 {