pi-workflow-engine 0.6.1 → 0.7.0

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

@@ -1,9 +1,9 @@
 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 { WorkflowProgressSnapshot } from "./src/progress.ts";
-import type { WorkflowModule, WorkflowRunOptions } from "./src/types.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";
@@ -64,6 +64,20 @@ 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 {
@@ -73,19 +87,53 @@ export interface LastWorkflowInspection {
   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 async function openWorkflowInspector(ctx: ExtensionCommandContext, inspection: LastWorkflowInspection): Promise<void> {
+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(() => inspection.snapshot, tui, theme, () => done(undefined)),
+    (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;
@@ -249,10 +297,22 @@ export 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);
@@ -282,7 +342,7 @@ export 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;
@@ -291,23 +351,14 @@ export default function workflowEngine(pi: ExtensionAPI): void {
   });
 
   pi.registerCommand("workflow:inspector", {
-    description: "Open the last completed 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;
       }
-      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);
+      await openAvailableWorkflowInspector(ctx);
     },
   });
 
@@ -354,6 +405,7 @@ export default function workflowEngine(pi: ExtensionAPI): void {
       "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({
@@ -386,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,
@@ -421,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 };
   });
 
+  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 opt-in: /workflow:dynamax on|off|status",
+    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: /workflow: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;
+}

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

@@ -5,12 +5,35 @@ import { runAgent, type RunContext } from "./agent-runner.ts";
 import { ProgressTracker } from "./progress.ts";
 import { createPerfRecorder, type PerfSnapshot } from "./perf.ts";
 import { defaultConcurrency, resolveWorkflowRunOptions } from "./options.ts";
-import type { AgentOptions, WorkflowApi, WorkflowModule, WorkflowRunOptions } from "./types.ts";
+import type { AgentOptions, WorkflowApi, WorkflowModule, WorkflowProgressEvent, WorkflowRef, WorkflowRunOptions } from "./types.ts";
 import { WorkflowInspector } from "./ui/workflow-inspector.ts";
 
 /** Default global cap on concurrent agents per run. */
 const DEFAULT_CONCURRENCY = defaultConcurrency();
 
+/** The workflow-facing slice of the progress tracker (satisfied by `ProgressTracker`). */
+export interface WorkflowProgress {
+  phase(title: string): void;
+  log(message: string): void;
+  event(event: WorkflowProgressEvent): void;
+}
+
+/** Per-context knobs threaded through `runWorkflowWithContext` (and re-derived for each sub-workflow). */
+export interface WorkflowContextOptions {
+  /** Controller whose `.signal` equals `rc.signal`; aborts in-flight `parallel` siblings on failure. */
+  abortController: AbortController;
+  /** Eager-submission cap for `parallel`. */
+  submissionLimit: number;
+  /** Resolve a sub-workflow reference for `api.workflow()`. Omit to disable composition. */
+  resolveWorkflow?: (ref: WorkflowRef) => Promise<WorkflowModule>;
+  /** Nesting depth. Sub-workflows run at depth >= 1, where `api.workflow()` rejects. */
+  depth?: number;
+  /** Prefix applied to phase titles so sub-workflow phases nest as "<name> ▸ <title>". */
+  progressPrefix?: string;
+  /** Namespace applied to child structured progress keys/lanes/logs. */
+  progressNamespace?: string;
+}
+
 /**
  * Run a workflow module: build the per-run primitives (binding agent/parallel/pipeline
  * to a shared semaphore + progress tracker), invoke the workflow, return its result.
@@ -23,6 +46,8 @@ export async function runWorkflow(
 ): Promise<unknown> {
   const resolvedOptions = resolveWorkflowRunOptions(options);
   const progress = new ProgressTracker(ctx, mod.meta.name);
+  const progressSource = { snapshot: () => progress.snapshot() };
+  resolvedOptions.onProgressSource?.(progressSource);
   if (resolvedOptions.inspect && ctx.hasUI) {
     void ctx.ui
       .custom<void>(
@@ -46,27 +71,17 @@ export async function runWorkflow(
     perf,
   };
 
-  const agent = ((prompt: string, opts?: AgentOptions) => runAgent(rc, prompt, opts)) as WorkflowApi["agent"];
-
-  const api: WorkflowApi = {
-    agent,
-    parallel: (thunks) =>
-      parallel(thunks, {
-        signal: runAbortController.signal,
+  try {
+    // perf.total_ms wraps the whole tree: sub-workflows run inside this span via api.workflow().
+    return await perf.time("workflow.total_ms", () =>
+      runWorkflowWithContext(rc, progress, mod, args, {
         abortController: runAbortController,
-        limit: resolvedOptions.parallelSubmissionLimit ?? resolvedOptions.concurrency * 2,
+        submissionLimit: resolvedOptions.parallelSubmissionLimit ?? resolvedOptions.concurrency * 2,
+        resolveWorkflow: resolvedOptions.resolveWorkflow,
+        depth: 0,
+        progressPrefix: "",
       }),
-    pipeline,
-    phase: (title) => progress.phase(title),
-    log: (message) => progress.log(message),
-    progress: (event) => progress.event(event),
-    args,
-    cwd: ctx.cwd,
-    signal: runAbortController.signal,
-  };
-
-  try {
-    return await perf.time("workflow.total_ms", () => mod.default(api));
+    );
   } finally {
     try {
       const snapshot = perf.snapshot();
@@ -77,12 +92,123 @@ export async function runWorkflow(
       progress.done();
       resolvedOptions.onProgressSnapshot?.(progress.snapshot());
     } finally {
+      resolvedOptions.onProgressSource?.(undefined);
       unlinkContextAbortSignal();
       unlinkOptionAbortSignal();
     }
   }
 }
 
+/**
+ * Build the `WorkflowApi` from an existing run context and invoke the module. Reused for both
+ * the top-level run and every `api.workflow()` sub-step, so children share the parent's semaphore,
+ * abort signal, and perf sink. No setup/teardown of its own — that belongs to `runWorkflow`.
+ */
+export async function runWorkflowWithContext(
+  rc: RunContext,
+  progress: WorkflowProgress,
+  mod: WorkflowModule,
+  args: string,
+  opts: WorkflowContextOptions,
+): Promise<unknown> {
+  const depth = opts.depth ?? 0;
+  const scope = createWorkflowScope(progress, opts.progressPrefix ?? "", opts.progressNamespace);
+
+  const agent = ((prompt: string, agentOpts?: AgentOptions) => runAgent(rc, prompt, scope.agentOptions(agentOpts))) as WorkflowApi["agent"];
+
+  const workflow: WorkflowApi["workflow"] =
+    depth >= 1
+      ? async () => {
+          throw new Error("workflow() can only nest one level deep");
+        }
+      : async (ref, childArgs) => {
+          if (!opts.resolveWorkflow) throw new Error("sub-workflows are not enabled in this context");
+          const childMod = await opts.resolveWorkflow(ref);
+          // A child controller isolates the child's failures from the parent (so the parent can
+          // try/catch a failed sub-workflow), while still cancelling the child when the run aborts.
+          const childController = new AbortController();
+          const unlink = linkAbortSignal(rc.signal, childController);
+          try {
+            return await runWorkflowWithContext({ ...rc, signal: childController.signal }, progress, childMod, childArgs ?? "", {
+              abortController: childController,
+              submissionLimit: opts.submissionLimit,
+              resolveWorkflow: opts.resolveWorkflow,
+              depth: depth + 1,
+              progressPrefix: `${childMod.meta.name} ▸ `,
+              progressNamespace: childMod.meta.name,
+            });
+          } finally {
+            unlink();
+            scope.restorePhase();
+          }
+        };
+
+  const api: WorkflowApi = {
+    agent,
+    workflow,
+    parallel: (thunks) =>
+      parallel(thunks, {
+        signal: rc.signal,
+        abortController: opts.abortController,
+        limit: opts.submissionLimit,
+      }),
+    pipeline,
+    phase: scope.phase,
+    log: scope.log,
+    progress: scope.event,
+    args,
+    cwd: rc.cwd,
+    signal: rc.signal,
+  };
+
+  return await mod.default(api);
+}
+
+interface WorkflowScope {
+  agentOptions(opts: AgentOptions | undefined): AgentOptions;
+  phase(title: string): void;
+  log(message: string): void;
+  event(event: WorkflowProgressEvent): void;
+  restorePhase(): void;
+}
+
+function createWorkflowScope(progress: WorkflowProgress, prefix: string, namespace: string | undefined): WorkflowScope {
+  let currentPhase = `${prefix}Workflow`;
+  const display = (title: string) => `${prefix}${title}`;
+  return {
+    agentOptions(opts) {
+      const phase = opts?.phase ? display(opts.phase) : currentPhase;
+      return opts ? { ...opts, phase } : { phase };
+    },
+    phase(title) {
+      currentPhase = display(title);
+      progress.phase(currentPhase);
+    },
+    log(message) {
+      progress.log(namespace ? `${namespace}: ${message}` : message);
+    },
+    event(event) {
+      progress.event(namespace ? namespaceProgressEvent(namespace, event) : event);
+    },
+    restorePhase() {
+      progress.phase(currentPhase);
+    },
+  };
+}
+
+function namespaceProgressEvent(namespace: string, event: WorkflowProgressEvent): WorkflowProgressEvent {
+  switch (event.type) {
+    case "counter":
+      return { ...event, key: `${namespace}.${event.key}` };
+    case "counter_delta":
+      return { ...event, key: `${namespace}.${event.key}` };
+    case "lane_item":
+      return { ...event, lane: `${namespace} ▸ ${event.lane}` };
+    case "summary":
+      return { ...event, key: `${namespace}.${event.key}` };
+  }
+}
+
 function formatPerfSummary(snapshot: PerfSnapshot): string {
   const parts = snapshot.aggregates
     .filter((aggregate) => aggregate.count > 0)

package/.pi/extensions/pi-workflow-engine/src/review/github-pr-comments.ts

@@ -28,7 +28,7 @@ export type InlineCommentStatus =
   | { readonly issueId: string; readonly status: "skipped"; readonly reason: string }
   | { readonly issueId: string; readonly status: "failed"; readonly reason: string };
 
-const PR_VIEW_JSON_FIELDS = "number,headRefOid,url,headRepositoryOwner,headRepository";
+const PR_VIEW_JSON_FIELDS = "number,headRefOid,url";
 
 export async function resolveGitHubPrContext(
   exec: ExecLike,
@@ -47,10 +47,10 @@ export async function resolveGitHubPrContext(
   if (number === undefined) return { ok: false, reason: "No GitHub PR number found." };
   if (!headSha) return { ok: false, reason: "GitHub PR head SHA is missing." };
 
-  const ownerFromPr = nestedStringField(prView.value, "headRepositoryOwner", "login");
-  const repoFromPr = nestedStringField(prView.value, "headRepository", "name");
-  let owner = ownerFromPr;
-  let repo = repoFromPr;
+  const url = stringField(prView.value, "url");
+  const baseFromUrl = parsePullRequestUrl(url);
+  let owner = baseFromUrl?.owner;
+  let repo = baseFromUrl?.repo;
   if (!owner || !repo) {
     const repoView = await runJson(exec, cwd, ["repo", "view", "--json", "nameWithOwner"]);
     if (!repoView.ok) return { ok: false, reason: repoView.reason };
@@ -61,7 +61,6 @@ export async function resolveGitHubPrContext(
   }
   if (!owner || !repo) return { ok: false, reason: "GitHub repository owner/name is missing." };
 
-  const url = stringField(prView.value, "url");
   return { ok: true, context: { owner, repo, number, headSha, url } };
 }
 
@@ -159,12 +158,6 @@ function stringField(value: unknown, key: string): string | undefined {
   return typeof field === "string" && field.trim().length > 0 ? field : undefined;
 }
 
-function nestedStringField(value: unknown, objectKey: string, key: string): string | undefined {
-  if (!isRecord(value)) return undefined;
-  const nested = value[objectKey];
-  return stringField(nested, key);
-}
-
 function parseNameWithOwner(value: string | undefined): { readonly owner: string; readonly repo: string } | undefined {
   if (!value) return undefined;
   const [owner, repo, extra] = value.split("/");
@@ -172,6 +165,18 @@ function parseNameWithOwner(value: string | undefined): { readonly owner: string
   return { owner, repo };
 }
 
+function parsePullRequestUrl(value: string | undefined): { readonly owner: string; readonly repo: string } | undefined {
+  if (!value) return undefined;
+  try {
+    const parsed = new URL(value);
+    const [owner, repo, type, number, extra] = parsed.pathname.split("/").filter(Boolean);
+    if (!owner || !repo || type !== "pull" || !number || extra !== undefined) return undefined;
+    return { owner, repo };
+  } catch {
+    return undefined;
+  }
+}
+
 function parsePostedCommentUrl(stdout: string): string | undefined {
   try {
     return stringField(JSON.parse(stdout), "html_url");

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

@@ -4,6 +4,9 @@ import type { Pipeline } from "./concurrency.ts";
 import type { PerfSink, PerfSnapshot } from "./perf.ts";
 import type { WorkflowProgressSnapshot } from "./progress.ts";
 
+/** A reference to a registered workflow by name. */
+export type WorkflowRef = string;
+
 /** Metadata every workflow module must export. */
 export interface WorkflowMeta {
   name: string;
@@ -29,12 +32,20 @@ export interface WorkflowRunOptions {
   signal?: AbortSignal;
   /** Internal recorder override for command/tool invocation timing. */
   perfRecorder?: PerfSink;
+  /** Resolve a sub-workflow reference to a module, enabling `api.workflow()`. When omitted, `api.workflow()` throws. */
+  resolveWorkflow?: (ref: WorkflowRef) => Promise<WorkflowModule>;
   /** Called with the final performance snapshot when perf is enabled. */
   onPerfSnapshot?: (snapshot: PerfSnapshot) => void;
+  /** Called with the live progress source while a workflow is running, then undefined when it ends. */
+  onProgressSource?: (source: WorkflowProgressSource | undefined) => void;
   /** Called with the final completed progress snapshot after live workflow UI teardown. */
   onProgressSnapshot?: (snapshot: WorkflowProgressSnapshot) => void;
 }
 
+export interface WorkflowProgressSource {
+  snapshot(): WorkflowProgressSnapshot;
+}
+
 /** Options for a single `agent()` call. */
 export type WorkflowLaneItemStatus = "pending" | "running" | "success" | "warning" | "error";
 
@@ -75,6 +86,13 @@ export interface WorkflowApi {
   agent<S extends TSchema>(prompt: string, opts: AgentOptions<S> & { schema: S }): Promise<Static<S> | null>;
   /** Run a subagent and return its final assistant text. */
   agent(prompt: string, opts?: AgentOptions): Promise<string>;
+  /**
+   * Run another registered workflow inline as a sub-step and return its result. The child shares
+   * this run's concurrency cap, abort signal, and perf sink. Nests one level only: calling
+   * `workflow()` from within a sub-workflow rejects. Rejects on unknown name — catch it to handle
+   * a missing sub-workflow gracefully.
+   */
+  workflow(ref: WorkflowRef, args?: string): Promise<unknown>;
   /** Run every thunk concurrently and wait for all (a barrier). */
   parallel<T>(thunks: Array<() => Promise<T>>): Promise<T[]>;
   /** Run each item through all stages independently — no barrier between stages. */

package/README.md

@@ -66,7 +66,7 @@ In a pi session, from inside a git repo with changes:
 /workflow diagnose "typecheck fails after the schema change"
 /workflow perf-review "workflow startup latency"
 /workflow code-review --inspect  # open the live workflow inspector while the run is active
-/workflow:inspector              # reopen the last completed workflow inspector
+/workflow:inspector              # open the current or last workflow inspector
 /workflow code-review --result-viewer     # explicitly open the post-review results viewer
 /workflow code-review --review-viewer     # alias for --result-viewer
 /workflow code-review --no-result-viewer  # explicitly keep the post-review viewer closed
@@ -87,7 +87,7 @@ dynamax inspect this bug with multiple focused agents
 /workflow:dynamax off
 ```
 
-`dynamax` is a permission signal for the host agent: once opted in, it may run an existing named workflow or author an inline workflow script through the `workflow` tool. In interactive mode, `/workflow` with no arguments also offers `✍ Author temporary one-shot workflow…`; choose it, type a brief, and pi will ask the host agent to author/run a temporary inline workflow.
+`dynamax` is a one-shot permission signal for the host agent: once opted in, it may run an existing named workflow or author an inline workflow script through the `workflow` tool. Dynamax workflow-tool runs open the live workflow inspector in the TUI while they run. `/workflow:dynamax on|off|status` controls sticky mode, and `/hotkeys` shows the registered inspector shortcut (`ctrl+shift+m` by default). Sticky mode, one-shot pending mode, and active Dynamax workflow runs show compact status with the relevant commands while active and leave no persistent UI when cleared. In interactive mode, `/workflow` with no arguments also offers `✍ Author temporary one-shot workflow…`; choose it, type a brief, and pi will ask the host agent to author/run a temporary inline workflow.
 
 The advisory workflows inspect and report only; they do not edit files. They return the same shape: summary, ranked findings, evidence, impact, recommendations, and next steps.
 
@@ -110,7 +110,7 @@ The bundled review workflow is deliberately shaped like a serious review process
 4. **Verify**: send each survivor to an independent verifier that must confirm, mark plausible, or refute with evidence.
 5. **Synthesize**: produce one ranked report with stats, verdicts, and concrete locations.
 
-After a direct TUI `/workflow code-review` run produces findings, pi records a readable table-formatted result message without asking whether to open another surface. Use `--result-viewer`/`--review-viewer` when you want the interactive findings viewer to open immediately, or `--no-result-viewer`/`--no-review-viewer` when a script or alias should explicitly keep it closed. Use `/workflow:inspector` after a run to reopen the last completed workflow inspector.
+After a direct TUI `/workflow code-review` run produces findings, pi records a readable table-formatted result message without asking whether to open another surface. Use `--result-viewer`/`--review-viewer` when you want the interactive findings viewer to open immediately, or `--no-result-viewer`/`--no-review-viewer` when a script or alias should explicitly keep it closed. Use `/workflow:inspector` during or after a run to open the workflow inspector.
 
 Viewer controls:
 
@@ -194,7 +194,7 @@ Under the hood:
 - **Each `agent()` is an in-process pi `AgentSession`** using `createAgentSession` and `SessionManager.inMemory()`.
 - **Structured output is a terminating tool**. The engine registers one tool whose `parameters` is your schema; pi validates the call and the engine captures the args. There is no JSON scraping.
 - **A single global semaphore caps concurrent agents**, so `parallel` and `pipeline` can nest freely while every `agent()` call still respects the run cap.
-- **Three surfaces are registered**: `/workflow <name> [args]` for direct use, grouped workflow commands such as `/workflow:dynamax on|off|status` and `/workflow:inspector`, and a `workflow` tool for host-agent delegation by `name` or inline `script`.
+- **Three surfaces are registered**: `/workflow <name> [args]` for direct use, grouped workflow commands such as `/workflow:dynamax [on|off|status]` and `/workflow:inspector`, and a `workflow` tool for host-agent delegation by `name` or inline `script`.
 
 ## Local development
 
@@ -208,7 +208,7 @@ bun run typecheck
 bun run test
 ```
 
-The test suite is no-LLM and uses Bun's built-in `bun test` runner, not a third-party test framework.
+Typechecking uses TypeScript Native Preview (`tsgo`) through `bun run typecheck`. The test suite is no-LLM and uses Bun's built-in `bun test` runner, not a third-party test framework.
 
 ### Performance controls and benchmarks
 

package/USAGE.md

@@ -1,9 +1,9 @@
 # Usage
 
-`pi-workflow-engine` adds multi-agent workflows to pi. Most users only need two surfaces:
+`pi-workflow-engine` adds multi-agent workflows to pi. Most users only need these surfaces:
 
 - `/workflow <name> [args]` to run a saved workflow directly.
-- `/workflow:*` commands for related actions such as inspector reopening and dynamax sticky mode.
+- `/workflow:*` commands for related actions such as inspector reopening and Dynamax control.
 - `dynamax` as a literal one-shot opt-in token when you want the host agent to author a one-off inline workflow for investigation/review.
 
 ## Run a workflow
@@ -24,7 +24,7 @@ Useful flags:
 
 ```text
 /workflow code-review --inspect          # show the live inspector while the run is active
-/workflow:inspector                      # reopen the last completed workflow inspector
+/workflow:inspector                      # open the current or last workflow inspector
 /workflow code-review --result-viewer    # explicitly open the findings viewer
 /workflow code-review --review-viewer    # alias for --result-viewer
 /workflow code-review --concurrency=4    # cap concurrent subagents
@@ -58,7 +58,7 @@ dynamax create a one-off workflow to compare the parser and tests before we chan
 dynamax use parallel agents to review this design and report the risks
 ```
 
-Sticky for the session:
+Sticky mode and inspector shortcut:
 
 ```text
 /workflow:dynamax on
@@ -66,7 +66,25 @@ Sticky for the session:
 /workflow:dynamax status
 ```
 
-With dynamax enabled, the host agent usually calls the `workflow` tool with `script`: a one-off inline workflow. It can still call a saved workflow by `name` when one already fits.
+The workflow inspector is also registered as a first-class shortcut shown by `/hotkeys`; the default is `ctrl+shift+m`. `ctrl+o` is intentionally not used because pi already uses it for tool-output expansion and tree filtering.
+
+When only the literal `dynamax` token is used, the opt-in is one-shot: the next agent run receives the workflow permission reminder, stays visibly active for that run, then clears after the run ends. When `/workflow:dynamax on` is used, the opt-in is sticky for the current pi session until `/workflow:dynamax off`. Sticky mode, one-shot pending mode, and active Dynamax workflow runs show compact TUI status with `/workflow:dynamax on|off` and the inspector shortcut; off mode clears that status line.
+
+When the host agent calls the `workflow` tool from a TUI session, pi opens the live workflow inspector for that run. The compact workflow widget still shows the latest moving status above the editor, but the inspector is the richer view for phases, agents, findings, and logs.
+
+Configure the inspector shortcut by creating `~/.pi/agent/extensions/pi-workflow-engine.json`:
+
+```json
+{
+  "shortcuts": {
+    "inspector": "ctrl+shift+x"
+  }
+}
+```
+
+Set `"inspector": null` to disable the shortcut while keeping `/workflow:dynamax` and `/workflow:inspector` available.
+
+With Dynamax enabled, the host agent usually calls the `workflow` tool with `script`: a one-off inline workflow. It can still call a saved workflow by `name` when one already fits.
 
 ## Workflow results
 
@@ -121,9 +139,23 @@ Core primitives:
 | `pipeline(items, ...stages)` | Runs each item through stages independently. |
 | `phase(title)` / `log(message)` | Updates workflow progress UI. |
 | `progress(event)` | Emits counters, summaries, and lane items. |
+| `workflow(ref, args?)` | Runs another workflow inline as a sub-step and returns its result. |
 
 Set `thinkingLevel` on fan-out agents. Otherwise many subagents can inherit an expensive global reasoning level.
 
+### Compose workflows
+
+`workflow(ref, args?)` runs a registered workflow by name as a sub-step, returning its result. The child shares the parent run's concurrency cap, abort signal, and perf timing, and its phases nest under `<name> ▸ <phase>` in the live UI.
+
+```ts
+export default async function run({ workflow }: WorkflowApi) {
+  const review = await workflow("code-review", "HEAD~3");
+  return { review };
+}
+```
+
+Nesting is one level only: calling `workflow()` from inside a sub-workflow rejects. Resolution throws on an unknown name — wrap the call in `try/catch` if a missing sub-workflow should be non-fatal (note `parallel()` rejects the whole batch on the first error, so catch inside each thunk for per-branch resilience).
+
 ### Where workflows live
 
 Guaranteed built-ins are statically registered:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-workflow-engine",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "type": "module",
   "description": "A customisable multi-agent workflow-orchestration engine for the pi coding agent.",
   "keywords": [
@@ -23,7 +23,7 @@
   "files": [
     ".pi/extensions/pi-workflow-engine",
     ".pi/settings.json",
-    "assets",
+    "assets/preview.png",
     "skills",
     "README.md",
     "USAGE.md",
@@ -35,8 +35,8 @@
     "image": "https://raw.githubusercontent.com/timbrinded/pi-workflow-engine/master/assets/preview.png"
   },
   "scripts": {
-    "typecheck": "tsc --noEmit",
-    "test": "bun test",
+    "typecheck": "tsgo --noEmit",
+    "test": "bun test --timeout=30000",
     "test:changedlines": "bun test tests/changedlines.test.ts",
     "test:concurrency": "bun test tests/concurrency.test.ts",
     "test:smoke": "bun test tests/discovery.test.ts",
@@ -46,7 +46,7 @@
     "bench:discovery": "bun run scripts/bench/discovery.ts",
     "bench:startup": "bun run scripts/bench/startup.ts",
     "bench:ui": "bun run scripts/bench/ui.ts",
-    "prepublishOnly": "tsc --noEmit && bun run test"
+    "prepublishOnly": "tsgo --noEmit && bun run test"
   },
   "peerDependencies": {
     "@earendil-works/pi-agent-core": "*",
@@ -57,6 +57,6 @@
   },
   "devDependencies": {
     "@types/node": "^22",
-    "typescript": "^5.6.0"
+    "@typescript/native-preview": "^7.0.0-dev.20260615.1"
   }
 }