@bastani/atomic 0.9.11-alpha.7 → 0.9.11-alpha.9

package/CHANGELOG.md

@@ -2,6 +2,104 @@
 
 ## [Unreleased]
 
+## [0.9.11-alpha.9] - 2026-08-01
+
+### Breaking Changes
+
+- Adopted pi 0.83.0 (`@earendil-works/pi-agent-core`, `@earendil-works/pi-ai`, `@earendil-works/pi-tui` at `^0.83.0`), which moves the bundled TypeBox to 1.3.7. TypeBox 1.3.7 **removes seven deprecated APIs**. Atomic inherits the removal exactly as upstream shipped it and does not provide a compatibility shim, so an extension, skill, workflow, or MCP schema that still calls one of these will now fail to compile and to run. Atomic's own sources use none of them; the migration below is for package authors. TypeBox 1.3.7 also fixes compiled validation of nullable array tool arguments, and — because `typebox` is pinned to a single hoisted `1.3.7` node — an Atomic-defined tool schema and a pi-defined one now validate identically in the same process.
+
+  | Removed API | Replacement | Migration |
+  | --- | --- | --- |
+  | `Type.Options(type, options)` | `Type.With(type, options)` | Straight rename; same arguments, same result. `Options` was already an alias of `With`. |
+  | `Type.Base` | `Type.Refine()` + `Type.Unsafe()` | `class DateType extends Type.Base<Date> { Check(value) { return value instanceof Date } }` becomes `const DateType = Type.Refine(Type.Unsafe<Date>({}), (value) => value instanceof Date)`. Class-instance schemas lost their prototype methods through TypeBox's clone/spread compositor, which is why the class form is gone. |
+  | `Type.Promise(item)` | none | Model the resolved value directly and validate after `await`, or hold the slot with `Type.Unsafe<Promise<T>>({})` when a schema entry is required. A promise was never checkable without settling it. |
+  | `Type.Awaited(type)` | none | Nothing is left to unwrap once `Type.Promise` is gone: use the resolved type itself where `Type.Awaited(Type.Promise(T))` appeared. |
+  | `Type.Iterator(items)` | none | Validate the materialized sequence with `Type.Array(items)` after draining the iterator, or hold the slot with `Type.Unsafe<Iterable<T>>({})`. |
+  | `Type.AsyncIterator(items)` | none | Same as `Type.Iterator`: drain first and validate with `Type.Array(items)`, or use `Type.Unsafe<AsyncIterable<T>>({})`. |
+  | `Value.Mutate(current, next)` | `Value.Patch(current, Value.Diff(current, next))` | `Patch` returns a **new** value rather than assigning into `current` in place, so code that relied on `Mutate` retaining internal references as a redraw signal must now assign the result and re-read the reference. |
+
+- The RPC `login_provider` response no longer carries the API key it just stored. `RpcLoginProviderResult` dropped its `credential` member and now reports `{ provider, cancelled: false, type: "api_key", …catalog }`. The key travelled as plaintext inside a JSON line on the same stdout the credential-export door treats as the single egress, and the host had itself supplied that key through the login input form, so nothing needed it echoed back. A host that read `data.credential` should use the value it submitted; `type` confirms which kind of credential was saved.
+
+### Added
+
+- Added `ctx.scopedModels` to the extension context: the read-only list of models scoped to the current session, resolved from the `--models` flag and the `enabledModels` setting — the same set `/scoped-models` shows. It is empty when no scoping is configured. The value resolves at access time, so it follows session replacement, and under the isolated interactive engine it reflects the engine's catalogue rather than a stale host snapshot. It reports the scope and cannot widen it: `readonly` is a compile-time claim only, so both the extension context and the hand-built context that shortcut handlers receive hand back a fresh copy on every read, and an extension that mutates what it was given changes nothing. Its types are exported too — `ScopedModel` for one entry and `ExtensionScopedModels` for the accessor — from `core/extensions/types.ts` and from the package root, so an extension can name what it reads without importing an internal module. Documented in `docs/extensions.md`.
+- Added `atomic auth print-api-key` and `atomic auth print-bearer-token`, which print one configured credential for an external client. The credential goes to stdout and nothing else — warnings, provider selection, refresh notices, and help all go to stderr — so `KEY=$(atomic auth print-api-key --model gpt-5.5)` cannot capture a diagnostic. `--model` is required, so no ambient "current model" can emit a credential you did not name. `--provider` and `--model` are the only options either subcommand accepts, enforced as an allowlist over the parsed arguments rather than a list of refusals, so a path-naming flag such as `--export` or `--session-dir` is a usage error instead of a flag this path happens to ignore; there is no file or clipboard sink. When `--provider` is omitted, eligibility comes from the runtime's resolved auth type for each provider offering that model, so a credential supplied by an environment variable or a custom resolver — which `auth.json` never sees — is exported like any other, and a provider offering both an API key and OAuth is selected by whichever one a request would actually use rather than by what it supports. `print-bearer-token` refreshes a token with less than `--min-expiry` (default `30m`, accepting `ms`/`s`/`m`/`h`, in both `--min-expiry 30m` and `--min-expiry=30m` spellings) remaining; `--min-expiry` with `print-api-key` is a usage error in either spelling rather than a silent no-op, because an API key has no expiry. Failures are distinguishable by exit code: `1` usage, `2` no credential configured, `3` provider ambiguous, `4` credential kind unsupported for that provider, `5` the OAuth refresh itself failed (the only exit that promises the stored credential is untouched, because that failure happens before anything is persisted), `6` the provider cannot mint a token that lives long enough, `7` any other OAuth failure, which makes no claim about the stored credential, `8` the credential could not be written and nothing was emitted, and `9` only part of it was written and the output should be discarded. Which of those two a failed write gets is read from `process.stdout.bytesWritten` rather than guessed: nothing flushed is `8` with stdout provably empty, the whole payload flushed is exit `0` with the failure on stderr — the caller holds what it asked for — and a partial flush is `9`, the one exit whose stdout is not empty, because those bytes cannot be recalled and reporting success over a truncated secret would be worse than saying so. One function in `src/cli/credential-print.ts` is the only place in the source tree that can read the credential wrapper and write it to stdout; a test enumerates every call in `packages/coding-agent/src` that puts a non-literal value on the real stdout, and carries a negative control that fails if the scanner stops reporting a planted egress. Documented in `docs/usage.md` and `docs/security.md`.
+
+### Changed
+
+- `ChatSessionHostCommands.prompt` now receives the submitting key's mode as a second argument, and the new `ChatSessionSubmitMode` (`"auto" | "followUp"`) type is exported alongside the other chat-session host types. A host whose idle prompt command chooses a delivery queue can now read the mode of the invocation it is serving instead of shared state a concurrent submission may still own. Existing single-argument `prompt` implementations keep working unchanged ([#2074](https://github.com/bastani-inc/atomic/issues/2074)).
+- The `/model` selector now highlights the top row whenever a filter query is typed, so the best match is the one Enter selects. Clearing the query restores the previous position, clamped to the restored list.
+- Toggling tool-output expansion now reports the new state (`Tool output: expanded` / `Tool output: collapsed`) on the status line instead of re-rendering silently.
+- The startup RESOURCES disclosure now lists `SYSTEM.md` and `APPEND_SYSTEM.md` alongside the `AGENTS.md`/`CLAUDE.md` context files, in the order they reach the prompt. Those files shape the system prompt exactly like a context file, so leaving them out of the listing hid them.
+- llama.cpp models now declare streaming usage support, so token usage is reported during a streamed response instead of only at the end.
+- A provider that ends a turn with a terminal reason the mapping does not recognise now surfaces a provider error naming the raw reason, instead of reporting an ordinary successful stop. A truncation or safety signal a provider adds after this release is therefore visible rather than arriving as a turn that looks like it finished normally; every raw reason that already mapped to a successful stop still does. Documented in `docs/providers.md`.
+- Assistant messages carry the new `pending` stop reason while they are still streaming. It is replaced by the terminal reason before the message completes, so it never reaches session JSONL, but an RPC or SDK client that switches on the stop reason of a partial message needs the case, and a custom `streamSimple` provider should start its partial message at `pending` and raise if the stream ends still holding it. Documented in `docs/providers.md`, `docs/custom-provider.md`, `docs/rpc.md`, and `docs/session-format.md`.
+- A stored OAuth token is now refreshed once fewer than five minutes of validity remain, rather than at expiry, so a long turn is no longer started on a credential that dies mid-request. The refresh runs inside the `auth.json` lock and re-checks the stored expiry after taking it, so concurrent sessions sharing one credential file refresh it once between them rather than once each. Documented in `docs/providers.md`.
+- The OpenRouter login now accepts a pasted final redirect URL, or the authorization code on its own, for remote and headless machines where the browser cannot reach the loopback callback. pi 0.83.0 added that fallback to the OpenRouter OAuth flow, which races the callback against a manual-entry prompt; Atomic's terminal only offers the input for providers whose metadata declares a callback server, so inheriting the flow alone left the prompt waiting on an input that was never shown and the login ended at the callback timeout. Documented in `docs/providers.md`.
+
+### Fixed
+
+- Fixed `/reload` re-transpiling and re-evaluating the entire transitive TypeScript graph of every extension on Windows and in single-file (compiled) builds even when nothing changed. Transformed extension evaluations now record a per-extension graph manifest mapping every file jiti reads to a SHA256 content hash, persisted under the versioned transpile cache directory. On reload, an unchanged graph — every recorded file rehashes identically and the stored manifest matches — reuses the previously evaluated factory instead of re-importing; any hash mismatch, missing file, missing or corrupt manifest, or graph-shape change falls back to a full fresh re-evaluation, which rewrites the manifest, so edited extension source is always picked up. Measured on Windows, reloading the five builtin packages drops from ~25 s cold / ~16 s warm (jiti fsCache) to ~90 ms — the cost of rehashing the recorded graph ([#2069](https://github.com/bastani-inc/atomic/issues/2069)).
+- Hardened the archive and SQLite path-selector parsers used by the read, search, and write tools against polynomial-time regex backtracking (CodeQL `js/polynomial-redos`). The ambiguous greedy `(.+\.ext)` prefixes were replaced with linear right-to-left scans; accepted selector syntax and parsing results are unchanged.
+- Fixed a failed `git` package install leaving a half-written checkout behind. Because the next install treats an existing target directory as installed, that partial clone silently suppressed the repair. A clone, checkout, or dependency install that fails now removes the target directory and prunes the host/owner directories it created.
+- Fixed the RPC `bash` command bypassing extension `user_bash` handlers. A sandbox or remote-shell extension that intercepts user shell commands now sees an RPC `bash` request exactly as it sees `user_bash`, with request-scoped ownership, streaming correlation, and result recording unchanged.
+- Fixed a startup session switch rendering every agent event twice. A session replacement that began while the startup rebind was still binding extensions produced two live agent subscriptions; the superseded rebind now returns without subscribing.
+- Fixed session-tree navigation being accepted while a response was still streaming, which stranded the in-flight turn's tool results on the abandoned branch. Navigation now rejects while streaming, the interactive tree selector stops the active response (restoring queued messages to the editor) before navigating, and a session replacement settles its active response before the outgoing session is torn down. The isolated engine's host facade deliberately does not re-enter its cooperative-abort round trip during teardown, so an unresponsive or dead engine still cannot hang a session switch.
+- Fixed a nested linked git worktree loading the repository's `AGENTS.md`/`CLAUDE.md` twice. When a worktree created inside its own main repository has its own copy of the same tracked context file, the main repository's copy is now skipped. Ordinary repositories, sibling worktrees, bare layouts, and submodules keep normal ancestor inheritance.
+- Fixed extension-contributed skills, prompt templates, and themes losing their package source metadata when they were registered after a resource reload. The reload's resolved metadata is now retained on the loader so later `extendResources` passes still resolve it.
+
+## [0.9.11-alpha.8] - 2026-07-29
+
+### Breaking Changes
+
+- Replaced Atomic's legacy extension OAuth registration bridge with provider-owned authentication from `@earendil-works/pi-ai`. Extensions must declare OAuth or API-key authentication on their provider registration. The package root no longer exports the bridge functions `registerOAuthProvider`, `resetOAuthProviders`, `getOAuthApiKey`, `getOAuthProvider`, or `getOAuthProviders`, nor the bridge and credential/status types `LegacyOAuthProvider`, `OAuthProviderDescriptor`, `ApiKeyCredential`, `AuthCredential`, `AuthStatus`, or `OAuthCredential`; import current credential types from `@earendil-works/pi-ai` and use provider-owned authentication instead. The internal legacy registration/refresh machinery and custom API-key login hooks beyond pi's provider contract were also removed.
+- Model configuration now follows pi's single-file `ModelConfig` contract. Atomic reads one `models.json` from the active Atomic agent directory (`~/.atomic/agent/models.json`, or the directory selected by `ATOMIC_CODING_AGENT_DIR`/`PI_CODING_AGENT_DIR`); it no longer reads project-scoped `.atomic/models.json`, falls back to `~/.pi/agent/models.json`, or layers and merges `.pi` and `.atomic` model configuration files. Move project-scoped custom providers and models into the active agent-directory file. The legacy `.pi` read fallback remains only for configuration surfaces that explicitly use layered paths, such as `auth.json`.
+- Model-catalog refreshes now use pi's exact timeout semantics. `modelRefreshTimeoutMs` applies only to the initial runtime creation refresh, and post-login catalog refreshes are unbounded; the interactive `/model` selector owns its 15-second refresh timeout like pi, rendering cached models immediately, aborting a slow refresh, and reporting "Model refresh timed out; showing cached models." Callers of `ModelRuntime.refresh()` that require cancellation must provide their own abort signal.
+- Extension `streamSimple` implementations are now scoped to their registered provider and `ModelRuntime`, matching pi's provider composer. Unregistering a newer provider no longer restores an older global API-owner registration; extensions that replace a provider stream must keep that provider registered for as long as the stream should remain active.
+- Remote model catalogs now publish refreshed models in memory before persisting the catalog, matching pi's ordering. If the catalog-store write fails, refresh reports the storage error but the newly refreshed in-memory catalog remains active for the current process.
+- `AuthStorage` now implements pi's asynchronous `CredentialStore` contract directly. Its synchronous compatibility methods (`get`, `set`, `remove`, `has`, `hasAuth`, `getAll`, `getAuthStatus`, `getLoadError`, `drainErrors`, and synchronous `list`), `asCredentialStore()` adapter, fallback/runtime-key helpers (`setFallbackResolver`, `getRuntimeApiKey`, `setRuntimeApiKey`, and `removeRuntimeApiKey`), and provider-auth methods (`login`, `logout`, `logoutAsync`, `getModelAuth`, `getApiKey`, and `getOAuthProviders`) were removed. Use and `await` `read`, `list`, `modify`, and `delete` for persisted credentials, call `reload` when an existing instance must reread its backing store, and use `ModelRuntime` for authentication resolution, login/logout, and runtime API-key overrides.
+- `ModelRegistry` is now constructed from a `ModelRuntime` and exposes only pi's thin compatibility-facade surface. The `create` and `inMemory` factories, public `authStorage` member, and the `canRestoreUnknownModel`, `checkAuth`, `getAuth`, `getCustomApiKeyAuth`, `getCustomApiKeyAuthProviders`, `getProviders`, `hasProvider`, `hasRegisteredStreamSimpleForApi`, `login`, and `logoutProvider` methods were removed. Instantiate and consume `ModelRuntime` for runtime-owned model/provider discovery and authentication, and pass it to `new ModelRegistry(runtime)` only where the synchronous extension-facing facade is required.
+- `CreateAgentSessionOptions` no longer accepts the public `authStorage` and `modelRegistry` overrides. Construct or supply a `ModelRuntime` through `modelRuntime` instead; when omitted, `createAgentSession()` creates the runtime from the active agent directory's `auth.json` and `models.json`.
+- Isolated interactive `ctx.ui.custom()` components that consume Ctrl+C must now pass `{ handlesCtrlC: true }`. Without that declaration the first Ctrl+C is the host escape and closes the focused component, resolving its promise with `undefined`; a declared component receives the first press and stays host-closable on the next one. This keeps a component that never resolves from trapping the keyboard. The bundled workflow and MCP surfaces were migrated; third-party extensions that bind Ctrl+C for Skip, Close, or cancel need the one-line addition.
+
+### Added
+
+- Added a `handlesCtrlC` option to `ctx.ui.custom()` for components that bind the key themselves. See the migration note under Breaking Changes for the behavior an existing component must declare to keep.
+
+### Changed
+
+- Adopted pi's provider-owned `ModelRuntime` architecture for model composition, credentials, streaming, and catalog refresh. `ModelRegistry` is now the thin synchronous extension-compatibility facade used by pi, while coding-agent, SDK, RPC, isolated-engine, workflow, and MCP internals consume `ModelRuntime` directly.
+
+### Fixed
+- Fixed physical Escape and Ctrl+C depending on the configurable `app.clear` action. With `app.clear` bound to Escape, Escape could reach the engine stop/restart branch while Ctrl+C lost the host route entirely — the opposite of the intended behavior on both keys. Both are now matched by physical key identity through pi-tui's parser (so complete CSI/OSC sequences and bracketed paste are never mistaken for a bare Escape, and Kitty key-release events never act twice), and the configured `app.clear` still governs ordinary editor clearing on whatever key it is bound to. The editor applies the same fixed Escape guard before its configurable action handlers, while keeping Escape as autocomplete cancel when autocomplete is open.
+- Fixed the remote-UI escape hatch replacing a healthy engine, and made it act on the first press. Ctrl+C behind a remote `ctx.ui.custom()` component used to need two presses and then stopped and replaced the whole engine child, discarding everything else that generation was doing. Ownership is now declared per mount: an unresponsive engine is still terminated on the first press (a wedged child cannot run a local handler either), a component that declared `handlesCtrlC` receives the press and keeps working — and is closed if it is still holding input on the next one — and an undeclared component is closed immediately through the ordinary close path, resolving its `ctx.ui.custom()` promise with `undefined` while the engine, and every other component it has mounted, keeps running.
+- Fixed an engine child that exits during the startup window leaving a live TUI bound to a dead engine. A child could report ready, let startup return, and exit before the host finished attaching its listeners; that death had no listener and recovery never ran. The terminal event is now retained and replayed to a listener that attaches afterwards, while a death belonging to an already-replaced generation is never replayed.
+- Fixed frames buffered by a dead engine generation being delivered to the host afterwards. A `ctx.ui.custom()` mount frame queued before its controller subscribed could arrive after that generation died and after teardown ran, remounting exactly the UI the teardown had just closed — and colliding with the replacement child, whose component IDs restart at the same values. Buffered engine messages and extension UI requests are now tagged with their generation, dropped when it dies, and never observed from a replaced generation; frames belonging to the live generation still replay as before.
+- Fixed two submissions whose text differs only in whitespace being able to restore each other's draft. The exact typed buffer travelled in a single shared slot that every Enter overwrote and every finished turn cleared, so a failure could put back the wrong text — or nothing. Each submission now carries its own draft end to end, through the input queue and the prompt turn, and submissions still queued behind a failed one come back with it in the order they were entered rather than being restored later in reverse.
+- Fixed a raw stream write failure still discarding submitted text. `write EPIPE`, `Cannot call write after a stream was destroyed`, and `write after end` are exactly what a dying engine produces, and none of them matched the message fragments the host used to recognize a send that never landed — so those submissions showed a red `Error: write EPIPE` and the typed text was lost. Transport failures are now classified where they happen, with an additive non-enumerable marker that leaves the error's identity and its `code`, `errno`, and `syscall` fields intact, and the queued writer, the child exit/error/stdin handlers, an explicit stop, a malformed transport, a missing writer, and a not-started client all carry it. Request timeouts after a successful write, RPC error responses, provider failures, and anything after `agent_start` are deliberately not classified and still surface as errors.
+- Fixed an idle Alt+Enter submission losing its surrounding whitespace when the send failed. Alt+Enter is an app action, so the editor never takes its own pre-trim snapshot for it and the submit handler's only draft is the value the Alt+Enter path hands over — which was the already-trimmed text. The raw expanded buffer is passed instead, so a failed idle follow-up now returns exactly what was typed while the agent still receives the same normalized prompt.
+- Fixed quiet work that the engine had already started being offered back to the editor as unsent. Ownership was inferred from the first byte of output, so `!touch marker && sleep 400` — which changes the working tree and prints nothing — looked identical to a command the child never received: killing the engine put that `!` line back in the editor, inviting a second run. The child now announces ownership of every correlated request, flushed before its handler can touch the shell, an extension, the queue, or compaction, and the host restores a draft only for a transport failure that arrived without an announcement. An accepted failure is reported as an ordinary failure instead. The interactive-engine protocol version is now `2`; a mismatched host and child do not bind rather than falling back to the old policy.
+- Fixed automatic recovery discarding the ownership of the work it was recovering from. An announcement can still be unparsed in the pipe when the child dies, and recovery — which starts in the same turn as the death event — detached the reader, retired the generation, and re-failed those requests with `Agent process stopped`, so already-running work was reported as never sent and offered back for a second run. A dead generation now gets a bounded settling window: its UI is torn down immediately as before, but its stdout keeps being read, only its ownership frames are honoured, its requests are classified exactly once with the error of whatever ended it, and the replacement starts only afterwards. Every terminal cause — exit, spawn error, stdin error, malformed transport, and explicit stop — goes through that one path, and a descendant that inherited stdout cannot delay recovery beyond the bound. The JSONL reader also reports completion for a stream that ends with nothing buffered, which previously left that wait to time out.
+- Fixed session teardown racing an engine replacement. A recovery attempt sits between its own stop and its spawn with no child attached, so disposal's stop found nothing to do and returned — and the attempt then started a fresh engine, plus its host initialization, after teardown had finished. Disposal now voids the in-flight restart permit and joins the attempt before returning, and a superseded restart fails as cancelled instead of quietly succeeding. Automatic single-shot recovery, the Ctrl+C rescue, and the overdue-replacement rules are unchanged; a cancelled attempt reports no failure and arms nothing.
+- Exempted every cooperative-cancellation command from the generic 30-second RPC deadline, not just `abort`. Cancelling a running `!sleep` still produced `Timeout waiting for response to abort_bash` — a red error about the host's own impatience while the engine was still working. `abort_bash`, `abort_compaction`, `abort_retry`, and `cancel_login_provider` now wait like `abort` does.
+- Fixed engine loss during an active replacement leaving the host with no engine and no way to ask for one. A newer child dying while the automatic attempt was still running was silently ignored, and once that attempt settled nothing armed Ctrl+C. The nested death now latches the escape hatch without starting a second automatic restart, so recovery stays single-shot and user-driven.
+- Fixed engine-owned line widgets surviving the generation that published them. `setWidget` writes plain host state with no component to close, so a dead generation left its lines on screen. Widget keys are now tracked against their latest writing generation and released only when that generation dies; a newer generation that rewrites the same key takes ownership and its content survives stale cleanup.
+- Fixed the restored draft being the already-trimmed submission rather than what was typed. pi-tui expands pastes, trims, and clears the editor before it calls `onSubmit`, so the callback argument could never carry the user's leading or trailing whitespace. The editor now snapshots its expanded buffer for the same input dispatch that submits it, and restoration uses that.
+- Stopped showing a red transport error next to a restored draft. A submission the engine never accepted already reports itself: the draft is back in the editor and the calm recovery status explains why. Errors that were not restored — provider failures, model errors, and any failure after the agent turn started — still surface.
+- Fixed a stream write that failed in its callback leaving its caller's promise pending forever. An EPIPE to a dying engine could hang a prompt or an abort instead of failing it; the in-flight frame is now rejected along with everything still queued.
+- Fixed the heartbeat observer consuming the buffered startup custom-UI messages. Watching heartbeats through the generic engine-message channel drained messages queued before the real controllers subscribed, so a custom UI opened during startup could be lost. Heartbeats now arrive on a dedicated callback that does not participate in that buffering.
+
+- Fixed interrupting a tool call terminating the interactive engine and reporting `Engine terminated; … result unknown; inspect side effects before retrying`. Escape raced the engine's cooperative abort against a 250 ms deadline and killed plus restarted the engine child whenever it lost that race, which any ordinary event-loop stall in the child could cause — a synchronous extension or tool callback, GC, or a large tool-output flush. Escape now simply requests the engine's cooperative cancellation and waits for it: interrupting never terminates the engine, never restarts it, never discards in-flight tool state, and the removed message no longer exists anywhere in Atomic. The wait is genuinely unbounded — `abort` is exempt from the generic 30-second RPC deadline, so a stopped or blocked child no longer turns Escape into a red `Timeout waiting for response to abort` while the engine is still working.
+- Fixed a total interactive-TUI lockup when the engine generation behind a mounted remote custom UI died. A crashed, killed, or replaced engine left the host's `ctx.ui.custom()` components mounted forever: their promises never settled, an inline mount kept the editor detached from its container, an overlay kept input focus, widget keys and terminal modes stayed claimed, and the blocking inline custom-UI depth stayed above zero, so typing, Escape, Ctrl+C, and even Ctrl+C Ctrl+C all did nothing and the process had to be killed from another terminal. Engine death is now a host-local lifecycle event that immediately closes every remote component from the dead generation, settles its promises, releases widget keys, resets terminal modes, remounts and refocuses the editor, and unwinds the inline depth to zero — without waiting for a replacement `engine_ready`, so a crash with no restart, or a hung or failed restart, recovers too. Teardown unwinds newest-first and hides each overlay through its own handle, so a nested overlay never restores focus to a layer that is already gone and never closes an unrelated native overlay, and the editor is refocused only when no surviving native modal owns input. Host `select`, `confirm`, `input`, and `editor` dialogs opened by the dead generation are now owned by it too: they used to stay on screen forever with their promise unsettled and could answer through the replacement child's writer.
+- Added recovery from an unexpected interactive-engine exit. A crashed engine previously left a live TUI bound to a dead child with no way back; Atomic now makes one automatic replacement attempt and shows the calm status `Interactive engine stopped unexpectedly; restarting.`, reports `Interactive engine restart failed: …` when the replacement cannot start, and leaves the editor mounted, focused, and usable in either case.
+- Kept an explicit escape hatch for a wedged engine, matching the watchdog's own `Esc interrupt · Ctrl+C terminate` copy, and made it reachable in every case where the key would otherwise vanish. Ctrl+C is now always handled by the host while an engine-owned `ctx.ui.custom()` component or overlay holds input — even with a healthy engine, because such a component forwards every key to the child and a component that never resolves would trap the escape key too; with a healthy engine the host closes that one component rather than touching the engine. Ctrl+C also still replaces an engine that is provably not answering: watchdog-confirmed unresponsive, a cooperative abort unanswered past the same one-second threshold, a replacement waiting for readiness past it (previously unrecoverable, since such a child emits no heartbeat and no diagnostic), or a replacement that failed outright, which now keeps Ctrl+C armed indefinitely instead of leaving the host permanently engine-less. A repeat press can stop an overdue replacement and start another; a fresh replacement is never stopped by a stray press; and host-native selectors, dialogs, input forms, and session pickers keep Ctrl+C-as-cancel whenever the engine is healthy.
+- Fixed the interactive engine exporting its private control values to every process it spawned. `ATOMIC_INTERACTIVE_ENGINE_CHILD`, `_HOST_PID`, `_GUARD_FILE`, and `_API_KEY` were set on the engine child's environment, so bash tool commands, subagent children, MCP servers, hooks, and nested Atomic runs all inherited them: a nested `atomic` started in engine mode and flooded stdout with heartbeats instead of opening a TUI, parent-process guardians watched an unrelated PID, subagent idle watchdogs never fired, and an `--api-key` credential reached every child. Deleting the variables at startup cannot fix this under Bun, where a child spawned without an explicit `env` inherits the runtime's launch-time environment; the engine is therefore now launched with an environment that never contains the values. They travel in an owner-only bootstrap file whose path is a private CLI argument, read once and unlinked by the child, and every reader uses that frozen snapshot. Legacy variables are still scrubbed from `process.env` and from subagent foreground, background-streaming, and detached-runner spawn environments as defense in depth, and extension `ctx.exec` passes an explicit environment. Bootstrap cleanup is ownership-scoped: the child unlinks exactly the file it was told to read, while recursive removal of the containing directory requires the handle the host received when it created it, so a hostile `--internal-engine-bootstrap` path cannot delete an unrelated directory. A failed publication removes its own temporary file and directory before rethrowing, so a `0600` credential file is never left behind.
+- Fixed typed input being discarded when a submission could not be sent. A prompt that failed because the engine was gone, stopping, or restarting showed only `Error: Agent process stopped` and lost the text. The submission now returns to the editor exactly as the editor handed it over, placed ahead of anything typed while the send was still pending and separated by a blank line, so neither part is lost and neither is trimmed; a pending large paste is expanded rather than reduced to a dead `[paste #1 …]` marker, which `setText` would otherwise discard. Focus returns to the editor unless a modal owns input, and the restored text is treated as a draft rather than replayed as a submission. This covers every submit route, not just Enter: `/atomic`, a deferred slash command, an extension command during compaction, a streaming steer send, `!bash`, `/compact`, and Alt+Enter all dispatch straight to the engine and previously dropped the text on their own. Text that reached a started agent turn stays in the transcript as before.
+- Fixed OAuth logins being destroyed by an unrelated model-catalog refresh, matching upstream pi's behavior. After a successful `/login`, a timed-out (aborted) or partially failed catalog refresh threw `Model refresh aborted after OAuth login` and rolled the freshly acquired tokens back to the previous credential. Because providers rotate refresh tokens, that rollback could permanently strand a server-side-invalidated credential — every send then failed with `invalid_grant` ("Refresh token not found or invalid") and every re-login was rolled back again, typically on machines with slow routes to catalog endpoints. Freshly persisted OAuth credentials now always survive the post-login refresh: per-provider refresh errors and refresh timeouts no longer fail the login in either the direct interactive or isolated-engine path, and models fall back to the cached snapshot.
+- Fixed the `/model` selector reporting `Could not refresh llama.cpp; showing cached models.` for users who never configured a llama.cpp server. The bundled llama.cpp extension now uses pi's provider-owned registration: the provider stays dormant — no refresh attempt, no error — until a server is configured through `LLAMA_BASE_URL` or a stored login, and `/login` prompts for the server URL plus optional API key exactly like pi.
+- Fixed RPC `save_provider_credential` writes disappearing after process restart. Saved API-key and OAuth credentials now persist to `auth.json` through `ModelRuntime.saveCredential()` instead of being stored as non-persistent runtime API-key overrides; the RPC command again accepts the full credential union, awaits a model-catalog refresh, and returns the refreshed catalog.
+- Fixed GitHub Copilot requests failing with `421 Misdirected Request` for users who authenticate with `COPILOT_GITHUB_TOKEN`. Upstream pi pins the `github-copilot` provider to `https://api.individual.githubcopilot.com` and only derives a per-tenant host inside its OAuth loader, so business, enterprise, and GHE tokens supplied through the environment were sent to the individual CAPI host. Atomic now resolves the endpoint for env-token auth again, highest precedence first: `COPILOT_API_TARGET` / `GITHUB_COPILOT_BASE_URL`, the token's embedded `proxy-ep` segment, `GITHUB_SERVER_URL` (`<tenant>.ghe.com` routes to `copilot-api.<tenant>.ghe.com`, other non-`github.com` hosts to `https://api.enterprise.githubcopilot.com`), and finally the public routing hub `https://api.githubcopilot.com`. A `models.json` provider `baseUrl` still overrides all of it, and the OAuth path remains exactly upstream.
+
 ## [0.9.11-alpha.7] - 2026-07-28
 
 ### Changed

package/README.md

@@ -429,14 +429,12 @@ See [docs/packages.md](docs/packages.md).
 ### SDK
 
 ```typescript
-import { AuthStorage, createAgentSession, ModelRegistry, SessionManager } from "@bastani/atomic";
+import { createAgentSession, SessionManager } from "@bastani/atomic";
 
-const authStorage = AuthStorage.create();
-const modelRegistry = ModelRegistry.create(authStorage);
+// By default, createAgentSession builds a ModelRuntime from the active agent
+// directory's auth.json and models.json.
 const { session } = await createAgentSession({
   sessionManager: SessionManager.inMemory(),
-  authStorage,
-  modelRegistry,
 });
 
 await session.prompt("What files are in the current directory?");

package/dist/builtin/intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/intercom",
-  "version": "0.9.11-alpha.7",
+  "version": "0.9.11-alpha.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": [
@@ -44,7 +44,7 @@
   },
   "peerDependencies": {
     "@bastani/atomic": "*",
-    "@earendil-works/pi-tui": "^0.82.1"
+    "@earendil-works/pi-tui": "^0.83.0"
   },
   "peerDependenciesMeta": {
     "@bastani/atomic": {
@@ -56,6 +56,6 @@
   },
   "dependencies": {
     "tsx": "^4.23.1",
-    "typebox": "^1.3.6"
+    "typebox": "^1.3.7"
   }
 }

package/dist/builtin/mcp/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.11-alpha.9] - 2026-08-01
+
+### Fixed
+
+- Declared `handlesCtrlC` on the `/mcp` panel, the `/mcp setup` panel, and the MCP OAuth panel. In isolated interactive sessions the terminal host now closes an undeclared remote `ctx.ui.custom()` component on the first Ctrl+C, which would have bypassed each panel's own Ctrl+C handler along with its cancel and cleanup work. The declaration keeps that handler running.
+
 ## [0.9.11-alpha.6] - 2026-07-28
 
 ### Removed

package/dist/builtin/mcp/commands.ts

@@ -292,7 +292,9 @@ export async function openMcpSetup(
           resolve({ configChanged });
         });
       },
-      { overlay: true, overlayOptions: { anchor: "center", width: 92 } },
+      // handlesCtrlC: the setup panel binds Ctrl+C for its own cancel/cleanup,
+      // so the host must forward the key instead of closing the panel itself.
+      { overlay: true, handlesCtrlC: true, overlayOptions: { anchor: "center", width: 92 } },
     );
   });
 }
@@ -369,7 +371,8 @@ export async function openMcpPanel(
           resolve();
         }, { noticeLines });
       },
-      { overlay: true, overlayOptions: { anchor: "center", width: 82 } },
+      // handlesCtrlC: the panel binds Ctrl+C for its own cancel/cleanup.
+      { overlay: true, handlesCtrlC: true, overlayOptions: { anchor: "center", width: 82 } },
     );
   });
 
@@ -412,7 +415,8 @@ export async function openMcpAuthPanel(
           noticeLines: ["Select OAuth MCP Server. Enter/CTRL+A Authenticate."],
         });
       },
-      { overlay: true, overlayOptions: { anchor: "center", width: 82 } },
+      // handlesCtrlC: the panel binds Ctrl+C for its own cancel/cleanup.
+      { overlay: true, handlesCtrlC: true, overlayOptions: { anchor: "center", width: 82 } },
     );
   });
 

package/dist/builtin/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/mcp",
-  "version": "0.9.11-alpha.7",
+  "version": "0.9.11-alpha.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": [
@@ -32,8 +32,8 @@
   },
   "peerDependencies": {
     "@bastani/atomic": "*",
-    "@earendil-works/pi-ai": "^0.82.1",
-    "@earendil-works/pi-tui": "^0.82.1",
+    "@earendil-works/pi-ai": "^0.83.0",
+    "@earendil-works/pi-tui": "^0.83.0",
     "zod": "^3.25.0 || ^4.0.0"
   },
   "peerDependenciesMeta": {
@@ -48,10 +48,10 @@
     }
   },
   "dependencies": {
-    "@modelcontextprotocol/ext-apps": "^1.7.4",
-    "@modelcontextprotocol/sdk": "^1.25.1",
+    "@modelcontextprotocol/ext-apps": "^1.7.5",
+    "@modelcontextprotocol/sdk": "^1.30.0",
     "open": "^11.0.0",
-    "typebox": "^1.3.6",
+    "typebox": "^1.3.7",
     "zod": "^3.25.0 || ^4.0.0"
   }
 }

package/dist/builtin/mcp/sampling-handler.ts

@@ -152,11 +152,7 @@ async function resolveSamplingModel(
       errors.push(`${model.provider}/${model.id}: ${auth.error}`);
       continue;
     }
-		return {
-			model: auth.baseUrl === undefined ? model : { ...model, baseUrl: auth.baseUrl },
-			apiKey: auth.apiKey,
-			headers: auth.headers,
-		};
+		return { model, apiKey: auth.apiKey, headers: auth.headers };
   }
 
   if (errors.length > 0) {

package/dist/builtin/subagents/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## [Unreleased]
 
+## [0.9.11-alpha.9] - 2026-08-01
+
+### Fixed
+
+- Fixed startup artifact cleanup escaping isolated agent directories. When the host provides a non-default session directory (for example an isolated programmatic `agentDir` used by tests and embedders), the global artifact scan now stays inside that sessions root; the real global and legacy `~/.pi` sessions roots are only scanned when no host-provided root is available ([#2070](https://github.com/bastani-inc/atomic/issues/2070)).
+- Fixed every extension activation rescanning all historical session directories for stale subagent artifacts. The global scan now runs at most once per 24 hours per sessions root via a root-level `.last-cleanup` marker, takes an exclusive `.cleanup.lock` so concurrent activations never race the same scan, and is deferred ten minutes after startup instead of running on the activation macrotask; the deferral stays unref'd and is cancelled by extension shutdown ([#2070](https://github.com/bastani-inc/atomic/issues/2070)).
+- Fixed startup maintenance walking every file under the nested subagent runtime directories on each activation. The stale-directory scan now stops at the first entry newer than the cleanup cutoff instead of recursively stat-ing whole subtrees to compute the true newest mtime, eliminating tens of thousands of synchronous fs calls on long-lived machines ([#2070](https://github.com/bastani-inc/atomic/issues/2070)).
+- Fixed subagent worktree setup hooks being reported as failed when they never read their stdin. The hook's JSON input is written to its stdin, but nothing requires a hook to consume it; a hook that exited before that write flushed made `spawnSync` report `EPIPE` and the whole worktree creation was torn down, even though the hook had run to completion and its stdout was captured in full. The child's exit status and output are now authoritative, so only a spawn that never produced a status is treated as a hook failure. Timeouts and every other spawn error stay fatal as before. This race was lost far more often on loaded machines, making it look intermittent.
+
 ## [0.9.11-alpha.6] - 2026-07-28
 
 ### Changed

package/dist/builtin/subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/subagents",
-  "version": "0.9.11-alpha.7",
+  "version": "0.9.11-alpha.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": [
@@ -38,9 +38,9 @@
   },
   "peerDependencies": {
     "@bastani/atomic": "*",
-    "@earendil-works/pi-agent-core": "^0.82.1",
-    "@earendil-works/pi-ai": "^0.82.1",
-    "@earendil-works/pi-tui": "^0.82.1"
+    "@earendil-works/pi-agent-core": "^0.83.0",
+    "@earendil-works/pi-ai": "^0.83.0",
+    "@earendil-works/pi-tui": "^0.83.0"
   },
   "peerDependenciesMeta": {
     "@bastani/atomic": {
@@ -58,6 +58,6 @@
   },
   "dependencies": {
     "jiti": "^2.7.0",
-    "typebox": "^1.3.6"
+    "typebox": "^1.3.7"
   }
 }

package/dist/builtin/subagents/src/agents/agent-discovery.ts

@@ -2,9 +2,8 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { getEnvValue } from "@bastani/atomic";
-import { mergeAgentsForScope } from "./agent-selection.ts";
-import { applyBuiltinOverrides, readMergedSubagentSettings } from "./agent-overrides.ts";
 import { loadAgentsFromDir, loadChainsFromDir } from "./agent-loaders.ts";
+import { applyBuiltinOverrides, readMergedSubagentSettings } from "./agent-overrides.ts";
 import {
 	BUILTIN_AGENTS_DIR,
 	getProjectAgentSettingsPath,
@@ -17,13 +16,14 @@ import {
 	resolveNearestProjectAgentDirs,
 	resolveNearestProjectChainDirs,
 } from "./agent-paths.ts";
+import { mergeAgentsForScope } from "./agent-selection.ts";
 import {
-	EMPTY_SUBAGENT_SETTINGS,
 	type AgentConfig,
 	type AgentDiscoveryResult,
 	type AgentScope,
 	type ChainConfig,
 	type ChainDiscoveryDiagnostic,
+	EMPTY_SUBAGENT_SETTINGS,
 } from "./agent-types.ts";
 
 export function discoverAgents(cwd: string, scope: AgentScope): AgentDiscoveryResult {
@@ -50,8 +50,9 @@ export function discoverAgents(cwd: string, scope: AgentScope): AgentDiscoveryRe
 	const userAgents = [...userAgentsOld, ...userAgentsNew];
 
 	const projectAgents = scope === "user" ? [] : projectAgentDirs.flatMap((dir) => loadAgentsFromDir(dir, "project"));
-	const agents = mergeAgentsForScope(scope, userAgents, projectAgents, builtinAgents)
-		.filter((agent) => agent.disabled !== true);
+	const agents = mergeAgentsForScope(scope, userAgents, projectAgents, builtinAgents).filter(
+		(agent) => agent.disabled !== true,
+	);
 
 	return { agents, projectAgentsDir };
 }
@@ -110,18 +111,28 @@ export function discoverAgentsAll(cwd: string): {
 		}
 	}
 	const userChainLoads = getUserChainDirs().map((dir) => loadChainsFromDir(dir, "user"));
-	const chains = [
-		...userChainLoads.flatMap((loaded) => loaded.chains),
-		...Array.from(chainMap.values()),
-	];
-	const chainDiagnostics = [
-		...userChainLoads.flatMap((loaded) => loaded.diagnostics),
-		...projectChainDiagnostics,
-	];
+	const chains = [...userChainLoads.flatMap((loaded) => loaded.chains), ...Array.from(chainMap.values())];
+	const chainDiagnostics = [...userChainLoads.flatMap((loaded) => loaded.diagnostics), ...projectChainDiagnostics];
 
 	const legacyUserAgentDir = userDirOld[0]!;
 	// ATOMIC_CODING_AGENT_DIR is already applied by getUserAgentDirs(); prefer that resolved path over ~/.agents.
-	const userDir = getEnvValue("ATOMIC_CODING_AGENT_DIR") ? legacyUserAgentDir : fs.existsSync(userDirNew) ? userDirNew : legacyUserAgentDir;
+	const userDir = getEnvValue("ATOMIC_CODING_AGENT_DIR")
+		? legacyUserAgentDir
+		: fs.existsSync(userDirNew)
+			? userDirNew
+			: legacyUserAgentDir;
 
-	return { builtin, user, project, chains, chainDiagnostics, userDir, projectDir, userChainDir, projectChainDir, userSettingsPath, projectSettingsPath };
+	return {
+		builtin,
+		user,
+		project,
+		chains,
+		chainDiagnostics,
+		userDir,
+		projectDir,
+		userChainDir,
+		projectChainDir,
+		userSettingsPath,
+		projectSettingsPath,
+	};
 }

package/dist/builtin/subagents/src/agents/agent-loaders.ts

@@ -1,20 +1,20 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { shouldPreserveAgentExtraField } from "./agent-serializer.ts";
-import { parseChain, parseJsonChain } from "./chain-serializer.ts";
-import { parseFrontmatter } from "./frontmatter.ts";
-import { buildRuntimeName, parsePackageName } from "./identity.ts";
+import { normalizeMaxSubagentDepth } from "../shared/types.ts";
 import { splitToolList } from "./agent-overrides.ts";
+import { shouldPreserveAgentExtraField } from "./agent-serializer.ts";
 import {
-	defaultInheritProjectContext,
-	defaultInheritSkills,
-	defaultSystemPromptMode,
 	type AgentConfig,
 	type AgentSource,
 	type ChainConfig,
 	type ChainDiscoveryDiagnostic,
+	defaultInheritProjectContext,
+	defaultInheritSkills,
+	defaultSystemPromptMode,
 } from "./agent-types.ts";
-import { normalizeMaxSubagentDepth } from "../shared/types.ts";
+import { parseChain, parseJsonChain } from "./chain-serializer.ts";
+import { parseFrontmatter } from "./frontmatter.ts";
+import { buildRuntimeName, parsePackageName } from "./identity.ts";
 
 function listFilesRecursive(dir: string, predicate: (fileName: string) => boolean): string[] {
 	const files: string[] = [];
@@ -51,7 +51,10 @@ function parseCommaSeparatedList(value: string | undefined): string[] | undefine
 export function loadAgentsFromDir(dir: string, source: AgentSource): AgentConfig[] {
 	const agents: AgentConfig[] = [];
 
-	for (const filePath of listFilesRecursive(dir, (fileName) => fileName.endsWith(".md") && !fileName.endsWith(".chain.md"))) {
+	for (const filePath of listFilesRecursive(
+		dir,
+		(fileName) => fileName.endsWith(".md") && !fileName.endsWith(".chain.md"),
+	)) {
 		let content: string;
 		try {
 			content = fs.readFileSync(filePath, "utf-8");
@@ -78,26 +81,30 @@ export function loadAgentsFromDir(dir: string, source: AgentSource): AgentConfig
 		const skills = parseCommaSeparatedList(skillStr);
 		const fallbackModels = parseCommaSeparatedList(frontmatter.fallbackModels);
 		const fallbackThinkingLevels = parseCommaSeparatedList(frontmatter.fallbackThinkingLevels);
-		const systemPromptMode = frontmatter.systemPromptMode === "replace"
-			? "replace"
-			: frontmatter.systemPromptMode === "append"
-				? "append"
-				: defaultSystemPromptMode(localName);
-		const inheritProjectContext = frontmatter.inheritProjectContext === "true"
-			? true
-			: frontmatter.inheritProjectContext === "false"
-				? false
-				: defaultInheritProjectContext(localName);
-		const inheritSkills = frontmatter.inheritSkills === "true"
-			? true
-			: frontmatter.inheritSkills === "false"
-				? false
-				: defaultInheritSkills();
-		const defaultContext = frontmatter.defaultContext === "fork"
-			? "fork" as const
-			: frontmatter.defaultContext === "fresh"
-				? "fresh" as const
-				: undefined;
+		const systemPromptMode =
+			frontmatter.systemPromptMode === "replace"
+				? "replace"
+				: frontmatter.systemPromptMode === "append"
+					? "append"
+					: defaultSystemPromptMode(localName);
+		const inheritProjectContext =
+			frontmatter.inheritProjectContext === "true"
+				? true
+				: frontmatter.inheritProjectContext === "false"
+					? false
+					: defaultInheritProjectContext(localName);
+		const inheritSkills =
+			frontmatter.inheritSkills === "true"
+				? true
+				: frontmatter.inheritSkills === "false"
+					? false
+					: defaultInheritSkills();
+		const defaultContext =
+			frontmatter.defaultContext === "fork"
+				? ("fork" as const)
+				: frontmatter.defaultContext === "fresh"
+					? ("fresh" as const)
+					: undefined;
 
 		let extensions: string[] | undefined;
 		if (frontmatter.extensions !== undefined) {
@@ -146,11 +153,17 @@ export function loadAgentsFromDir(dir: string, source: AgentSource): AgentConfig
 	return agents;
 }
 
-export function loadChainsFromDir(dir: string, source: "user" | "project"): { chains: ChainConfig[]; diagnostics: ChainDiscoveryDiagnostic[] } {
+export function loadChainsFromDir(
+	dir: string,
+	source: "user" | "project",
+): { chains: ChainConfig[]; diagnostics: ChainDiscoveryDiagnostic[] } {
 	const chains = new Map<string, ChainConfig>();
 	const diagnostics: ChainDiscoveryDiagnostic[] = [];
 
-	for (const filePath of listFilesRecursive(dir, (fileName) => fileName.endsWith(".chain.md") || fileName.endsWith(".chain.json"))) {
+	for (const filePath of listFilesRecursive(
+		dir,
+		(fileName) => fileName.endsWith(".chain.md") || fileName.endsWith(".chain.json"),
+	)) {
 		let content: string;
 		try {
 			content = fs.readFileSync(filePath, "utf-8");
@@ -159,13 +172,14 @@ export function loadChainsFromDir(dir: string, source: "user" | "project"): { ch
 		}
 
 		try {
-			const chain = filePath.endsWith(".chain.json") ? parseJsonChain(content, source, filePath) : parseChain(content, source, filePath);
+			const chain = filePath.endsWith(".chain.json")
+				? parseJsonChain(content, source, filePath)
+				: parseChain(content, source, filePath);
 			const existing = chains.get(chain.name);
-			if (existing && existing.filePath.endsWith(".chain.json") && filePath.endsWith(".chain.md")) continue;
+			if (existing?.filePath.endsWith(".chain.json") && filePath.endsWith(".chain.md")) continue;
 			chains.set(chain.name, chain);
 		} catch (error) {
 			diagnostics.push({ source, filePath, error: error instanceof Error ? error.message : String(error) });
-			continue;
 		}
 	}