@bastani/atomic 0.9.9-alpha.3 → 0.9.9

package/CHANGELOG.md

@@ -2,6 +2,45 @@
 
 ## [Unreleased]
 
+## [0.9.9] - 2026-07-15
+
+### Breaking Changes
+
+- Replaced deletion-target context compaction with durable verbatim line compaction. Legacy `context_compaction` entries are now inert archival records, so content they previously hid may re-enter context when old sessions resume; start a new conversation or compact again to establish a new boundary.
+- Removed the deprecated `contextCompact()` SDK method, `context_compact` RPC command, and `context_compaction_start`/`context_compaction_end` events. Use `compact()` and `compaction_start`/`compaction_end`.
+- Changed extension compaction hooks: `session_before_compact` now accepts `cancel` or a complete non-empty `compactedText` override instead of `deletionRequest`; `session_compact` exposes `VerbatimCompactionResult` and the saved `compactionEntry`.
+
+### Added
+
+- Added one-pass contextual line-ranking compaction: Atomic asks the active session model at its active reasoning level, through the normal session stream/provider wrapper, for one whole-region compact `{"d":[[start,end],...]}` deletion plan, then safety-normalizes ranges and mechanically reconstructs verbatim text with cumulative `(filtered N lines)` markers.
+- Added strict pi-style compaction failure semantics: oversized prompts, provider/API errors or overflow, aborts, malformed JSON, and empty/unusable ranges fail without persistence or continuation and without semantic retries, chunking, critical replans, deterministic fallback, or deterministic target correction.
+- Added durable pi-style `CompactionEntry` boundaries discriminated by `details.strategy: "verbatim-lines"`, plus resumable custom-role boundary messages and a collapsible TUI card showing retained-line and token-reduction statistics.
+- Added `pi.sendMessages()` for atomic, array-ordered custom-message admission without waiting for the resulting model turn, allowing companion extensions to keep related preludes and terminal notices contiguous without globally serializing unrelated work.
+
+### Changed
+
+- Changed `compression_ratio` to explicitly represent the fraction of compactable lines to keep. `preserve_recent` is enforced client-side, widens the tail to a user-turn start, and always protects the final logical turn. Role headers are now ordinary ranked lines; only explicit protected spans are split out of model-selected deletion ranges.
+- Simplified resume reconstruction to load the persisted compacted string followed by original messages from `firstKeptEntryId`; no deletion filters, signed-thinking repair pass, or tool dependency repair is re-derived.
+- Retuned the one-pass compaction classifier's retention guidance to surgically thin long tool results, preserve compact diagnostic/code/state anchors, prune repeated retry and superseded bodies, and treat formatting, stack position, markers, and query matches as contextual rather than hard categories.
+- Updated the Pi runtime dependency set (`@earendil-works/pi-agent-core`, `pi-ai`, and `pi-tui`) from `^0.80.6` to `^0.80.7` across Atomic and its bundled packages, with matching Bun and npm lock metadata. This inherits the upstream provider authentication, session-affinity, reasoning replay, tool-choice, model-catalog, terminal input, and prompt-cache fixes from [Pi v0.80.7](https://github.com/earendil-works/pi/releases/tag/v0.80.7) while preserving versionless `0.0.0` workspace manifests.
+- Consolidated ten closed Dependabot updates into the Pi v0.80.7 branch: `linkedom` 0.18.13, npm `ignore` 7.0.6, `@typescript/native-preview` 7.0.0-dev.20260707.2, `typebox` 1.3.6, TypeScript 7.0.2, and the native dependency refreshes documented in `@bastani/atomic-natives`; regenerated the Bun, npm, and publish shrinkwrap dependency graphs without changing workspace package versions.
+- Added an Atomic `StringEnum` export that preserves Pi's Google-compatible enum schema while bridging Pi 0.80.7's TypeBox identity to the direct TypeBox 1.3.6 types; updated bundled extension examples and documentation to use the portable export, and updated TypeScript fixture configs for TypeScript 7's removal of `baseUrl`.
+
+### Fixed
+
+- Fixed resumed sessions resurrecting records hidden by earlier Verbatim Compaction entries after later compactions changed signed-thinking turn or tool-call/result dependencies. Persisted logical deletions are now an authoritative lower bound during every context rebuild: Atomic closes unsafe replay structures by adding transient omissions instead of restoring compacted calls/results, pairs each result with its concrete call occurrence so independent exchanges may reuse an opaque call ID, leaves unrelated retained history unchanged, and keeps the append-only session file intact.
+- Fixed successful manual and automatic compaction UI refreshes to render the compacted transcript with exactly one visible `✻ Context compacted` boundary, while aborted and failed compactions remain unchanged.
+- Fixed the bundled workflows `/workflow resume` experience to mix successful completed workflows into the existing globally newest-first, deduplicated picker with green completed styling, resolve full IDs and prefixes across live, durable, and completed targets, and reopen retained stage chats for follow-up without re-running workflow code or replaying side effects. Completed durable state is retained for authoritative inspection; rows need checkpoints and at least one strictly valid retained conversation, invalid per-stage transcript paths cannot open chat, repeated inspection refreshes changed authoritative chat handles, and selector mount failures close safely. ([#1532](https://github.com/bastani-inc/atomic/issues/1532))
+- Fixed workflow-owned transcripts leaking into normal `/resume`, `-r`, `-c`, and `--continue` history by requiring complete workflow ownership markers, persisting classification in initial fork headers, inheriting it across branches, and keeping malformed legacy markers and ordinary user forks visible.
+- Preserved accepted async-child Intercom chronology across lazily activated companion extensions by atomically admitting same-child ordinary messages before pause, completion, and failure notices; unrelated children remain independent and ask/reply behavior is unchanged ([#1802](https://github.com/bastani-inc/atomic/issues/1802)).
+- Fixed in-process workflow reload to atomically publish freshly rescanned project, user, legacy, configured, and package workflow resources across list/get/inputs/help/completion/invocation surfaces. Overlapping requests are serialized and coalesced, stale session generations cannot overwrite current state, fatal refresh failures retain the prior registry, and reload no longer blocks or changes workflows already in flight. `/workflow reload` and the workflow tool now include actionable per-resource diagnostics instead of reporting bare success when malformed or missing resources were skipped.
+
+## [0.9.9-alpha.4] - 2026-07-15
+
+### Fixed
+
+- Fixed in-process workflow reload to atomically publish freshly rescanned project, user, legacy, configured, and package workflow resources across list/get/inputs/help/completion/invocation surfaces. Overlapping requests are serialized and coalesced, stale session generations cannot overwrite current state, fatal refresh failures retain the prior registry, and reload no longer blocks or changes workflows already in flight. `/workflow reload` and the workflow tool now include actionable per-resource diagnostics instead of reporting bare success when malformed or missing resources were skipped.
+
 ## [0.9.9-alpha.3] - 2026-07-14
 
 ### Added

package/dist/builtin/cursor/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [0.9.9] - 2026-07-15
+
+### Changed
+
+- Published the stable Atomic 0.9.9 release for the Cursor provider package with its `@earendil-works/pi-ai` dependency aligned to `^0.80.7`; no functional Cursor provider source changes were made after 0.9.8.
+
+## [0.9.9-alpha.4] - 2026-07-15
+
+### Changed
+
+- Published a synchronized Atomic 0.9.9-alpha.4 prerelease for the Cursor provider package; no functional Cursor provider changes were made after 0.9.9-alpha.3.
+
 ## [0.9.9-alpha.3] - 2026-07-14
 
 ### Changed

package/dist/builtin/cursor/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/cursor",
-  "version": "0.9.9-alpha.3",
+  "version": "0.9.9",
   "private": true,
   "description": "Experimental first-party Atomic extension for Cursor OAuth, model discovery, and streaming provider registration.",
   "contributors": [
@@ -40,7 +40,7 @@
     }
   },
   "dependencies": {
-    "@bastani/atomic-natives": "0.9.9-alpha.3",
+    "@bastani/atomic-natives": "0.9.9",
     "@bufbuild/protobuf": "^2.12.1",
     "@earendil-works/pi-ai": "^0.80.7"
   }

package/dist/builtin/intercom/CHANGELOG.md

@@ -4,6 +4,24 @@ All notable changes to the `pi-intercom` extension will be documented in this fi
 
 ## [Unreleased]
 
+## [0.9.9] - 2026-07-15
+
+### Changed
+
+- Aligned the intercom extension peer dependency with `@earendil-works/pi-tui` `^0.80.7` as part of the consolidated Pi v0.80.7 dependency update; no intercom source changes were needed.
+- Updated the runtime `typebox` range to `^1.3.6`.
+
+### Fixed
+
+- Preserved per-child chronology between busy-parent Intercom messages and terminal async subagent notifications: paused, completed, and failed paths now claim pre-terminal ordinary messages from the exact child session/run in FIFO order and atomically admit the prelude plus terminal notice through the custom-message batch API. A process-local bridge complements extension-bus delivery for lazily activated companions; terminal identity deduplicates both paths even when the successful terminal dispatch has an empty prelude, while failed dispatches remain retryable and distinct resumed-run lifecycle terminals remain independent. Idle flushes use the same ordered batch admission, unrelated children remain independent, and ask/reply correlation is unchanged ([#1802](https://github.com/bastani-inc/atomic/issues/1802)).
+- Made every short session ID printed by `intercom list` directly actionable in `send`, blocking `ask`, and targeted `reply`. Target resolution now preserves exact full IDs and exact case-insensitive names before accepting unique ID prefixes, reports colliding prefixes with the matching sessions instead of guessing, resolves blocking asks to the full sender ID so threaded replies correlate correctly, and rejects short-form self-targets at both tool and broker routing boundaries.
+
+## [0.9.9-alpha.4] - 2026-07-15
+
+### Changed
+
+- Published a synchronized Atomic 0.9.9-alpha.4 prerelease for the intercom extension; no functional intercom changes were made after 0.9.9-alpha.3.
+
 ## [0.9.9-alpha.3] - 2026-07-14
 
 ### Fixed

package/dist/builtin/intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/intercom",
-  "version": "0.9.9-alpha.3",
+  "version": "0.9.9",
   "private": true,
   "description": "Atomic extension providing a private coordination channel between parent and child agent sessions. Fork of: https://github.com/nicobailon/pi-intercom",
   "contributors": [

package/dist/builtin/mcp/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.9] - 2026-07-15
+
+### Changed
+
+- Aligned the MCP extension peer dependencies with `@earendil-works/pi-ai` and `@earendil-works/pi-tui` `^0.80.7` as part of the consolidated Pi v0.80.7 dependency update; no MCP source changes were needed.
+- Updated the runtime `typebox` range to `^1.3.6`.
+
+## [0.9.9-alpha.4] - 2026-07-15
+
+### Changed
+
+- Published a synchronized Atomic 0.9.9-alpha.4 prerelease for the MCP extension; no functional MCP changes were made after 0.9.9-alpha.3.
+
 ## [0.9.9-alpha.3] - 2026-07-14
 
 ### Changed

package/dist/builtin/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/mcp",
-  "version": "0.9.9-alpha.3",
+  "version": "0.9.9",
   "private": true,
   "description": "Atomic extension that adapts MCP (Model Context Protocol) servers into the coding agent. Fork of: https://github.com/nicobailon/pi-mcp-adapter",
   "contributors": [

package/dist/builtin/subagents/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## [Unreleased]
 
+## [0.9.9] - 2026-07-15
+
+### Changed
+
+- Aligned the subagents extension peer dependencies with the `@earendil-works/pi-agent-core`, `pi-ai`, and `pi-tui` `^0.80.7` runtime set as part of the consolidated Pi v0.80.7 dependency update; no subagent source changes were needed.
+- Updated the runtime `typebox` range to `^1.3.6`.
+
+### Fixed
+
+- Fixed first-party subagent transcripts launched inside workflow stages to inherit complete workflow ownership metadata in foreground and background execution, while fork-context children also inherit classification through the branched JSONL header.
+- Preserved background async-child completion chronology with Intercom by emitting a terminal-ordering barrier and atomically batching claimed same-child messages before the completion notice, with a compatibility fallback for hosts without batched message admission.
+
+## [0.9.9-alpha.4] - 2026-07-15
+
+### Changed
+
+- Published a synchronized Atomic 0.9.9-alpha.4 prerelease for the subagents extension; no functional subagent changes were made after 0.9.9-alpha.3.
+
 ## [0.9.9-alpha.3] - 2026-07-14
 
 ### Fixed

package/dist/builtin/subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/subagents",
-  "version": "0.9.9-alpha.3",
+  "version": "0.9.9",
   "private": true,
   "description": "Atomic extension for delegating tasks to subagents with chains, parallel execution, and background runs. Fork of: https://github.com/nicobailon/pi-subagents",
   "contributors": [

package/dist/builtin/subagents/src/extension/startup-maintenance.ts

@@ -39,6 +39,7 @@ export function createSubagentStartupMaintenance(
     resultsDir: string;
     artifactCleanupDays: number;
     resultTtlMs: number;
+    scheduleMacrotask?: (task: () => void) => () => void;
   },
 ): SubagentStartupMaintenance {
   const { startResultWatcher, primeExistingResults, stopResultWatcher } = createResultWatcher(
@@ -49,7 +50,7 @@ export function createSubagentStartupMaintenance(
   );
   const cancelTasks = new Set<() => void>();
   const schedule = (task: () => void): void => {
-    const cancel = scheduleMacrotask(() => {
+    const cancel = (options.scheduleMacrotask ?? scheduleMacrotask)(() => {
       cancelTasks.delete(cancel);
       task();
     });

package/dist/builtin/web-access/CHANGELOG.md

@@ -4,6 +4,19 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.9.9] - 2026-07-15
+
+### Changed
+
+- Aligned the web-access extension peer dependency with `@earendil-works/pi-tui` `^0.80.7` as part of the consolidated Pi v0.80.7 dependency update; no web-access source changes were needed.
+- Updated `linkedom` from 0.18.12 to 0.18.13 and refreshed its selector dependency graph.
+
+## [0.9.9-alpha.4] - 2026-07-15
+
+### Changed
+
+- Published a synchronized Atomic 0.9.9-alpha.4 prerelease for the web-access extension; no functional web-access changes were made after 0.9.9-alpha.3.
+
 ## [0.9.9-alpha.3] - 2026-07-14
 
 ### Changed

package/dist/builtin/web-access/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/web-access",
-  "version": "0.9.9-alpha.3",
+  "version": "0.9.9",
   "private": true,
   "description": "Atomic extension for web search, URL fetching, GitHub repo cloning, PDF/video extraction. Fork of: https://github.com/nicobailon/pi-web-access",
   "contributors": [

package/dist/builtin/workflows/CHANGELOG.md

@@ -6,6 +6,42 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.9.9] - 2026-07-15
+
+### Changed
+
+- Hardened the shared builtin `goal`/`ralph` prompt contracts against over-implementation drift (observed in eval traces where near-perfect patches lost binary reward to a single invented strictness: returning a read-only mapping proxy where the contract said "dict", marking an optional schema field required, and rejecting duplicate aliases the task's hidden tests expected to be tolerated). The literal objective contract now states that the loud-error preference applies only to error conditions the contract enumerates and that the default for unenumerated behavior is permissive acceptance (never invent a validation error, required field, uniqueness constraint, or rejection the contract does not name); that contract-named types/shapes/formats must be produced exactly, with no defensive substitutes such as read-only proxies, frozen collections, or tuples-for-lists, because consumers may check type identity literally; and that unspecified behavior defaults to preserving input verbatim over normalizing, deduplicating, reordering, or rewriting it.
+- Extended the worker/orchestrator acceptance-matrix contract with rows for literal contract examples (checked character-for-character rather than paraphrased) and for each contract-constrained interface decision (types by identity, required-vs-optional per field, duplicate handling, ordering, raw-vs-normalized text), recording the permissive/preserving default whenever the contract leaves a decision open.
+- Added a shared `CONTRACT_FIDELITY_AUDIT` adversarial divergence pass to the Goal worker and Ralph orchestrator prompts (`<divergence_audit>`): after checks are green and before claiming readiness, re-read each contract clause asking what plausible independent check would fail the implementation, probing the recurring divergence categories — type-identity assertions, optional fields omitted, duplicated/aliased inputs, ordering assumptions, verbatim-vs-normalized text, and any raised error the contract does not enumerate. Forked continuation prompts reference the audit in their established-guidance pointer.
+- Made Goal and Ralph reviewers hunt over-implementation as seriously as gaps via a shared `REVIEWER_OVERIMPLEMENTATION_GUARD`: validation errors, required fields, uniqueness/format constraints, immutability wrappers, or normalization the contract does not require are `required_by_objective` defects, and reviewers must probe at least one contract-permitted input the worker's own tests do not exercise before approving. The independent-verification contract and reviewer action items now include contract-permitted-input and type/shape/text-identity probes alongside the existing boundary/edge/negative probes.
+- Added a shared Intercom coordination protocol to every concurrent builtin Goal and Ralph reviewer prompt: reviewers now check Intercom and discover same-run siblings at review start, communicate validation plans and ownership, serialize conflicting shared-checkout or shared-environment checks, announce starts/completions/releases, share reusable execution evidence, and retain independent patch analysis and verdicts ([#1803](https://github.com/bastani-inc/atomic/issues/1803)).
+- Aligned the workflows extension peer dependency with `@earendil-works/pi-tui` `^0.80.7` as part of the consolidated Pi v0.80.7 dependency update; no workflow source changes were needed.
+- Updated the runtime `typebox` range to `^1.3.6`.
+
+### Fixed
+
+- Fixed the builtin `open-claude-design` artifact directory fallback to use a per-user OS tmpdir namespace (`open-claude-design-<username>`), preventing `EACCES` failures on shared hosts where another user already owns the plain `<tmpdir>/open-claude-design` directory. The legacy shared path remains a secondary fallback, and the last-resort synthesized path now also uses the per-user namespace so best-effort feedback persistence can actually create it.
+- Prevented the synced Impeccable fixture's nested `git init` from inheriting hook-local Git repository variables and corrupting a linked repository's shared `core.worktree`. Runner-managed reusable worktrees now remap propagated invoking-repository `cwd` values and relative direct outputs into the selected worktree; reject blank, self, nested, foreign, lexical-escape, symlink-escape, and changed cached targets before opening a later session; key cached identity by canonical repository/target across equivalent path and ref spellings; revalidate newly created targets; and expose clearer workflow tool guidance/schema descriptions so natural-language worktree requests cannot be mistaken for runtime configuration. Temporary direct task and parallel worktrees also derive omitted/relative task cwd values from the runner invocation cwd and clean up when startup fails before their workflow callback, while relative outputs are persisted to stable runner-owned artifacts before cleanup and reject parent traversal, child symlink escapes, or a linked trusted artifact root across direct, parallel, and chain modes; blank `chainDir` values no longer bypass reusable-worktree output routing.
+- Fixed the active Workflow Orchestrator graph pane to pan left and right for horizontal trackpad and terminal mouse-wheel events while preserving vertical wheel panning and pane-local input capture ([#1756](https://github.com/bastani-inc/atomic/issues/1756)).
+- Fixed `/workflow resume` so its single globally newest-first, deduplicated picker includes current paused or recoverably failed and durable resumable entries alongside authoritative successful completed workflows. Completed rows use green `✓ completed` styling and open an immutable detail/chat snapshot with transcript follow-up conversation, without durable re-dispatch or workflow side-effect replay. Full IDs take precedence and prefixes resolve across the mixed namespace; completed rows require checkpoints and at least one strictly valid retained conversation, invalid per-stage paths cannot attach chat, repeated inspection refreshes changed authoritative chat handles, and selector mount failures close safely. Existing resumable workflow and ordinary internal-session history behavior remains on the original paths. ([#1532](https://github.com/bastani-inc/atomic/issues/1532))
+- Fixed `/workflow resume` to deduplicate live and durable choices with live-row precedence, then globally sort the combined selector by latest run/stage or durable-update activity, newest first, with deterministic workflow-id tie-breaking independent of source enumeration order ([#1714](https://github.com/bastani-inc/atomic/issues/1714)).
+- Fixed startup and restored-session workflow notices to use the authoritative durable resume catalog's status/progress rules: failed and blocked root workflows are advertised unless explicitly marked `resumable: false`, running and paused workflows require durable progress, nested child workflows and stale cache-only entries are excluded, and legacy direct or payload-wrapped checkpoint entries are parsed correctly.
+- Fixed durable mid-stage workflow resume to refresh pause-adjusted active stage/task duration at repeated session checkpoints, preserve it through file and DBOS hydration, and continue accumulating it across repeated process-boundary resumes without resetting the baseline when concurrent tracked stage calls begin, double-counting earlier pauses, changing replay identity, or re-running completed side effects ([#1713](https://github.com/bastani-inc/atomic/issues/1713)).
+- Fixed incompatible durable workflow records appearing as loadable resume targets by moving file state, DBOS metadata/checkpoint envelopes, and JSONL discovery caches to one shared v2 format contract; exact legacy v1 file and DBOS rows are now suppressed and permanently deleted (including DBOS checkpoint-prefix records), with per-workflow deletion and loadability queries implemented across durable backends and safely isolated from child scopes. Resume selectors, explicit target resolution, completed catalogs, restored-session notices, status/listing state, cache merges, and live resume paths accept only loadable current-format rows; compatibility preparation purges matching restored/live snapshots even when DBOS deletion fails, so failure fallbacks cannot resurrect or dispatch them. Repeated discovery is idempotent, deletion failures stay hidden and retry later, compatible and newly registered runs plus unmarked raw DBOS checkpoint outputs remain supported, and malformed, unavailable, future-version, or unsupported marked-envelope data is conservatively preserved and hidden rather than overwritten, reinterpreted, or broadly deleted.
+- Fixed workflow stage session classification so fresh and fork-context stages persist complete ownership metadata before their transcripts can enter normal resume history, including custom session directories.
+- 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.
+- 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.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

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.3",
+  "version": "0.9.9",
   "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)}`;
 }
 

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

@@ -18,18 +18,17 @@ import {
   allStageConflictMessage,
   ambiguousRunMessage,
   formatAlreadyEndedRetainedMessage,
-  inFlightRunCount,
-  reloadBlockedMessage,
   reloadFailureMessage,
   resolveToolRunTarget,
   resolveToolStageTarget,
   stageFailureMessage,
 } from "./workflow-targets.js";
-import { formatWorkflowResourceLoadWarning } from "./workflow-command-surfaces.js";
+import { formatWorkflowReloadReport, formatWorkflowResourceLoadWarning } from "./workflow-command-surfaces.js";
+import { normalizeWorkflowReloadReport, type WorkflowReloadReport } from "./workflow-reload-report.js";
 
 export interface WorkflowControlActionDeps {
   getPersistence: () => WorkflowPersistencePort | undefined;
-  reloadWorkflowResources: () => Promise<void> | void;
+  reloadWorkflowResources: () => Promise<WorkflowReloadReport | void> | void;
   getRuntime: () => ExtensionRuntime;
   policy: WorkflowExecutionPolicy;
   ensureWorkflowResourcesLoaded: () => Promise<void> | void;
@@ -71,22 +70,27 @@ export async function workflowReloadAction(
   args: WorkflowToolArgs,
   deps: Pick<WorkflowControlActionDeps, "reloadWorkflowResources">,
 ): Promise<WorkflowToolResult> {
-  const activeRuns = inFlightRunCount();
-  if (activeRuns > 0) {
-    return { action: "reload", status: "noop", message: reloadBlockedMessage(activeRuns) };
-  }
   try {
-    await deps.reloadWorkflowResources();
+    const report = normalizeWorkflowReloadReport(await deps.reloadWorkflowResources());
+    return {
+      action: "reload",
+      status: report.outcome === "applied" ? "ok" : "noop",
+      message: formatWorkflowReloadReport(report, args.reason),
+      ...report,
+    };
   } catch (error) {
-    return { action: "reload", status: "noop", message: reloadFailureMessage(error) };
+    return {
+      action: "reload",
+      status: "noop",
+      message: reloadFailureMessage(error),
+      outcome: "failed",
+      error: error instanceof Error ? error.message : String(error),
+      generation: 0,
+      workflowCount: 0,
+      coalescedRequests: 1,
+      diagnostics: [],
+    };
   }
-  return {
-    action: "reload",
-    status: "ok",
-    message: args.reason?.trim()
-      ? `Reloaded workflow resources (${args.reason.trim()}).`
-      : "Reloaded workflow resources.",
-  };
 }
 
 export function workflowKillAction(

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

@@ -32,11 +32,12 @@ import {
   topLevelExpandedSnapshots,
 } from "./workflow-targets.js";
 import { formatWorkflowResourceLoadWarning } from "./workflow-command-surfaces.js";
+import type { WorkflowReloadReport } from "./workflow-reload-report.js";
 
 export function makeExecuteWorkflowTool(
   runtime: ExtensionRuntime | ((ctx: PiExecuteContext) => ExtensionRuntime),
   getPersistence: () => WorkflowPersistencePort | undefined,
-  reloadWorkflowResources: () => Promise<void> | void,
+  reloadWorkflowResources: () => Promise<WorkflowReloadReport | void> | void,
   ensureWorkflowResourcesLoaded: () => Promise<void> | void = () => {},
 ): (args: WorkflowToolArgs, ctx: PiExecuteContext) => Promise<WorkflowToolResult> {
   return async function executeWorkflowTool(

package/docs/workflows.md

@@ -781,6 +781,14 @@ export const tableSelectorFactory: WorkflowCustomUiFactory<{ id: string; name: s
 
 Workflow files are loaded via [jiti](https://github.com/unjs/jiti), so TypeScript works without compilation.
 
+## Reloading workflow resources
+
+Run `/workflow reload` after adding, editing, renaming, or deleting workflow modules or changing workflow config. Reload rescans project and user conventional directories, legacy `.pi` locations, configured file/directory paths, and package resources without restarting Atomic. The workflow tool's `reload` action uses the same in-process path.
+
+Reload builds a complete replacement registry before publishing it. Concurrent requests are serialized and coalesced, stale discovery from an earlier session cannot overwrite newer state, and a fatal refresh failure retains the previous registry. Reload is safe while workflows are running: existing runs keep the definition and runtime snapshot they started with, while subsequent list/get/inputs/help/completion/invocation calls use the newly published registry.
+
+A successful rescan may still contain per-resource diagnostics. Both reload surfaces now show `CONFIG_INVALID`, `IMPORT_FAILED`, `INVALID_DEFINITION`, `PATH_NOT_FOUND`, and duplicate-name diagnostics instead of reporting bare success while silently skipping a resource. Valid sibling workflows remain available. Fix the reported source/path and reload again; no process restart is required.
+
 ## Workflow Configuration
 
 Configured workflow paths live in workflow extension config. Project config paths are relative to the project root. Global config paths are relative to `~/.atomic/agent`.
@@ -1107,7 +1115,7 @@ When Atomic starts with an existing session or resumes one, it shows an informat
 /workflow resume <workflow-id-or-prefix> # Resume unfinished work or open completed detail/chat
 ```
 
-Explicit full IDs take precedence, while prefixes resolve across live, resumable durable, and completed targets as one namespace. Ambiguous prefixes use the existing-style ambiguity diagnostic. A completed backend row with no checkpoints or no usable retained stage conversation is hidden from the picker; an explicit target reports that it is stale or missing required durable checkpoint/session data. A completed run remains inspectable when at least one stage has a usable transcript; missing, empty, directory, context-empty, or partially malformed transcript paths are omitted from stage chat attachment. Validation uses the final retained transcript for a repeated stage replay key, so an obsolete superseded checkpoint path does not hide an otherwise valid completed run. Reopening inspection refreshes a changed authoritative retained-chat handle. Session-cache-only rows are likewise hidden because the backend is authoritative. Cancelled, killed, non-resumable failed, and other terminal non-success states are never added. Normal `/resume`, `atomic -r`, and `--continue` behavior for internal workflow stage sessions is unchanged.
+Explicit full IDs take precedence, while prefixes resolve across top-level live, resumable durable, and completed targets as one namespace. An exact loadable paused top-level live target resumes directly from in-session state without enumerating the durable completed-history catalog; this keeps explicit live resume responsive even when retained durable history is large and preserves live-over-durable precedence for duplicate IDs. Nested child runs remain excluded from this top-level target namespace even when addressed by an exact ID. Prefixes and other targets continue through the combined catalog so ambiguity and completed-inspection behavior remain unchanged. Ambiguous prefixes use the existing-style ambiguity diagnostic. A completed backend row with no checkpoints or no usable retained stage conversation is hidden from the picker; an explicit target reports that it is stale or missing required durable checkpoint/session data. A completed run remains inspectable when at least one stage has a usable transcript; missing, empty, directory, context-empty, or partially malformed transcript paths are omitted from stage chat attachment. Validation uses the final retained transcript for a repeated stage replay key, so an obsolete superseded checkpoint path does not hide an otherwise valid completed run. Reopening inspection refreshes a changed authoritative retained-chat handle. Session-cache-only rows are likewise hidden because the backend is authoritative. Cancelled, killed, non-resumable failed, and other terminal non-success states are never added. Normal `/resume`, `atomic -r`, and `--continue` behavior for internal workflow stage sessions is unchanged.
 
 ### Cancellation, failure, and retry semantics
 

package/npm-shrinkwrap.json

@@ -1,15 +1,15 @@
 {
 	"name": "@bastani/atomic",
-	"version": "0.9.9-alpha.3",
+	"version": "0.9.9",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "@bastani/atomic",
-			"version": "0.9.9-alpha.3",
+			"version": "0.9.9",
 			"license": "MIT",
 			"dependencies": {
-				"@bastani/atomic-natives": "0.9.9-alpha.3",
+				"@bastani/atomic-natives": "0.9.9",
 				"@bufbuild/protobuf": "^2.12.1",
 				"@earendil-works/pi-agent-core": "^0.80.7",
 				"@earendil-works/pi-ai": "^0.80.7",
@@ -515,16 +515,16 @@
 			}
 		},
 		"node_modules/@bastani/atomic-natives": {
-			"version": "0.9.9-alpha.3",
-			"resolved": "https://registry.npmjs.org/@bastani/atomic-natives/-/atomic-natives-0.9.9-alpha.3.tgz",
+			"version": "0.9.9",
+			"resolved": "https://registry.npmjs.org/@bastani/atomic-natives/-/atomic-natives-0.9.9.tgz",
 			"license": "MIT",
 			"optionalDependencies": {
-				"@bastani/atomic-natives-darwin-arm64": "0.9.9-alpha.3",
-				"@bastani/atomic-natives-darwin-x64": "0.9.9-alpha.3",
-				"@bastani/atomic-natives-linux-arm64-gnu": "0.9.9-alpha.3",
-				"@bastani/atomic-natives-linux-x64-gnu": "0.9.9-alpha.3",
-				"@bastani/atomic-natives-win32-arm64-msvc": "0.9.9-alpha.3",
-				"@bastani/atomic-natives-win32-x64-msvc": "0.9.9-alpha.3"
+				"@bastani/atomic-natives-darwin-arm64": "0.9.9",
+				"@bastani/atomic-natives-darwin-x64": "0.9.9",
+				"@bastani/atomic-natives-linux-arm64-gnu": "0.9.9",
+				"@bastani/atomic-natives-linux-x64-gnu": "0.9.9",
+				"@bastani/atomic-natives-win32-arm64-msvc": "0.9.9",
+				"@bastani/atomic-natives-win32-x64-msvc": "0.9.9"
 			},
 			"engines": {
 				"bun": ">=1.3.14",
@@ -532,8 +532,8 @@
 			}
 		},
 		"node_modules/@bastani/atomic-natives-darwin-arm64": {
-			"version": "0.9.9-alpha.3",
-			"resolved": "https://registry.npmjs.org/@bastani/atomic-natives-darwin-arm64/-/atomic-natives-darwin-arm64-0.9.9-alpha.3.tgz",
+			"version": "0.9.9",
+			"resolved": "https://registry.npmjs.org/@bastani/atomic-natives-darwin-arm64/-/atomic-natives-darwin-arm64-0.9.9.tgz",
 			"license": "MIT",
 			"os": [
 				"darwin"
@@ -544,8 +544,8 @@
 			"optional": true
 		},
 		"node_modules/@bastani/atomic-natives-darwin-x64": {
-			"version": "0.9.9-alpha.3",
-			"resolved": "https://registry.npmjs.org/@bastani/atomic-natives-darwin-x64/-/atomic-natives-darwin-x64-0.9.9-alpha.3.tgz",
+			"version": "0.9.9",
+			"resolved": "https://registry.npmjs.org/@bastani/atomic-natives-darwin-x64/-/atomic-natives-darwin-x64-0.9.9.tgz",
 			"license": "MIT",
 			"os": [
 				"darwin"
@@ -556,8 +556,8 @@
 			"optional": true
 		},
 		"node_modules/@bastani/atomic-natives-linux-arm64-gnu": {
-			"version": "0.9.9-alpha.3",
-			"resolved": "https://registry.npmjs.org/@bastani/atomic-natives-linux-arm64-gnu/-/atomic-natives-linux-arm64-gnu-0.9.9-alpha.3.tgz",
+			"version": "0.9.9",
+			"resolved": "https://registry.npmjs.org/@bastani/atomic-natives-linux-arm64-gnu/-/atomic-natives-linux-arm64-gnu-0.9.9.tgz",
 			"license": "MIT",
 			"os": [
 				"linux"
@@ -571,8 +571,8 @@
 			"optional": true
 		},
 		"node_modules/@bastani/atomic-natives-linux-x64-gnu": {
-			"version": "0.9.9-alpha.3",
-			"resolved": "https://registry.npmjs.org/@bastani/atomic-natives-linux-x64-gnu/-/atomic-natives-linux-x64-gnu-0.9.9-alpha.3.tgz",
+			"version": "0.9.9",
+			"resolved": "https://registry.npmjs.org/@bastani/atomic-natives-linux-x64-gnu/-/atomic-natives-linux-x64-gnu-0.9.9.tgz",
 			"license": "MIT",
 			"os": [
 				"linux"
@@ -586,8 +586,8 @@
 			"optional": true
 		},
 		"node_modules/@bastani/atomic-natives-win32-arm64-msvc": {
-			"version": "0.9.9-alpha.3",
-			"resolved": "https://registry.npmjs.org/@bastani/atomic-natives-win32-arm64-msvc/-/atomic-natives-win32-arm64-msvc-0.9.9-alpha.3.tgz",
+			"version": "0.9.9",
+			"resolved": "https://registry.npmjs.org/@bastani/atomic-natives-win32-arm64-msvc/-/atomic-natives-win32-arm64-msvc-0.9.9.tgz",
 			"license": "MIT",
 			"os": [
 				"win32"
@@ -598,8 +598,8 @@
 			"optional": true
 		},
 		"node_modules/@bastani/atomic-natives-win32-x64-msvc": {
-			"version": "0.9.9-alpha.3",
-			"resolved": "https://registry.npmjs.org/@bastani/atomic-natives-win32-x64-msvc/-/atomic-natives-win32-x64-msvc-0.9.9-alpha.3.tgz",
+			"version": "0.9.9",
+			"resolved": "https://registry.npmjs.org/@bastani/atomic-natives-win32-x64-msvc/-/atomic-natives-win32-x64-msvc-0.9.9.tgz",
 			"license": "MIT",
 			"os": [
 				"win32"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/atomic",
-  "version": "0.9.9-alpha.3",
+  "version": "0.9.9",
   "description": "Atomic coding agent CLI with read, bash, edit, write tools and session management",
   "type": "module",
   "atomicConfig": {
@@ -77,7 +77,7 @@
     "prepublishOnly": "bun run clean && bun run build && bun run shrinkwrap"
   },
   "dependencies": {
-    "@bastani/atomic-natives": "0.9.9-alpha.3",
+    "@bastani/atomic-natives": "0.9.9",
     "@bufbuild/protobuf": "^2.12.1",
     "@earendil-works/pi-agent-core": "^0.80.7",
     "@earendil-works/pi-ai": "^0.80.7",