@bastani/atomic 0.8.31-alpha.5 → 0.9.0-alpha.2

package/dist/builtin/workflows/src/extension/discovery.ts

@@ -20,18 +20,14 @@
  *   const result = await discoverWorkflows({ cwd: process.cwd(), homeDir: os.homedir() });
  */
 
-import { readdir, stat } from "node:fs/promises";
-import { join, resolve, extname, isAbsolute } from "node:path";
+import { join } from "node:path";
 import { CONFIG_DIR_NAMES, getProjectConfigPaths } from "@bastani/atomic";
 import type { WorkflowDefinition } from "../shared/types.js";
 import { createRegistry } from "../workflows/registry.js";
 import type { WorkflowRegistry } from "../workflows/registry.js";
 import * as bundledManifest from "../../builtin/index.js";
-import {
-  collectWorkflowModuleCandidates,
-  loadWorkflowModule,
-  validateWorkflowDefinitionShape as validateDefinitionShape,
-} from "./workflow-module-loader.js";
+import { validateWorkflowDefinitionShape as validateDefinitionShape } from "./workflow-module-loader.js";
+import { loadFromDir, loadFromPaths, type WorkflowModuleCandidateRecord } from "./discovery-loaders.js";
 
 // ---------------------------------------------------------------------------
 // Public types
@@ -149,14 +145,6 @@ export interface DiscoveryResult {
 // Internal helpers
 // ---------------------------------------------------------------------------
 
-type WorkflowModuleCandidateRecord = {
-  readonly value: unknown;
-  readonly exportKey: string;
-  readonly kind: DiscoveryKind;
-  readonly filePath?: string;
-  readonly configuredName?: string;
-};
-
 /**
  * Validate DiscoveryConfig shape.
  * Returns null when valid, or a description of the problem.
@@ -274,108 +262,6 @@ function applyBatchShapeOnly(
   return registry;
 }
 
-/** Scan a directory for .ts/.js/.mjs/.cjs files, returning sorted absolute paths. */
-async function scanWorkflowDir(dir: string): Promise<string[] | null> {
-  try {
-    const entries = await readdir(dir, { withFileTypes: true });
-    const WORKFLOW_EXTS = new Set([".ts", ".js", ".mjs", ".cjs"]);
-    return entries
-      .filter((e) => e.isFile() && WORKFLOW_EXTS.has(extname(e.name)))
-      .map((e) => join(dir, e.name))
-      .sort();
-  } catch {
-    // Directory doesn't exist or isn't readable — not an error, just empty
-    return null;
-  }
-}
-
-async function importWorkflowFile(
-  filePath: string,
-  kind: DiscoveryKind,
-  diagnostics: DiscoveryDiagnostic[],
-): Promise<WorkflowModuleCandidateRecord[]> {
-  let mod: Record<string, unknown>;
-  try {
-    mod = loadWorkflowModule(filePath);
-  } catch (err) {
-    diagnostics.push({
-      level: "error",
-      code: "IMPORT_FAILED",
-      message: `Failed to import "${filePath}": ${err instanceof Error ? err.message : String(err)}`,
-      source: filePath,
-    });
-    return [];
-  }
-
-  return collectWorkflowModuleCandidates(mod).map((candidate) => ({
-    ...candidate,
-    kind,
-    filePath,
-  }));
-}
-
-/** Load workflows from a scanned directory. */
-async function loadFromDir(
-  dir: string,
-  kind: DiscoveryKind,
-  diagnostics: DiscoveryDiagnostic[],
-): Promise<WorkflowModuleCandidateRecord[]> {
-  const files = await scanWorkflowDir(dir);
-  if (files === null) return [];
-
-  const all: WorkflowModuleCandidateRecord[] = [];
-  for (const filePath of files) {
-    const candidates = await importWorkflowFile(filePath, kind, diagnostics);
-    all.push(...candidates);
-  }
-  return all;
-}
-
-/** Load workflows from an explicit path list (from config). */
-async function loadFromPaths(
-  pathsOrMap: string[] | Record<string, string>,
-  kind: DiscoveryKind,
-  baseCwd: string,
-  diagnostics: DiscoveryDiagnostic[],
-): Promise<WorkflowModuleCandidateRecord[]> {
-  const all: WorkflowModuleCandidateRecord[] = [];
-
-  // Normalise to [ { rawPath, configuredName? } ] regardless of input shape
-  const entries: Array<{ rawPath: string; configuredName?: string }> = Array.isArray(pathsOrMap)
-    ? pathsOrMap.map((p) => ({ rawPath: p }))
-    : Object.entries(pathsOrMap).map(([name, p]) => ({ rawPath: p, configuredName: name }));
-
-  for (const { rawPath, configuredName } of entries) {
-    const absPath = isAbsolute(rawPath) ? rawPath : resolve(baseCwd, rawPath);
-
-    // Give a specific PATH_NOT_FOUND when we can detect the file is absent.
-    let pathStats: Awaited<ReturnType<typeof stat>> | undefined;
-    try {
-      pathStats = await stat(absPath);
-    } catch {
-      pathStats = undefined;
-    }
-
-    if (pathStats === undefined) {
-      diagnostics.push({
-        level: "error",
-        code: "PATH_NOT_FOUND",
-        message: `Workflow path not found: "${absPath}"`,
-        source: absPath,
-      });
-      continue;
-    }
-
-    const candidates = pathStats.isDirectory()
-      ? await loadFromDir(absPath, kind, diagnostics)
-      : await importWorkflowFile(absPath, kind, diagnostics);
-    for (const c of candidates) {
-      all.push({ ...c, ...(configuredName !== undefined ? { configuredName } : {}) });
-    }
-  }
-  return all;
-}
-
 // ---------------------------------------------------------------------------
 // Main API
 // ---------------------------------------------------------------------------

package/dist/builtin/workflows/src/extension/extension-factory.ts

@@ -0,0 +1,120 @@
+import { killRun } from "../runs/background/status.js";
+import { cancellationRegistry } from "../runs/background/cancellation-registry.js";
+import { store } from "../shared/store.js";
+import { subscribeIntercomControl } from "../intercom/result-intercom.js";
+import { buildIntercomCallbacks } from "../intercom/intercom-routing.js";
+import { installStoreWidget, installToolExecutionHooks } from "../tui/store-widget-installer.js";
+import { buildGraphOverlayAdapter } from "../tui/overlay-adapter.js";
+import type { GraphOverlayPort } from "../tui/overlay-adapter.js";
+import { registerInlineFormRenderer } from "../tui/inline-form-overlay.js";
+import { registerChatSurfaceRenderer, emitChatSurface } from "../tui/chat-surface-message.js";
+import { deriveGraphTheme } from "../tui/graph-theme.js";
+import type { WorkflowPersistencePort } from "../shared/types.js";
+import { renderRunBanner, renderRunSummary, type RunEndPayload, type RunStartPayload } from "./renderers.js";
+import { buildRuntimeAdapters } from "./wiring.js";
+import type { ExtensionAPI, PiCommandContext } from "./public-types.js";
+import { createWorkflowExtensionRuntimeState } from "./extension-runtime-state.js";
+import { registerWorkflowLifecycleHandlers } from "./extension-lifecycle.js";
+import { dynamicTextRenderComponent } from "./render-component.js";
+import { makeExecuteWorkflowTool } from "./workflow-tool.js";
+import { registerWorkflowTool } from "./workflow-tool-registration.js";
+import { registerWorkflowSlashCommand } from "./workflow-command-registration.js";
+import { installInputInterceptor, type WorkflowCommandHandler } from "./workflow-command-utils.js";
+import { overlaySurfaceFromContext } from "./workflow-targets.js";
+
+function registerWorkflowMessageRenderers(pi: ExtensionAPI): void {
+  if (typeof pi.registerMessageRenderer !== "function") return;
+  pi.registerMessageRenderer("workflow.run.start", (payload) =>
+    dynamicTextRenderComponent(() => renderRunBanner(payload as RunStartPayload)),
+  );
+  pi.registerMessageRenderer("workflow.run.end", (payload) =>
+    dynamicTextRenderComponent(() => renderRunSummary(payload as RunEndPayload)),
+  );
+  registerInlineFormRenderer(pi, deriveGraphTheme({}));
+  registerChatSurfaceRenderer(pi, deriveGraphTheme({}));
+}
+
+function buildWorkflowOverlay(
+  pi: ExtensionAPI,
+  getPersistence: () => WorkflowPersistencePort | undefined,
+): GraphOverlayPort {
+  return buildGraphOverlayAdapter(pi, store, {
+    onKillRun: (runId) => {
+      const run = store.runs().find((r) => r.id === runId);
+      const result = killRun(runId, { cancellation: cancellationRegistry, persistence: getPersistence() });
+      if (run && result.ok) {
+        emitChatSurface(pi, { kind: "killed", run, previousStatus: result.previousStatus });
+      }
+    },
+  });
+}
+
+function registerWorkflowShortcut(pi: ExtensionAPI, overlay: GraphOverlayPort): void {
+  if (typeof pi.registerShortcut !== "function") return;
+  const openPane = (ctx?: PiCommandContext): void => {
+    const activeRunId = store.activeRunId();
+    const fallback = activeRunId ?? store.runs().at(-1)?.id ?? null;
+    overlay.open(fallback, overlaySurfaceFromContext(ctx));
+  };
+  pi.registerShortcut("F2", {
+    description: "Open workflow orchestrator pane",
+    handler: openPane,
+  });
+}
+
+function registerIntercomControl(
+  pi: ExtensionAPI,
+  intercomControlRef: { current: (() => void) | null },
+): void {
+  intercomControlRef.current = subscribeIntercomControl(
+    pi,
+    buildIntercomCallbacks({
+      store,
+      emit: typeof pi.events?.emit === "function"
+        ? (event, payload) => pi.events!.emit!(event, payload)
+        : undefined,
+      confirm: typeof pi.ui?.confirm === "function"
+        ? (title, message) => pi.ui!.confirm!(title, message)
+        : undefined,
+    }),
+  );
+}
+
+function factory(pi: ExtensionAPI): void {
+  const adapters = buildRuntimeAdapters(pi);
+  const runtimeState = createWorkflowExtensionRuntimeState(pi, adapters);
+  const overlay = buildWorkflowOverlay(pi, () => runtimeState.persistenceRef.current);
+  const workflowCommands = new Map<string, WorkflowCommandHandler>();
+  const storeWidgetRef: { current: (() => void) | null } = { current: null };
+  const intercomControlRef: { current: (() => void) | null } = { current: null };
+  const executeWorkflowTool = makeExecuteWorkflowTool(
+    (ctx) => runtimeState.runtimeForContext(ctx),
+    () => runtimeState.persistenceRef.current,
+    runtimeState.reloadWorkflowResources,
+  );
+
+  registerWorkflowTool(pi, executeWorkflowTool, runtimeState.runWithLifecycleSuppressedForPolicy);
+  registerWorkflowSlashCommand(pi, workflowCommands, {
+    runtimeProxy: runtimeState.runtimeProxy,
+    runtimeForContext: runtimeState.runtimeForContext,
+    overlay,
+    reloadWorkflowResources: runtimeState.reloadWorkflowResources,
+    runWithLifecycleSuppressedForPolicy: runtimeState.runWithLifecycleSuppressedForPolicy,
+    runControl: {
+      pi,
+      overlay,
+      getPersistence: () => runtimeState.persistenceRef.current,
+      runtimeForContext: runtimeState.runtimeForContext,
+    },
+  });
+  registerWorkflowMessageRenderers(pi);
+  registerWorkflowLifecycleHandlers(pi, { runtimeState, storeWidgetRef, intercomControlRef });
+
+  storeWidgetRef.current = installStoreWidget(pi, store);
+  installToolExecutionHooks(pi, store);
+  registerWorkflowShortcut(pi, overlay);
+  registerIntercomControl(pi, intercomControlRef);
+  installInputInterceptor(pi, workflowCommands);
+}
+
+export default factory;

package/dist/builtin/workflows/src/extension/extension-lifecycle.ts

@@ -0,0 +1,109 @@
+import { killAllRuns } from "../runs/background/status.js";
+import { cancellationRegistry } from "../runs/background/cancellation-registry.js";
+import { stageControlRegistry } from "../runs/foreground/stage-control-registry.js";
+import { store } from "../shared/store.js";
+import { restoreOnSessionStart } from "../shared/persistence-restore.js";
+import { installCompactionHook } from "../shared/persistence-compaction-policy.js";
+import { clearForms } from "../tui/inline-form-store.js";
+import { installStoreWidget } from "../tui/store-widget-installer.js";
+import { registerIntercomParentSession } from "../intercom/intercom-bridge.js";
+import {
+  resetWorkflowLifecycleNotificationState,
+  seedWorkflowLifecycleNotificationState,
+  withWorkflowLifecycleNotificationsSuppressed,
+} from "./lifecycle-notifications.js";
+import { resetWorkflowHilAnswerNotificationState } from "./hil-answer-notifications.js";
+import type { ExtensionAPI } from "./public-types.js";
+import type { WorkflowExtensionRuntimeState } from "./extension-runtime-state.js";
+import { deAdvertiseAskUserQuestionWhenHeadless, formatStartupDiagnostics } from "./workflow-command-surfaces.js";
+import { inFlightRunCount } from "./workflow-targets.js";
+
+export interface WorkflowLifecycleRegistrationDeps {
+  runtimeState: WorkflowExtensionRuntimeState;
+  storeWidgetRef: { current: (() => void) | null };
+  intercomControlRef: { current: (() => void) | null };
+}
+
+export function registerWorkflowLifecycleHandlers(
+  pi: ExtensionAPI,
+  deps: WorkflowLifecycleRegistrationDeps,
+): void {
+  if (typeof pi.on !== "function") return;
+  const { runtimeState } = deps;
+  pi.on("session_before_switch", async (event, ctx) => {
+    const reason = typeof event === "object" && event !== null && "reason" in event
+      ? (event as { readonly reason?: string }).reason
+      : undefined;
+    if (reason !== "new" && reason !== "resume") return undefined;
+    const inFlightWorkflowCount = inFlightRunCount();
+    if (inFlightWorkflowCount === 0) return undefined;
+    const confirmSessionSwitch = ctx?.ui?.confirm;
+    if (typeof confirmSessionSwitch !== "function") return undefined;
+    const workflowNoun = inFlightWorkflowCount === 1 ? "workflow" : "workflows";
+    const actionLabel = reason === "new" ? "Start a new session" : "Resume another session";
+    const messageLabel = reason === "new" ? "Starting a new session" : "Resuming another session";
+    try {
+      const shouldSwitchSession = await confirmSessionSwitch(
+        `${actionLabel} and stop ${inFlightWorkflowCount} in-flight ${workflowNoun}?`,
+        `${messageLabel} will stop/kill ${inFlightWorkflowCount} in-flight ${workflowNoun} and clear workflow history tied to the current session.`,
+      );
+      if (shouldSwitchSession) return undefined;
+    } catch {
+      return undefined;
+    }
+    const cancelledLabel = reason === "new" ? "New session" : "Resume";
+    ctx?.ui?.notify?.(`${cancelledLabel} cancelled; in-flight workflows were left unchanged.`, "info");
+    return { cancel: true };
+  });
+
+  pi.on("session_start", async (_event, ctx) => {
+    deAdvertiseAskUserQuestionWhenHeadless(pi, ctx?.hasUI);
+    killAllRuns({ store, cancellation: cancellationRegistry, persistence: runtimeState.persistenceRef.current });
+    store.clear();
+    clearForms();
+    resetWorkflowLifecycleNotificationState(runtimeState.lifecycleNotificationState);
+    resetWorkflowHilAnswerNotificationState(runtimeState.hilAnswerNotificationState);
+    stageControlRegistry.clear();
+    runtimeState.setIntercomParentSession(registerIntercomParentSession(pi));
+    await runtimeState.discoveryPromise;
+    runtimeState.setNotificationsActive(true);
+    if (ctx?.ui) {
+      const diagnostics = formatStartupDiagnostics(runtimeState.configLoadRef.current, runtimeState.discoveryRef.current);
+      if (diagnostics !== null) ctx.ui.notify?.(diagnostics, "warning");
+      deps.storeWidgetRef.current?.();
+      deps.storeWidgetRef.current = installStoreWidget({ ui: ctx.ui }, store);
+    }
+    const sessionManager = ctx?.sessionManager ?? pi.sessionManager;
+    runtimeState.updateHostStageSessionDir(sessionManager);
+    if (sessionManager) {
+      const cfg = runtimeState.configLoadRef.current?.config;
+      withWorkflowLifecycleNotificationsSuppressed(runtimeState.lifecycleNotificationState, () => {
+        restoreOnSessionStart(
+          sessionManager,
+          {
+            resumeInFlight: cfg?.resumeInFlight ?? "ask",
+            persistRuns: cfg?.persistRuns ?? true,
+          },
+          store,
+        );
+        seedWorkflowLifecycleNotificationState(runtimeState.lifecycleNotificationState, store.snapshot());
+      });
+    }
+  });
+
+  installCompactionHook(pi, store);
+  pi.on("session_shutdown", (event) => {
+    const reason = typeof event === "object" && event !== null && "reason" in event
+      ? (event as { readonly reason?: string }).reason
+      : undefined;
+    deps.intercomControlRef.current?.();
+    deps.intercomControlRef.current = null;
+    if (reason === "quit") {
+      killAllRuns({ store, cancellation: cancellationRegistry, persistence: runtimeState.persistenceRef.current });
+      stageControlRegistry.clear();
+    }
+    deps.storeWidgetRef.current?.();
+    deps.storeWidgetRef.current = null;
+    runtimeState.setNotificationsActive(false);
+  });
+}

package/dist/builtin/workflows/src/extension/extension-runtime-state.ts

@@ -0,0 +1,270 @@
+import type { CreateAgentSessionOptions } from "@bastani/atomic";
+import type { StageAdapters } from "../runs/foreground/stage-runner.js";
+import type { SessionManager } from "../shared/persistence-restore.js";
+import type {
+  WorkflowExecutionPolicy,
+  WorkflowMcpPort,
+  WorkflowModelCatalogPort,
+  WorkflowModelInfo,
+  WorkflowPersistencePort,
+  WorkflowRuntimeConfig,
+} from "../shared/types.js";
+import { stageUiBroker } from "../shared/stage-ui-broker.js";
+import { store } from "../shared/store.js";
+import { cancellationRegistry } from "../runs/background/cancellation-registry.js";
+import { createExtensionRuntime, type ExtensionRuntime } from "./runtime.js";
+import { discoverStartupWorkflowsSync, discoverWorkflows, type DiscoveryResult } from "./discovery.js";
+import {
+  loadWorkflowConfig,
+  toScopedDiscoveryConfig,
+  withWorkflowDefaults,
+  WORKFLOW_CONFIG_DEFAULTS,
+  type ConfigLoadResult,
+} from "./config-loader.js";
+import { createStatusWriter, type StatusWriter } from "./status-writer.js";
+import {
+  createWorkflowLifecycleNotificationState,
+  installWorkflowLifecycleNotifications,
+  registerLifecycleNoticeRenderer,
+  withWorkflowLifecycleNotificationsSuppressedAsync,
+  type WorkflowLifecycleNotificationConfig,
+} from "./lifecycle-notifications.js";
+import {
+  createWorkflowHilAnswerNotificationState,
+  installWorkflowHilAnswerNotifications,
+  registerHilAnswerNoticeRenderer,
+} from "./hil-answer-notifications.js";
+import type { ExtensionAPI, PiModelContext } from "./public-types.js";
+import { makeMcpPort, makePersistencePort } from "./workflow-ports.js";
+import { inFlightRunCount, reloadBlockedMessage, WorkflowReloadBlockedError } from "./workflow-targets.js";
+
+export interface WorkflowExtensionRuntimeState {
+  persistenceRef: { current: WorkflowPersistencePort | undefined };
+  mcpPort: WorkflowMcpPort | undefined;
+  runtimeProxy: ExtensionRuntime;
+  configLoadRef: { current: ConfigLoadResult | null };
+  discoveryRef: { current: DiscoveryResult | null };
+  discoveryPromise: Promise<void>;
+  lifecycleNotificationState: ReturnType<typeof createWorkflowLifecycleNotificationState>;
+  hilAnswerNotificationState: ReturnType<typeof createWorkflowHilAnswerNotificationState>;
+  runtimeForContext(ctx?: PiModelContext): ExtensionRuntime;
+  reloadWorkflowResources(options?: { allowInFlight?: boolean }): Promise<void>;
+  runWithLifecycleSuppressedForPolicy<T>(policy: WorkflowExecutionPolicy, fn: () => Promise<T>): Promise<T>;
+  setNotificationsActive(active: boolean): void;
+  setIntercomParentSession(session: string | null): void;
+  updateHostStageSessionDir(sessionManager: SessionManager | undefined): void;
+}
+
+export function createWorkflowExtensionRuntimeState(
+  pi: ExtensionAPI,
+  adapters: StageAdapters,
+): WorkflowExtensionRuntimeState {
+  const persistenceRef = { current: makePersistencePort(pi, WORKFLOW_CONFIG_DEFAULTS.persistRuns) };
+  const mcpPort = makeMcpPort(pi);
+  const runtimeConfigRef: { current: WorkflowRuntimeConfig } = {
+    current: {
+      maxDepth: WORKFLOW_CONFIG_DEFAULTS.maxDepth,
+      defaultConcurrency: WORKFLOW_CONFIG_DEFAULTS.defaultConcurrency,
+      persistRuns: WORKFLOW_CONFIG_DEFAULTS.persistRuns,
+      statusFile: WORKFLOW_CONFIG_DEFAULTS.statusFile,
+      resumeInFlight: WORKFLOW_CONFIG_DEFAULTS.resumeInFlight,
+    },
+  };
+  let statusWriterRef: StatusWriter = createStatusWriter(store, runtimeConfigRef.current);
+  let lifecycleNotificationsUnsubscribe: (() => void) | null = null;
+  let hilAnswerNotificationsUnsubscribe: (() => void) | null = null;
+  let notificationsActive = false;
+  const lifecycleNotificationState = createWorkflowLifecycleNotificationState();
+  const hilAnswerNotificationState = createWorkflowHilAnswerNotificationState();
+  const lifecycleNotificationConfigRef: { current: WorkflowLifecycleNotificationConfig } = {
+    current: WORKFLOW_CONFIG_DEFAULTS.workflowNotifications,
+  };
+  const registerMessageRenderer: ExtensionAPI["registerMessageRenderer"] | undefined =
+    typeof pi.registerMessageRenderer === "function"
+      ? (event, renderer) => pi.registerMessageRenderer!(event, renderer)
+      : undefined;
+  registerLifecycleNoticeRenderer({ rendererHost: pi, registerMessageRenderer });
+  registerHilAnswerNoticeRenderer({ rendererHost: pi, registerMessageRenderer });
+  const sendWorkflowNotificationMessage: ExtensionAPI["sendMessage"] | undefined =
+    typeof pi.sendMessage === "function" ? (message, options) => pi.sendMessage!(message, options) : undefined;
+  const reinstallLifecycleNotifications = (): void => {
+    lifecycleNotificationsUnsubscribe?.();
+    lifecycleNotificationsUnsubscribe = null;
+    if (!notificationsActive) return;
+    lifecycleNotificationsUnsubscribe = installWorkflowLifecycleNotifications({
+      store,
+      config: lifecycleNotificationConfigRef.current,
+      state: lifecycleNotificationState,
+      seedExisting: true,
+      sendMessage: sendWorkflowNotificationMessage,
+    });
+  };
+  const reinstallHilAnswerNotifications = (): void => {
+    hilAnswerNotificationsUnsubscribe?.();
+    hilAnswerNotificationsUnsubscribe = null;
+    if (!notificationsActive) return;
+    hilAnswerNotificationsUnsubscribe = installWorkflowHilAnswerNotifications({
+      store,
+      stageUiBroker,
+      state: hilAnswerNotificationState,
+      sendMessage: sendWorkflowNotificationMessage,
+    });
+  };
+
+  let intercomParentSession: string | null = null;
+  const intercomPort = {
+    emit: typeof pi.events?.emit === "function"
+      ? (event: string, payload: Record<string, unknown>) => pi.events!.emit!(event, payload)
+      : undefined,
+    parentSession: () => intercomParentSession ?? undefined,
+  };
+  const hostStageSessionDir: { current: string | undefined } = { current: undefined };
+  const resolveDefaultStageSessionDir = (): string | undefined => hostStageSessionDir.current;
+  const startupDiscovery = discoverStartupWorkflowsSync();
+  const runtimeRef: { current: ExtensionRuntime } = {
+    current: createExtensionRuntime({
+      registry: startupDiscovery.registry,
+      cwd: process.cwd(),
+      adapters,
+      cancellation: cancellationRegistry,
+      persistence: persistenceRef.current,
+      mcp: mcpPort,
+      intercom: intercomPort,
+      config: runtimeConfigRef.current,
+      resolveDefaultStageSessionDir,
+    }),
+  };
+  const discoveryRef: { current: DiscoveryResult | null } = { current: null };
+  const configLoadRef: { current: ConfigLoadResult | null } = { current: null };
+  const runtimeProxy: ExtensionRuntime = {
+    get registry() { return runtimeRef.current.registry; },
+    dispatch(args, options) { return runtimeRef.current.dispatch(args, options); },
+    runDirect(args, options) { return runtimeRef.current.runDirect(args, options); },
+    resumeFailedRun(sourceRunId, stageId, options) { return runtimeRef.current.resumeFailedRun(sourceRunId, stageId, options); },
+  };
+
+  function workflowModelCatalogFromContext(ctx?: PiModelContext): WorkflowModelCatalogPort | undefined {
+    if (ctx?.modelRegistry === undefined && ctx?.model === undefined) return undefined;
+    return {
+      listModels: async (): Promise<readonly WorkflowModelInfo[]> => {
+        const available = ctx.modelRegistry?.getAvailable() ?? (ctx.model === undefined ? [] : [ctx.model]);
+        return available.map((model) => ({
+          provider: String(model.provider),
+          id: model.id,
+          fullId: `${String(model.provider)}/${model.id}`,
+          model: model as NonNullable<CreateAgentSessionOptions["model"]>,
+        }));
+      },
+      ...(ctx.model !== undefined
+        ? {
+            currentModel: ctx.model as NonNullable<CreateAgentSessionOptions["model"]>,
+            preferredProvider: String(ctx.model.provider),
+          }
+        : {}),
+    };
+  }
+
+  function runtimeForContext(ctx?: PiModelContext): ExtensionRuntime {
+    const models = workflowModelCatalogFromContext(ctx);
+    if (models === undefined) return runtimeProxy;
+    return createExtensionRuntime({
+      registry: runtimeRef.current.registry,
+      cwd: process.cwd(),
+      adapters,
+      cancellation: cancellationRegistry,
+      persistence: persistenceRef.current,
+      mcp: mcpPort,
+      intercom: intercomPort,
+      config: runtimeConfigRef.current,
+      models,
+      resolveDefaultStageSessionDir,
+    });
+  }
+
+  let workflowReloadQueue: Promise<void> = Promise.resolve();
+  async function reloadWorkflowResources(options?: { allowInFlight?: boolean }): Promise<void> {
+    const reload = workflowReloadQueue.then(() => reloadWorkflowResourcesNow(options));
+    workflowReloadQueue = reload.catch(() => {});
+    await reload;
+  }
+  async function loadPackageWorkflowPaths(): Promise<string[]> {
+    const packageResources = (await pi.refreshWorkflowResources?.()) ?? pi.getWorkflowResources?.() ?? [];
+    return packageResources.filter((resource) => resource.enabled !== false).map((resource) => resource.path);
+  }
+  async function reloadWorkflowResourcesNow(options?: { allowInFlight?: boolean }): Promise<void> {
+    const activeRuns = inFlightRunCount();
+    if (options?.allowInFlight !== true && activeRuns > 0) {
+      throw new WorkflowReloadBlockedError(reloadBlockedMessage(activeRuns));
+    }
+    if (options?.allowInFlight === true && activeRuns > 0 && process.env.ATOMIC_WORKFLOW_DEBUG === "1") {
+      console.warn(`Workflow reload bypassed in-flight guard with ${activeRuns} active run(s).`);
+    }
+    const configResult = await loadWorkflowConfig();
+    configLoadRef.current = configResult;
+    const { homedir } = await import("node:os");
+    const hasGlobal = configResult.globalConfig != null;
+    const hasProject = configResult.projectConfig != null;
+    const discoveryConfig = hasGlobal || hasProject
+      ? toScopedDiscoveryConfig(configResult.globalConfig ?? null, configResult.projectConfig ?? null, { projectRoot: process.cwd(), homeDir: homedir() })
+      : undefined;
+    const result = await discoverWorkflows({ config: discoveryConfig, packageWorkflowPaths: await loadPackageWorkflowPaths() });
+    discoveryRef.current = result;
+    const effectiveConfig = withWorkflowDefaults(configResult.config ?? {});
+    runtimeConfigRef.current = {
+      maxDepth: effectiveConfig.maxDepth,
+      defaultConcurrency: effectiveConfig.defaultConcurrency,
+      persistRuns: effectiveConfig.persistRuns,
+      statusFile: effectiveConfig.statusFile,
+      resumeInFlight: effectiveConfig.resumeInFlight,
+    };
+    lifecycleNotificationConfigRef.current = effectiveConfig.workflowNotifications;
+    reinstallLifecycleNotifications();
+    statusWriterRef.unsubscribe();
+    statusWriterRef = createStatusWriter(store, runtimeConfigRef.current);
+    persistenceRef.current = makePersistencePort(pi, effectiveConfig.persistRuns);
+    runtimeRef.current = createExtensionRuntime({
+      registry: result.registry,
+      cwd: process.cwd(),
+      adapters,
+      cancellation: cancellationRegistry,
+      persistence: persistenceRef.current,
+      mcp: mcpPort,
+      intercom: intercomPort,
+      config: runtimeConfigRef.current,
+      resolveDefaultStageSessionDir,
+    });
+  }
+
+  return {
+    persistenceRef,
+    mcpPort,
+    runtimeProxy,
+    configLoadRef,
+    discoveryRef,
+    discoveryPromise: pi.disableAsyncDiscovery ? Promise.resolve() : reloadWorkflowResources({ allowInFlight: true }),
+    lifecycleNotificationState,
+    hilAnswerNotificationState,
+    runtimeForContext,
+    reloadWorkflowResources,
+    runWithLifecycleSuppressedForPolicy(policy, fn) {
+      return policy.mode !== "non_interactive" || policy.awaitTerminalRun !== true
+        ? fn()
+        : withWorkflowLifecycleNotificationsSuppressedAsync(lifecycleNotificationState, fn);
+    },
+    setNotificationsActive(active) {
+      notificationsActive = active;
+      reinstallLifecycleNotifications();
+      reinstallHilAnswerNotifications();
+    },
+    setIntercomParentSession(session) { intercomParentSession = session; },
+    updateHostStageSessionDir(sessionManager) {
+      try {
+        hostStageSessionDir.current = sessionManager?.usesDefaultSessionDir?.() === false
+          ? sessionManager.getSessionDir?.()
+          : undefined;
+      } catch {
+        hostStageSessionDir.current = undefined;
+      }
+    },
+  };
+}