@bastani/atomic 0.9.9-alpha.2 → 0.9.9-alpha.4

package/dist/builtin/workflows/CHANGELOG.md

@@ -6,6 +6,20 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.9.9-alpha.4] - 2026-07-15
+
+### Fixed
+
+- Fixed workflow resource reload to build and atomically publish a fresh registry for additions, edits, renames, deletions, config paths, conventional/legacy directories, and package resources without restarting Atomic. Reloads now serialize and coalesce, reject stale session generations, retain the active registry on fatal failures, remain safe during in-flight runs, and return visible config/discovery diagnostics through both slash-command and tool surfaces while preserving valid siblings.
+- Fixed exact paused top-level live `/workflow resume <id>` targets to resume before enumerating retained completed durable history, preserving live-over-durable precedence and keeping headless command output responsive when the durable catalog is large, while exact nested child IDs remain excluded from the top-level resume namespace. Slash-dispatch tests now isolate durable state in memory and restore the backend after each test so they never read or populate a user's workflow history.
+- Isolated lazy-startup continuation tests with fresh in-memory durable backends and a completed-catalog regression guard, preventing test runs from enumerating or populating the user's real durable workflow history while preserving failed-run resource-loading coverage.
+
+## [0.9.9-alpha.3] - 2026-07-14
+
+### Fixed
+
+- Made `workflow({ action: "status", runId })` apply the same exact-or-unique-prefix contract as the other run actions. A prefix shared by multiple retained runs now returns the standard ambiguity diagnostic instead of silently inspecting the first match, so abbreviated run IDs printed by status surfaces remain safe and actionable.
+
 ## [0.9.9-alpha.2] - 2026-07-14
 
 ### Changed

package/dist/builtin/workflows/README.md

@@ -29,6 +29,8 @@ Adding workflow files under `.atomic/workflows/` (project scope) or `~/.atomic/a
 }
 ```
 
+After Atomic is running, use `/workflow reload` or the workflow tool's `reload` action to rescan all workflow sources in process. Additions, edits, renames, deletions, config changes, and package-resource changes become visible immediately to list/get/inputs/help/completion/invocation surfaces. Reload requests are serialized/coalesced and publish a complete replacement registry; an in-flight workflow keeps its original definition while later calls use the new registry. Fatal refresh failures retain the prior registry, and skipped malformed or missing resources are reported with actionable diagnostics while valid siblings remain available.
+
 ### Workflow lifecycle notifications
 
 Workflow lifecycle notices are enabled by default. They send steer prompts into the main chat/model context when a run completes, fails, or ends blocked. Awaiting-input prompts are tracked for dedupe/restore, but they do not wake the main chat agent. Configure lifecycle tracking in the same extension config file:

package/dist/builtin/workflows/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/workflows",
-  "version": "0.9.9-alpha.2",
+  "version": "0.9.9-alpha.4",
   "private": true,
   "description": "Atomic extension for multi-stage workflow authoring and execution.",
   "contributors": [

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

@@ -36,7 +36,11 @@ import {
 } 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";
+import { createWorkflowReloadCoordinator } from "./workflow-reload-coordinator.js";
+import {
+  workflowReloadDiagnostics,
+  type WorkflowReloadReport,
+} from "./workflow-reload-report.js";
 
 export interface WorkflowExtensionRuntimeState {
   persistenceRef: { current: WorkflowPersistencePort | undefined };
@@ -49,8 +53,8 @@ export interface WorkflowExtensionRuntimeState {
   runtimeForContext(ctx?: PiModelContext): ExtensionRuntime;
   resetWorkflowDiscoveryForSession(): void;
   ensureWorkflowConfigLoaded(): Promise<void>;
-  ensureWorkflowResourcesLoaded(options?: { allowInFlight?: boolean }): Promise<void>;
-  reloadWorkflowResources(options?: { allowInFlight?: boolean }): Promise<void>;
+  ensureWorkflowResourcesLoaded(): Promise<void>;
+  reloadWorkflowResources(): Promise<WorkflowReloadReport>;
   startWorkflowDiscoveryWarmup(onSettled?: () => void): void;
   runWithLifecycleSuppressedForPolicy<T>(policy: WorkflowExecutionPolicy, fn: () => Promise<T>): Promise<T>;
   setNotificationsActive(active: boolean): void;
@@ -198,10 +202,9 @@ export function createWorkflowExtensionRuntimeState(
     });
   }
 
-  let workflowReloadQueue: Promise<void> = Promise.resolve();
-
-  let lazyDiscoveryPromise: Promise<void> | null = null;
+  let lazyDiscoveryPromise: Promise<WorkflowReloadReport> | null = null;
   let workflowDiscoveryGeneration = 0;
+  let activeResourceGeneration = 0;
   function deferToMacrotask(): Promise<void> {
     return new Promise((resolve) => setImmediate(resolve));
   }
@@ -245,7 +248,6 @@ export function createWorkflowExtensionRuntimeState(
     workflowDiscoveryGeneration += 1;
     discoveryRef.current = null;
     lazyDiscoveryPromise = null;
-    workflowReloadQueue = Promise.resolve();
     rebuildRuntime(startupDiscovery.registry);
   }
 
@@ -257,13 +259,36 @@ export function createWorkflowExtensionRuntimeState(
     rebuildRuntime();
   }
 
-  function queueWorkflowResourceReload(options: { allowInFlight?: boolean } | undefined, generation: number): Promise<void> {
-    const reload = workflowReloadQueue.then(() => reloadWorkflowResourcesNow(options, generation));
-    workflowReloadQueue = reload.catch(() => {});
-    return reload;
+  function supersededReloadReport(
+    coalescedRequests: number,
+    configResult?: ConfigLoadResult,
+    result?: DiscoveryResult,
+  ): WorkflowReloadReport {
+    return {
+      outcome: "superseded",
+      generation: activeResourceGeneration,
+      workflowCount: runtimeRef.current.registry.names().length,
+      coalescedRequests,
+      diagnostics: workflowReloadDiagnostics(configResult?.diagnostics ?? [], result?.errors ?? []),
+    };
+  }
+
+  function failedReloadReport(
+    error: unknown,
+    coalescedRequests: number,
+    configResult?: ConfigLoadResult,
+  ): WorkflowReloadReport {
+    return {
+      outcome: "failed",
+      error: error instanceof Error ? error.message : String(error),
+      generation: activeResourceGeneration,
+      workflowCount: runtimeRef.current.registry.names().length,
+      coalescedRequests,
+      diagnostics: workflowReloadDiagnostics(configResult?.diagnostics ?? [], []),
+    };
   }
 
-  function trackLazyDiscovery(pending: Promise<void>): Promise<void> {
+  function trackLazyDiscovery(pending: Promise<WorkflowReloadReport>): Promise<WorkflowReloadReport> {
     lazyDiscoveryPromise = pending;
     void pending.finally(() => {
       if (lazyDiscoveryPromise === pending) lazyDiscoveryPromise = null;
@@ -271,49 +296,74 @@ export function createWorkflowExtensionRuntimeState(
     return pending;
   }
 
-  function reloadWorkflowResources(options?: { allowInFlight?: boolean }): Promise<void> {
-    const generation = workflowDiscoveryGeneration;
-    return trackLazyDiscovery(queueWorkflowResourceReload(options, generation));
+  function reloadWorkflowResources(): Promise<WorkflowReloadReport> {
+    return trackLazyDiscovery(reloadCoordinator.request(workflowDiscoveryGeneration));
   }
   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 } | undefined, generation: number): 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).`);
+  async function reloadWorkflowResourcesNow(
+    discoveryGeneration: number,
+    coalescedRequests: number,
+  ): Promise<WorkflowReloadReport> {
+    if (!isWorkflowDiscoveryCurrent(discoveryGeneration)) {
+      return supersededReloadReport(coalescedRequests);
     }
     const configResult = await loadWorkflowConfig();
-    if (!isWorkflowDiscoveryCurrent(generation)) return;
-    applyWorkflowConfig(configResult);
-    const hasGlobal = configResult.globalConfig != null;
-    const hasProject = configResult.projectConfig != null;
-    const discoveryConfig = hasGlobal || hasProject
-      ? toScopedDiscoveryConfig(configResult.globalConfig ?? null, configResult.projectConfig ?? null, { projectRoot: process.cwd() })
-      : undefined;
-    const packageWorkflowPaths = await loadPackageWorkflowPaths();
-    if (!isWorkflowDiscoveryCurrent(generation)) return;
-    const result = await discoverWorkflows({ config: discoveryConfig, packageWorkflowPaths });
-    if (!isWorkflowDiscoveryCurrent(generation)) return;
-    discoveryRef.current = result;
-    rebuildRuntime(result.registry);
+    if (!isWorkflowDiscoveryCurrent(discoveryGeneration)) {
+      return supersededReloadReport(coalescedRequests, configResult);
+    }
+    try {
+      const hasGlobal = configResult.globalConfig != null;
+      const hasProject = configResult.projectConfig != null;
+      const discoveryConfig = hasGlobal || hasProject
+        ? toScopedDiscoveryConfig(configResult.globalConfig ?? null, configResult.projectConfig ?? null, { projectRoot: process.cwd() })
+        : undefined;
+      const packageWorkflowPaths = await loadPackageWorkflowPaths();
+      if (!isWorkflowDiscoveryCurrent(discoveryGeneration)) {
+        return supersededReloadReport(coalescedRequests, configResult);
+      }
+      const result = await discoverWorkflows({ config: discoveryConfig, packageWorkflowPaths });
+      if (!isWorkflowDiscoveryCurrent(discoveryGeneration)) {
+        return supersededReloadReport(coalescedRequests, configResult, result);
+      }
+
+      // Commit config, diagnostics, and the replacement runtime synchronously,
+      // after every fallible/awaited discovery step has completed.
+      applyWorkflowConfig(configResult);
+      discoveryRef.current = result;
+      rebuildRuntime(result.registry);
+      activeResourceGeneration += 1;
+      return {
+        outcome: "applied",
+        generation: activeResourceGeneration,
+        workflowCount: result.registry.names().length,
+        coalescedRequests,
+        diagnostics: workflowReloadDiagnostics(configResult.diagnostics, result.errors),
+      };
+    } catch (error) {
+      return failedReloadReport(error, coalescedRequests, configResult);
+    }
   }
 
-  async function ensureWorkflowResourcesLoaded(options?: { allowInFlight?: boolean }): Promise<void> {
+  const reloadCoordinator = createWorkflowReloadCoordinator(async (discoveryGeneration, coalescedRequests) => {
+    try {
+      return await reloadWorkflowResourcesNow(discoveryGeneration, coalescedRequests);
+    } catch (error) {
+      return failedReloadReport(error, coalescedRequests);
+    }
+  });
+
+  async function ensureWorkflowResourcesLoaded(): Promise<void> {
     while (!pi.disableAsyncDiscovery && discoveryRef.current === null) {
-      const generation = workflowDiscoveryGeneration;
-      const pending = lazyDiscoveryPromise ?? trackLazyDiscovery(
-        queueWorkflowResourceReload({ allowInFlight: options?.allowInFlight ?? true }, generation),
-      );
-      await pending;
-      if (!isWorkflowDiscoveryCurrent(generation)) continue;
-      if (discoveryRef.current === null) {
-        lazyDiscoveryPromise = null;
-      }
+      const discoveryGeneration = workflowDiscoveryGeneration;
+      const pending = lazyDiscoveryPromise
+        ?? trackLazyDiscovery(reloadCoordinator.request(discoveryGeneration));
+      const report = await pending;
+      if (report.outcome === "failed") throw new Error(report.error);
+      if (!isWorkflowDiscoveryCurrent(discoveryGeneration)) continue;
+      if (discoveryRef.current === null) lazyDiscoveryPromise = null;
     }
   }
 
@@ -321,10 +371,14 @@ export function createWorkflowExtensionRuntimeState(
     if (pi.disableAsyncDiscovery || discoveryRef.current !== null || lazyDiscoveryPromise !== null) return;
     const notificationStart = notificationGeneration;
     const discoveryStart = workflowDiscoveryGeneration;
-    const pending = (async () => {
+    const pending = (async (): Promise<WorkflowReloadReport> => {
       await deferToMacrotask();
-      if (!isWorkflowDiscoveryCurrent(discoveryStart)) return;
-      await queueWorkflowResourceReload({ allowInFlight: true }, discoveryStart);
+      if (!isWorkflowDiscoveryCurrent(discoveryStart)) {
+        return supersededReloadReport(1);
+      }
+      const report = await reloadCoordinator.request(discoveryStart);
+      if (report.outcome === "failed") throw new Error(report.error);
+      return report;
     })();
     lazyDiscoveryPromise = pending;
     const isCurrentWarmup = (): boolean => lazyDiscoveryPromise === pending

package/dist/builtin/workflows/src/extension/render-result.ts

@@ -16,6 +16,7 @@ import type { WorkflowDetails } from "../shared/types.js";
 import type { RunDetail } from "../runs/background/status.js";
 import { renderInputsSchema } from "../shared/render-inputs-schema.js";
 import { renderStatusList } from "../tui/status-list.js";
+import type { WorkflowReloadReport } from "./workflow-reload-report.js";
 import { renderRunDetail } from "../tui/run-detail.js";
 import { renderWorkflowList } from "../tui/workflow-list.js";
 import { deriveGraphTheme } from "../tui/graph-theme.js";
@@ -23,6 +24,7 @@ import { renderDispatchConfirm } from "../tui/dispatch-confirm.js";
 import type { WorkflowInputValues, WorkflowOutputValues } from "../shared/types.js";
 import { renderRoundedBox } from "../tui/chat-surface.js";
 import { truncateToWidth } from "../tui/text-helpers.js";
+import { wrapTextWithAnsi } from "@earendil-works/pi-tui";
 
 // ---------------------------------------------------------------------------
 // Result variants
@@ -138,7 +140,7 @@ type TranscriptResult = {
 };
 type SendResult = { action: "send"; runId: string; stageId: string; delivery: string; status: "ok" | "noop"; message: string };
 type PauseResult = { action: "pause"; runId: string; status: string; message: string };
-type ReloadResult = { action: "reload"; status: "ok" | "noop"; message: string };
+type ReloadResult = WorkflowReloadReport & { action: "reload"; status: "ok" | "noop"; message: string };
 type InterruptResult = { action: "interrupt"; runId: string; status: string; message: string };
 type KillResult = { action: "kill"; runId: string; status: string; message: string };
 type ResumeResult = { action: "resume"; runId: string; status: string; message: string };
@@ -201,6 +203,13 @@ function fitLine(line: string, width?: number): string {
   return truncateToWidth(line, width, "…");
 }
 
+function noticeBodyLines(message: string, width?: number): string[] {
+  return message.split(/\r?\n/).flatMap((line) => {
+    if (line.length === 0 || width === undefined || width <= 0) return [line];
+    return wrapTextWithAnsi(line, width);
+  }).map((line) => ` ${line} `);
+}
+
 function renderNotice(
   title: string,
   message: string,
@@ -212,7 +221,7 @@ function renderNotice(
   const contentWidth = width && width > 0 ? Math.max(1, width - 4) : undefined;
   return renderRoundedBox({
     title,
-    bodyLines: [` ${fitLine(message, contentWidth)} `],
+    bodyLines: noticeBodyLines(message, contentWidth),
     theme,
     width,
   });

package/dist/builtin/workflows/src/extension/workflow-command-registration.ts

@@ -23,22 +23,25 @@ import {
   type WorkflowCommandHandler,
   type WorkflowCommandOutputDetails,
 } from "./workflow-command-utils.js";
-import { emitTerminalRunDetailSurface, formatWorkflowResourceLoadWarning } from "./workflow-command-surfaces.js";
+import {
+  emitTerminalRunDetailSurface,
+  formatWorkflowReloadReport,
+  formatWorkflowResourceLoadWarning,
+} from "./workflow-command-surfaces.js";
 import { handleRunControlCommand, type WorkflowRunControlDeps } from "./workflow-run-control-command.js";
 import { workflowPolicyFromContext } from "./workflow-policy.js";
 import {
-  inFlightRunCount,
-  reloadBlockedMessage,
   reloadFailureMessage,
   resolveRunIdPrefix,
   overlaySurfaceFromContext,
 } from "./workflow-targets.js";
+import { normalizeWorkflowReloadReport, type WorkflowReloadReport } from "./workflow-reload-report.js";
 
 export interface WorkflowSlashCommandDeps {
   runtimeProxy: ExtensionRuntime;
   runtimeForContext: (ctx?: PiCommandContext) => ExtensionRuntime;
   overlay: GraphOverlayPort;
-  reloadWorkflowResources: () => Promise<void> | void;
+  reloadWorkflowResources: () => Promise<WorkflowReloadReport | void> | void;
   ensureWorkflowResourcesLoaded: () => Promise<void> | void;
   runWithLifecycleSuppressedForPolicy: <T>(
     policy: WorkflowExecutionPolicy,
@@ -141,11 +144,11 @@ async function workflowSlashHandler(
     return;
   }
   if (subcommand === "reload") {
-    const activeRuns = inFlightRunCount();
-    if (activeRuns > 0) return fail(reloadBlockedMessage(activeRuns));
     try {
-      await deps.reloadWorkflowResources();
-      print("Reloaded workflow resources.");
+      const report = normalizeWorkflowReloadReport(await deps.reloadWorkflowResources());
+      const message = formatWorkflowReloadReport(report);
+      if (report.outcome === "applied") print(message);
+      else fail(message);
     } catch (error) {
       fail(reloadFailureMessage(error));
     }

package/dist/builtin/workflows/src/extension/workflow-command-surfaces.ts

@@ -7,6 +7,7 @@ import type { DiscoveryResult } from "./discovery.js";
 import type { WorkflowToolResult } from "./render-result.js";
 import type { ExtensionAPI } from "./public-types.js";
 import { isRunStatus } from "./workflow-targets.js";
+import type { WorkflowReloadReport } from "./workflow-reload-report.js";
 
 function fallbackRunDetailFromResult(
   workflowName: string,
@@ -54,6 +55,28 @@ export function formatWorkflowResourceLoadWarning(error: unknown): string {
     "Using the currently loaded workflow registry; run `/workflow reload` after fixing the issue.",
   ].join("\n");
 }
+
+export function formatWorkflowReloadReport(report: WorkflowReloadReport, reason?: string): string {
+  const reasonSuffix = reason?.trim() ? ` (${reason.trim()})` : "";
+  const legacySuccess = report.generation === 0 && report.workflowCount === 0 && report.diagnostics.length === 0;
+  const headline = report.outcome === "applied"
+    ? legacySuccess
+      ? `Reloaded workflow resources${reasonSuffix}.`
+      : `Reloaded workflow resources${reasonSuffix}. ${report.workflowCount} workflow(s), generation ${report.generation}.`
+    : report.outcome === "failed"
+      ? `Workflow resources could not be refreshed; the current registry was retained: ${report.error}`
+      : "Workflow reload was superseded by a newer session; no stale resources were applied.";
+  if (report.diagnostics.length === 0) return headline;
+
+  const lines = report.diagnostics.map((diagnostic) =>
+    `- [${diagnostic.level} ${diagnostic.code}] ${diagnostic.source ?? `workflow ${diagnostic.phase}`}: ${diagnostic.message}`
+  );
+  return [
+    headline,
+    `Workflow discovery diagnostics (${report.diagnostics.length}): some resources were skipped or need attention.`,
+    ...lines,
+  ].join("\n");
+}
 export function formatStartupDiagnostics(
   configResult: ConfigLoadResult | null,
   discoveryResult: DiscoveryResult | null,

package/dist/builtin/workflows/src/extension/workflow-reload-coordinator.ts

@@ -0,0 +1,66 @@
+import type { WorkflowReloadReport } from "./workflow-reload-report.js";
+
+type ReloadBatch = {
+  readonly discoveryGeneration: number;
+  requestCount: number;
+  readonly promise: Promise<WorkflowReloadReport>;
+  readonly resolve: (report: WorkflowReloadReport) => void;
+  readonly reject: (error: Error) => void;
+};
+
+export interface WorkflowReloadCoordinator {
+  request(discoveryGeneration: number): Promise<WorkflowReloadReport>;
+}
+
+function createBatch(discoveryGeneration: number): ReloadBatch {
+  let resolve: (report: WorkflowReloadReport) => void = () => undefined;
+  let reject: (error: Error) => void = () => undefined;
+  const promise = new Promise<WorkflowReloadReport>((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise;
+    reject = (error) => rejectPromise(error);
+  });
+  return { discoveryGeneration, requestCount: 0, promise, resolve, reject };
+}
+
+/**
+ * Runs one reload at a time. Requests coalesce only with the latest queued pass
+ * from the same session generation; generation boundaries remain ordered.
+ */
+export function createWorkflowReloadCoordinator(
+  reload: (discoveryGeneration: number, coalescedRequests: number) => Promise<WorkflowReloadReport>,
+): WorkflowReloadCoordinator {
+  const pending: ReloadBatch[] = [];
+  let draining = false;
+
+  const drain = async (): Promise<void> => {
+    if (draining) return;
+    draining = true;
+    try {
+      while (pending.length > 0) {
+        const batch = pending.shift()!;
+        try {
+          const report = await reload(batch.discoveryGeneration, batch.requestCount);
+          batch.resolve(report);
+        } catch (error) {
+          batch.reject(error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+    } finally {
+      draining = false;
+      if (pending.length > 0) void drain();
+    }
+  };
+
+  return {
+    request(discoveryGeneration): Promise<WorkflowReloadReport> {
+      let batch = pending.at(-1);
+      if (batch?.discoveryGeneration !== discoveryGeneration) {
+        batch = createBatch(discoveryGeneration);
+        pending.push(batch);
+      }
+      batch.requestCount += 1;
+      queueMicrotask(() => void drain());
+      return batch.promise;
+    },
+  };
+}

package/dist/builtin/workflows/src/extension/workflow-reload-report.ts

@@ -0,0 +1,39 @@
+import type { ConfigDiagnostic } from "./config-loader.js";
+import type { DiscoveryDiagnostic } from "./discovery.js";
+
+export type WorkflowReloadDiagnostic =
+  | (ConfigDiagnostic & { readonly phase: "config" })
+  | (DiscoveryDiagnostic & { readonly phase: "discovery" });
+
+type WorkflowReloadReportState = {
+  readonly generation: number;
+  readonly workflowCount: number;
+  readonly coalescedRequests: number;
+  readonly diagnostics: WorkflowReloadDiagnostic[];
+};
+
+export type WorkflowReloadReport = WorkflowReloadReportState & (
+  | { readonly outcome: "applied" }
+  | { readonly outcome: "failed"; readonly error: string }
+  | { readonly outcome: "superseded" }
+);
+
+export function normalizeWorkflowReloadReport(report: WorkflowReloadReport | void): WorkflowReloadReport {
+  return report ?? {
+    outcome: "applied",
+    generation: 0,
+    workflowCount: 0,
+    coalescedRequests: 1,
+    diagnostics: [],
+  };
+}
+
+export function workflowReloadDiagnostics(
+  configDiagnostics: readonly ConfigDiagnostic[],
+  discoveryDiagnostics: readonly DiscoveryDiagnostic[],
+): WorkflowReloadDiagnostic[] {
+  return [
+    ...configDiagnostics.map((diagnostic) => ({ ...diagnostic, phase: "config" as const })),
+    ...discoveryDiagnostics.map((diagnostic) => ({ ...diagnostic, phase: "discovery" as const })),
+  ];
+}

package/dist/builtin/workflows/src/extension/workflow-run-control-command.ts

@@ -288,35 +288,57 @@ export async function handleRunControlCommand(
     } else if (action === "resume") {
       const backend = getDurableBackend();
       const exactBeforePreparation = store.runs().find((run) => run.id === target);
-      let durable: readonly ResumableWorkflowEntry[] = [];
-      let preparationError: string | undefined;
-      const needsDurablePreparation = exactBeforePreparation === undefined
-        || !backend.isWorkflowLoadable(exactBeforePreparation.id);
-      if (needsDurablePreparation) {
-        await ensureWorkflowResourcesVisible();
-        const runtime = deps.runtimeForContext(ctx);
-        try {
-          durable = await runtime.prepareDurableResumable(target);
-        } catch (error) {
-          preparationError = error instanceof Error ? error.message : String(error);
-        }
-      }
-      const loadableRuns = topLevelWorkflowRuns(store.runs()).filter((run) => backend.isWorkflowLoadable(run.id));
-      const combined = resolveWorkflowResumeTarget(target, loadableRuns, durable, backend.listCompletedWorkflows());
-      if (combined.kind === "ambiguous") {
-        fail(`Ambiguous workflow prefix "${target}" matches: ${combined.matches.map((match) => `${match.name} (${match.workflowId.slice(0, 8)})`).join(", ")}`);
+      const exactHasPausedState = exactBeforePreparation?.status === "paused"
+        || (exactBeforePreparation?.stages.some((stage) => stage.status === "paused") ?? false);
+      const exactIsActivelyRunning = exactBeforePreparation !== undefined
+        && exactBeforePreparation.endedAt === undefined
+        && exactBeforePreparation.status === "running"
+        && !exactHasPausedState
+        && exactBeforePreparation.exitReason !== "quit";
+      if (exactIsActivelyRunning) {
+        fail(`Workflow ${exactBeforePreparation.id.slice(0, 8)} is already running in this session. Attach with \`/workflow connect ${exactBeforePreparation.id.slice(0, 8)}\` instead of resuming.`);
         return true;
       }
-      if (combined.kind === "completed" || combined.kind === "durable") {
-        return await handleDurableResume(combined.workflowId, ctx, reporter, deps);
-      }
-      if (combined.kind === "live") runId = combined.workflowId;
-      else {
-        if (preparationError !== undefined) {
-          fail(`Failed to resolve workflow resume target: ${preparationError}`);
+      if (exactBeforePreparation !== undefined
+        && exactBeforePreparation.parentRunId === undefined
+        && exactHasPausedState
+        && backend.isWorkflowLoadable(exactBeforePreparation.id)) {
+        // Exact top-level live state is authoritative. Avoid scanning the
+        // potentially large completed catalog while preserving the established
+        // top-level target namespace and live-over-durable precedence.
+        runId = exactBeforePreparation.id;
+      } else {
+        let durable: readonly ResumableWorkflowEntry[] = [];
+        let preparationError: string | undefined;
+        const needsDurablePreparation = exactBeforePreparation === undefined
+          || (!backend.isWorkflowLoadable(exactBeforePreparation.id)
+            && (!exactHasPausedState || backend.hydrateResumableWorkflows !== undefined));
+        if (needsDurablePreparation) {
+          await ensureWorkflowResourcesVisible();
+          const runtime = deps.runtimeForContext(ctx);
+          try {
+            durable = await runtime.prepareDurableResumable(target);
+          } catch (error) {
+            preparationError = error instanceof Error ? error.message : String(error);
+          }
+        }
+        const loadableRuns = topLevelWorkflowRuns(store.runs()).filter((run) => backend.isWorkflowLoadable(run.id));
+        const combined = resolveWorkflowResumeTarget(target, loadableRuns, durable, backend.listCompletedWorkflows());
+        if (combined.kind === "ambiguous") {
+          fail(`Ambiguous workflow prefix "${target}" matches: ${combined.matches.map((match) => `${match.name} (${match.workflowId.slice(0, 8)})`).join(", ")}`);
           return true;
         }
-        return await handleDurableResume(target, ctx, reporter, deps);
+        if (combined.kind === "completed" || combined.kind === "durable") {
+          return await handleDurableResume(combined.workflowId, ctx, reporter, deps);
+        }
+        if (combined.kind === "live") runId = combined.workflowId;
+        else {
+          if (preparationError !== undefined) {
+            fail(`Failed to resolve workflow resume target: ${preparationError}`);
+            return true;
+          }
+          return await handleDurableResume(target, ctx, reporter, deps);
+        }
       }
     } else {
       const resolved = resolveRunIdPrefix(target);

package/dist/builtin/workflows/src/extension/workflow-targets.ts

@@ -41,23 +41,13 @@ export function topLevelExpandedSnapshots() {
   }));
 }
 
-export function reloadBlockedMessage(count = inFlightRunCount()): string {
-  return `Reload skipped: ${count} workflow run(s) still in flight. Wait for them to finish, or pause/kill them before reloading workflow resources.`;
-}
 
 export function allStageConflictMessage(action: "pause" | "interrupt" | "kill"): string {
   return `Cannot ${action} --all with a stageId; omit stageId or target a single run.`;
 }
 
-export class WorkflowReloadBlockedError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "WorkflowReloadBlockedError";
-  }
-}
 
 export function reloadFailureMessage(error: unknown): string {
-  if (error instanceof WorkflowReloadBlockedError) return error.message;
   return `Reload failed: ${error instanceof Error ? error.message : String(error)}`;
 }