@bastani/atomic 0.9.11-alpha.9 → 0.9.12-alpha.1

package/CHANGELOG.md

@@ -2,6 +2,153 @@
 
 ## [Unreleased]
 
+## [0.9.12-alpha.1] - 2026-08-04
+
+### Added
+
+- Compaction honors `<keepContext>` / `</keepContext>` tags. Wrap any part of a prompt you never want compressed, and every line of the span — tag lines included — is protected verbatim regardless of the compression ratio. The guarantee is mechanical rather than advisory: deletion ranges are split around protected lines after the planner responds. Because the tag lines are protected too, a span is re-detected on each subsequent boundary and stays protected for the life of the session. Detection is bounded on three sides, because the transcript it scans is untrusted: a tag must be the whole line after any role header, a span is scoped to one message so an unclosed tag stops at the end of its own message rather than running to the end of the region, and tags inside tool results are inert — user and assistant messages may both protect, so prompts, steering, and an agent's own pinned information all work, but file, page, or command output an agent reads cannot mark itself unreclaimable or persist through compaction ahead of real content. Protected lines count against the keep target rather than raising it, so the compression ratio stays a real bound on output size and the unprotected remainder compresses harder. Results report force-preserved ranges as `keptRanges` ([#2172](https://github.com/bastani-inc/atomic/issues/2172)).
+
+### Fixed
+
+- The compaction relevance query is no longer truncated to 1,000 characters. Truncation made prompt section order the retention policy: for a long structured prompt only the leading section reached the planner, so a constraint stated later could not influence what was kept, while the objective it qualified survived and was acted on. Long queries are safe — an oversized planner request surfaces as an explicit provider-overflow failure rather than silent truncation ([#2172](https://github.com/bastani-inc/atomic/issues/2172)).
+- Cleared three advisories in the shipped dependency tree. `undici` moves 8.5.0 → 8.9.0, which covers five advisories against 8.0.0–8.8.0 — response desynchronization via the retry interceptor, two cross-user cache-directive disclosures, CRLF injection through a blob body `type`, and cookie-attribute injection — and it is the dispatcher behind `fetch_url` and every agent HTTP request. Transitively under `@modelcontextprotocol/sdk`, `ip-address` is pinned to 10.3.1 for three SSRF and trust-boundary bypasses (octal-decoded leading-zero octets, CIDR suffixes suppressing special-use classification, and misclassified IPv4-mapped/NAT64 addresses), and `hono` to 4.12.34 for a CORS-middleware ReDoS. `npm audit` is clean.
+
+- Fixed bundled builtin extensions failing to load on Windows when shared modules were evaluated twice, so bundled workflows and tools initialize correctly.
+
+## [0.9.11] - 2026-08-03
+
+Cumulative release of the `0.9.11-alpha.1` – `0.9.11-alpha.12` prereleases. The summary below covers the user-visible outcome of that work; the per-change detail remains in the prerelease sections below.
+
+### Breaking Changes
+
+- Adopted pi 0.83.0 (`@earendil-works/pi-agent-core`, `pi-ai`, `pi-tui` at `^0.83.0`), which moves the bundled TypeBox to 1.3.7 and **removes seven deprecated APIs**. Atomic inherits the removal exactly as upstream shipped it with no compatibility shim, so an extension, skill, workflow, or MCP schema still calling one of these fails to compile and to run. Atomic's own sources use none of them.
+
+  | Removed API | Replacement |
+  | --- | --- |
+  | `Type.Options(type, options)` | `Type.With(type, options)` — straight rename |
+  | `Type.Base` | `Type.Refine()` + `Type.Unsafe()` |
+  | `Type.Promise(item)` | none — model the resolved value and validate after `await` |
+  | `Type.Awaited(type)` | none — use the resolved type itself |
+  | `Type.Iterator(items)` / `Type.AsyncIterator(items)` | none — drain first, then `Type.Array(items)` |
+  | `Value.Mutate(current, next)` | `Value.Patch(current, Value.Diff(current, next))` — returns a **new** value rather than assigning in place |
+
+- Replaced Atomic's legacy extension OAuth registration bridge with provider-owned authentication from `@earendil-works/pi-ai`, and adopted pi's provider-owned `ModelRuntime` architecture for model composition, credentials, streaming, and catalog refresh. The bridge functions (`registerOAuthProvider`, `getOAuthApiKey`, and the rest) and their credential/status types are gone from the package root; `AuthStorage` now implements pi's asynchronous `CredentialStore` contract, so its synchronous compatibility methods and provider-auth helpers were removed in favour of `read`, `list`, `modify`, `delete`, and `ModelRuntime`; `ModelRegistry` is now the thin synchronous extension-compatibility facade constructed as `new ModelRegistry(runtime)`; and `CreateAgentSessionOptions` takes `modelRuntime` instead of `authStorage`/`modelRegistry`. Extensions must declare OAuth or API-key authentication on their provider registration, and `streamSimple` implementations are now scoped to their registered provider.
+- Model configuration follows pi's single-file `ModelConfig` contract: Atomic reads one `models.json` from the active agent directory and no longer reads project-scoped `.atomic/models.json`, falls back to `~/.pi/agent/models.json`, or merges layered files. Move project-scoped custom providers and models into the agent-directory file. Catalog refreshes also use pi's exact timeout semantics — `modelRefreshTimeoutMs` applies only to the initial runtime creation refresh, and `/model` owns its own 15-second timeout.
+- Removed all Atomic-specific GitHub Copilot handling; `github-copilot` is now an ordinary upstream provider sourced entirely from `pi-ai`. The live CAPI catalog fetch and disk cache, enterprise/GHE base-URL routing, the Gemini tool-schema sanitizer, the Anthropic `message_stop` SSE repair, and Copilot prompt-limit guidance are all gone. Because pi's bundled context windows can exceed what Copilot's API enforces, long sessions on affected models may overrun the server-side cap instead of compacting first ([#1608](https://github.com/bastani-inc/atomic/issues/1608)).
+- Removed the short/long context-window selection feature, which upstream pi does not have: the `contextWindowOptions` / `defaultContextWindow` / `maxInputTokens` model fields, the `/model` picker, `--context-window`, the `defaultContextWindow(s)` settings, the `set_context_window` and `get_available_context_windows` RPC commands, the `context_window_changed` event, the `contextWindow` / `contextWindowStrict` SDK and workflow-stage options, the related root exports, and the `(1m)` / `(long)` token in subagent and workflow model strings. A model's `contextWindow` is now a single catalog value.
+- Isolated interactive `ctx.ui.custom()` components that consume Ctrl+C must declare `{ handlesCtrlC: true }`. Without it the first Ctrl+C is the host escape and closes the focused component, resolving its promise with `undefined`. Bundled workflow and MCP surfaces were migrated; third-party extensions binding Ctrl+C need the one-line addition.
+- Changed the published `runVerbatimCompaction` SDK export to a request object: `runVerbatimCompaction(preparation, model, { resolveAuth, signal, thinkingLevel, urgency, ...options })`. Pre-resolved credentials become a `resolveAuth(model)` callback because a borrowed fallback model needs its own credentials, and `urgency` is required with no default so only a `load_bearing` caller can reach the context-destroying fresh rung. The persisted `CompactionEntry` shape, resume, and the compaction hooks are preserved.
+- Workflow run targets now require the full 36-character run UUID; typed prefixes are no longer resolved by any command or `runId` action, and a malformed target is rejected with a diagnostic distinct from `Run not found:` so a truncated paste is diagnosable. Stage targets are matched exactly, so `build` will not select `build-check`. Every user-facing surface already prints the full id.
+- The RPC `login_provider` response no longer carries the API key it just stored. `RpcLoginProviderResult` dropped its `credential` member; `type` confirms which kind of credential was saved.
+
+### Added
+
+- Added first-class Alpine/musl Linux support for x64 and arm64, including native search and PTY bindings and the `atomic-linux-x64-musl.tar.gz` and `atomic-linux-arm64-musl.tar.gz` archives. The musl archives omit the clipboard binding and glibc-linked `@embedded-postgres/*` binaries, so Atomic falls back to Linux clipboard commands/OSC52 and durable Alpine workflows require external Postgres.
+- Added `atomic auth print-api-key` and `atomic auth print-bearer-token`, which print exactly one named credential to stdout while every warning and diagnostic goes to stderr, so `KEY=$(atomic auth print-api-key --model gpt-5.5)` cannot capture noise. `--model` is required, `--provider` and `--model` are the only accepted options, there is no file or clipboard sink, and `print-bearer-token` refreshes a token with less than `--min-expiry` (default `30m`) remaining. Failures are distinguishable by exit code 1–9, including a partial-write exit that tells you to discard the output. Documented in `docs/usage.md` and `docs/security.md`.
+- Added a compaction rung ladder so a compaction that must succeed always does. The range planner returns typed outcomes instead of ranges-or-throw; a terminal attempt borrows the next `settings.fallbackModels` entry for one planner request resolved with that candidate's own credentials, without changing the session model or history; an overflowing planner request withholds the oldest region lines and retries; and when every model is exhausted, a load-bearing compaction starts a fresh context window — a loud (`✻ Context cleared (compaction degraded)`) and durable (`details.rung: "fresh"`) model-free rung. Manual `/compact` and threshold auto-compaction may borrow a model but can never clear context. **A configured fallback model may now receive the compaction transcript.**
+- Added a built-in, hidden llama.cpp router provider with `/login llama.cpp`, `LLAMA_BASE_URL`/`LLAMA_API_KEY` configuration, loaded-model discovery, and the `/llama` manager for load, unload, reconnect, and Hugging Face GGUF download flows.
+- Added provider-metadata-driven `/login` with direct `/login <provider>` routing and autocomplete, OpenRouter PKCE and Kimi Code device subscription login, API-key login for Qwen Token Plan, Radius, and GitHub Copilot, and immediate post-login model refresh without transporting credentials to the frontend.
+- Added Claude Opus 5 to the Anthropic and Amazon Bedrock catalog paths with adaptive thinking/`xhigh`, Bedrock inference profiles, prompt caching, and strict-tool metadata.
+- Added end-to-end constrained tool sampling to extension/SDK tool definitions and model catalogs: strict JSON Schema `prefer`/`require`, OpenAI grammar tools with Lark/regex variants, and `supportsStrictMode` / `supportsStrictTools` / `supportsOpenAIGrammarTools` flags exposed through additive optional `ModelInfo.compat` ([#1995](https://github.com/bastani-inc/atomic/issues/1995)).
+- Added execution-time session metadata to every bash execution path through `ATOMIC_SESSION_ID`, `ATOMIC_SESSION_FILE`, `ATOMIC_PROVIDER`, `ATOMIC_MODEL`, and `ATOMIC_REASONING_LEVEL` with exact `PI_*` aliases, plus request-correlated `bash_execution_update` RPC events that separate stdout from stderr and support concurrent requests and per-request cancellation ([#1995](https://github.com/bastani-inc/atomic/issues/1995)).
+- Added `ctx.scopedModels` to the extension context: the read-only list of models scoped to the current session, resolving at access time and handing back a fresh copy on every read so an extension cannot widen its own scope. Documented in `docs/extensions.md`.
+- Added durable, searchable companion transcripts for every workflow stage that declares `output:`, run-scoped durable artifact directories under `~/.atomic/workflows/runs/<runId>/` (overridable with `ATOMIC_WORKFLOW_ARTIFACT_DIR`) with state-aware retention, explicit warnings for degenerate stage artifacts, and a real artifact-integrity probe in the shared resume predicate.
+- Added extension lifecycle hooks `before_provider_headers` and `agent_settled`, durable `entry_appended` events with `registerEntryRenderer()`, named/hidden `InlineExtension` descriptors, and the public `ModelRuntime` facade, `readStoredCredential`, and session-context conversion helpers on the SDK surface.
+- Added global `httpProxy`, duration-string and `"disabled"` HTTP idle timeouts, package `autoload: false` project deltas, `oauth: "radius"` custom gateways, global/project scope switching in `atomic config`, and the `get_available_thinking_levels` RPC command.
+- Added Ctrl+X copy-last-message, clipboard text fallback when image paste finds no image, durable cache-miss attribution with waste totals, per-model session usage and cost breakdowns including tool and summary work, and Atomic's first-run theme preview with explicit analytics opt-in (no analytics data is transmitted by this change).
+
+### Changed
+
+- Reworked interactive startup and working motion around Atomic's revision-3 identity: the ∀ banner assembles inward before its identity beat, and main and workflow-stage surfaces keep the one-cell `∀` visible on a theme-aware dark → accent → bright → accent → dark luminance ramp at 88 ms while retaining all 453 randomized working verbs. `NO_COLOR` keeps regular/bold activity without color escapes, and reduced motion keeps a static accent `∀` ([#1883](https://github.com/bastani-inc/atomic/issues/1883)).
+- Made interactive startup dramatically faster on Windows: installed builds ship the builtin workflows extension as a single prebundled ESM file instead of transpiling a ~300-file module graph per launch (~7 s → ~1.1 s on a test VM), and the CLI enables Node's persistent on-disk V8 compile cache so host and engine child reuse compiled bytecode across runs ([#1962](https://github.com/bastani-inc/atomic/issues/1962)).
+- Removed the fixed 1 MiB size limit from RPC and isolated interactive-engine JSONL transport; commands, responses, events, and render frames now pass through in full ([#1985](https://github.com/bastani-inc/atomic/issues/1985)).
+- A stored OAuth token is now refreshed once fewer than five minutes of validity remain, rather than at expiry, so a long turn is not started on a credential that dies mid-request. The refresh runs inside the `auth.json` lock, so concurrent sessions refresh it once between them.
+- The OpenRouter login now accepts a pasted final redirect URL, or the authorization code alone, for remote and headless machines where the browser cannot reach the loopback callback.
+- A provider that ends a turn with an unrecognised terminal reason now surfaces a provider error naming the raw reason instead of reporting an ordinary successful stop, and assistant messages carry a new `pending` stop reason while streaming. Documented in `docs/providers.md`, `docs/custom-provider.md`, `docs/rpc.md`, and `docs/session-format.md`.
+- Workflow run identifiers are shown as full UUIDs across the BACKGROUND widget, status views, run pickers, and control messages; the four-workflow BACKGROUND display cap is gone; and `workflow({ action: "status", format: "json" })` no longer includes `runIdPrefix` — read `runId`.
+- Added Orwell's six writing rules from "Politics and the English Language" to the core default system prompt's `Guidelines` section, and the startup `RESOURCES` disclosure now lists `SYSTEM.md` and `APPEND_SYSTEM.md` alongside the `AGENTS.md`/`CLAUDE.md` context files.
+- Synchronized the bundled `impeccable` skill tree with upstream 4.0.3 (four surface modes, new routing and craft-floor guidance, a `doctor` drift check, documenter and finish-reviewer agents), and verified the `playwright-cli` and `liteparse` trees against their upstream baselines.
+- Updated the bundled user documentation for the current subagent, workflow-stage, reviewer, and `prompt-engineer` prompt contracts, removing response prefilling and private-reasoning requests for GPT-5.6, Claude Opus 5, and Claude Fable 5 compatibility.
+
+### Fixed
+
+- Fixed the isolated interactive engine losing or duplicating your typed input. A submission the engine never accepted now returns to the editor exactly as typed — through every submit route, including `/atomic`, deferred slash commands, streaming steer sends, `!bash`, `/compact`, and Alt+Enter — with its own draft carried end to end so two similar submissions cannot restore each other's text, and without a misleading red transport error beside it. Work the engine *had* started is no longer offered back as unsent: the child announces ownership of every correlated request before its handler can touch the shell, so a silent `!touch marker && sleep 400` is not re-invited for a second run. The interactive-engine protocol version is now `2`.
+- Fixed a total interactive-TUI lockup when the engine generation behind a mounted remote custom UI died, which previously left components mounted forever with input trapped and required killing the process from another terminal. Engine death is now a host-local lifecycle event that closes every remote component from the dead generation, settles its promises, releases widget keys, resets terminal modes, and refocuses the editor without waiting for a replacement.
+- Fixed interrupting a tool call terminating the interactive engine and reporting `Engine terminated; … result unknown`. Escape now simply requests cooperative cancellation and waits for it — interrupting never terminates or restarts the engine and never discards in-flight tool state — and every cooperative-cancellation command (`abort`, `abort_bash`, `abort_compaction`, `abort_retry`, `cancel_login_provider`) is exempt from the generic 30-second RPC deadline.
+- Added recovery from an unexpected interactive-engine exit — one automatic replacement attempt with the calm status `Interactive engine stopped unexpectedly; restarting.` — and kept an explicit Ctrl+C escape hatch for a provably wedged engine. Reopening an inactive session after such an exit now derives explicit error results for unanswered `toolUse` calls without rewriting its append-only JSONL, so the session is usable again instead of permanently pending.
+- Fixed the interactive engine exporting its private control values (`ATOMIC_INTERACTIVE_ENGINE_CHILD`, `_HOST_PID`, `_GUARD_FILE`, `_API_KEY`) to every process it spawned, which made nested `atomic` runs start in engine mode, misdirected process guardians, disabled subagent idle watchdogs, and leaked an `--api-key` credential to every child. Those values now travel in an owner-only bootstrap file read once and unlinked by the child.
+- Fixed OAuth logins being destroyed by an unrelated model-catalog refresh. A timed-out or partially failed post-login refresh used to roll freshly acquired tokens back to the previous credential and — because providers rotate refresh tokens — could permanently strand the account behind repeating `invalid_grant` failures. Freshly persisted credentials now always survive the refresh.
+- Fixed `/model` and `/logout` hanging. The selector's 15-second abort now crosses the engine RPC boundary and covers credential reload, model refreshes run in a concurrent correlated lane so selection stays responsive, and `/logout` publishes credential removal immediately instead of timing out after it had already deleted the credential. Newly authenticated providers also appear without a restart ([#1918](https://github.com/bastani-inc/atomic/issues/1918)).
+- Fixed Anthropic subscription login on Bun-hosted Linux sessions remaining at `Exchanging authorization code for tokens...`, caused by Bun not exposing Undici's CommonJS `install()` helper through its ESM namespace, so the configured transport was silently never used.
+- Fixed RPC `save_provider_credential` writes disappearing after restart (they were stored as non-persistent runtime overrides), `ANTHROPIC_AUTH_TOKEN` header-only bearer authentication being rejected across catalog and request paths, and GitHub Copilot requests failing with `421 Misdirected Request` for `COPILOT_GITHUB_TOKEN` users on business, enterprise, and GHE tenants ([#1995](https://github.com/bastani-inc/atomic/issues/1995)).
+- Fixed a mid-turn compaction leaving the turn unsendable, which the provider rejected with an unrecoverable `400 ... each tool_use must have a single result`. The post-tool preflight returned the agent's live internal message array, so every later turn duplicated assistant messages and tool results; it now returns its own copy, with provider-side deduplication and a descriptive pre-conversion guard as defence in depth ([#2051](https://github.com/bastani-inc/atomic/issues/2051)).
+- Fixed reasoning tokens being able to fail a compaction outright. The planner capped its own request at `0.8 × reserveTokens` — an input-side reserve reused as an output cap — so a high-reasoning session could spend the whole budget thinking and return no deletion records, killing the active turn during a mid-turn preflight. The planner now sends no `max_tokens` at all; branch summarization received the same fix.
+- Fixed compaction rebuilding the retained recent messages as structured blocks after the boundary, which could produce out-of-order provider blocks and a rejected request. The `preserve_recent` tail is now serialized with the same transcript grammar and concatenated onto the boundary, losslessly: retained tool results keep their full text and retained images stay as image blocks.
+- Fixed repeated `/compact` presses starting several overlapping compactions. `AgentSession.compact()` is now single-flight — a second manual request joins the run in flight rather than emitting a duplicate boundary — and messages queued before an automatic compaction no longer stay stuck until Escape ([#1984](https://github.com/bastani-inc/atomic/issues/1984)).
+- Fixed `/reload` re-transpiling and re-evaluating the entire transitive TypeScript graph of every extension on Windows and in compiled builds even when nothing changed. A per-extension SHA256 graph manifest now lets an unchanged graph reuse its evaluated factory; reloading the five builtin packages drops from ~25 s cold / ~16 s warm to ~90 ms ([#2069](https://github.com/bastani-inc/atomic/issues/2069)).
+- Fixed interactive startup crashing with `Interactive engine did not become ready within 5000 ms` on machines with slow cold starts; the fixed deadline is removed while a dead process or broken transport still fails fast ([#1962](https://github.com/bastani-inc/atomic/issues/1962)).
+- Fixed the external editor failing on Windows whenever the editor path, its arguments, or the temporary prompt path contained a space, and fixed the compiled package CLI crashing before TUI startup when invoked from another working directory ([#1995](https://github.com/bastani-inc/atomic/issues/1995)).
+- Fixed physical Escape and Ctrl+C depending on the configurable `app.clear` action, which could send Escape to the engine stop branch and strip Ctrl+C of its host route. Both are now matched by physical key identity, and a single Ctrl+C again dismisses the `/login` popups instead of clearing the hidden editor and risking a double-press exit.
+- 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, and fixed a startup session switch rendering every agent event twice.
+- Fixed inherited `.pi` extensions conflicting with Atomic-bundled resources, extension-contributed skills, prompts, and themes losing their package source metadata after a resource reload, and a nested linked git worktree loading the repository's `AGENTS.md`/`CLAUDE.md` twice ([#1955](https://github.com/bastani-inc/atomic/issues/1955)).
+- Fixed workflow reliability from the parent-session side: stage `output:` no longer lost to an admitted external turn, `reads:` references fail loudly when an artifact is missing instead of handing the model an empty file, the resume picker stops offering stale or non-resumable runs, fast named workflows no longer leave a stale "still running" claim, queued work no longer escapes a controlled pause ([#1983](https://github.com/bastani-inc/atomic/issues/1983)), and tool-only workflows are no longer reported failed after their durable side effects completed ([#1991](https://github.com/bastani-inc/atomic/issues/1991)).
+- Fixed the RPC `bash` command bypassing extension `user_bash` handlers, so sandbox and remote-shell extensions see an RPC request exactly as they see `user_bash`.
+- Fixed a failed `git` package install leaving a half-written checkout that silently suppressed the next repair, and hardened the archive and SQLite path-selector parsers against polynomial-time regex backtracking (CodeQL `js/polynomial-redos`) with no change to accepted selector syntax.
+- Fixed PDF extraction dropping text and streaming `TypeError: Math.sumPrecise is not a function` on Node runtimes without `Math.sumPrecise` by exact-pinning `unpdf` to `1.7.0` instead of letting it float to 1.8.0 ([#2141](https://github.com/bastani-inc/atomic/issues/2141)).
+
+## [0.9.11-alpha.12] - 2026-08-03
+
+### Fixed
+
+- Fixed PDF extraction dropping text and streaming `TypeError: Math.sumPrecise is not a function` warnings on Node runtimes that do not implement `Math.sumPrecise`. The `unpdf` dependency was declared as the floating range `^1.6.2`, which resolves to 1.8.0 in a published or global install; that release's bundled PDF.js v6.1 dropped the guarded fallback and calls the builtin unconditionally, so extraction threw per glyph, emitted font-substitution warnings, and silently returned fewer text items. `unpdf` is now exact-pinned to `1.7.0`, the newest release that still ships the fallback, so no install can float to 1.8.0 ([#2141](https://github.com/bastani-inc/atomic/issues/2141)).
+- Upgraded the pinned `unpdf` from 1.6.2 to 1.7.0, which adds `cMapUrl` CJK font support under Node, destroys internally created document proxies and canvas resources, and preserves line breaks in `extractText` with `mergePages`.
+
+## [0.9.11-alpha.11] - 2026-08-03
+
+### Breaking Changes
+
+- Workflow run targets now require the full 36-character run UUID. Typed prefixes are no longer resolved by any command or workflow-tool action that accepts `runId`, including `status`, `stages`, `stage`, `transcript`, `send`, `pause`, `resume`, `interrupt`, and `quit`, and by `/workflow connect`, `/workflow attach`, and `/workflow resume`. A target that is not a well-formed 8-4-4-4-12 hex UUID — a prefix, a 32-character dashless id, or a same-length non-hex string — is rejected with `Run id must be a full 36-character UUID; got "339e05a4" (8 chars).`, which is deliberately distinct from `Run not found:` so a truncated paste is diagnosable as truncated rather than looking like a stale run. Since every user-facing surface already prints the full id, copy it back verbatim. Because ids are unique and now matched exactly, run-target ambiguity is unreachable and the "Ambiguous run prefix" diagnostic is gone.
+- Stage targets are now matched exactly. A `stageId` resolves by exact stage id — a bare UUID at the root, the full `runId:stageId` composite for a stage inside a nested `ctx.workflow(...)` import, or `tool:<argsHash>` for a `ctx.tool` node — or by exact stage or tool name. Prefixes and partial names no longer resolve, so `build` will not select `build-check`. Stage ids are deliberately **not** held to the 36-character rule, because nested and tool identifiers are legitimately longer or differently shaped; nested-stage and tool-node targeting are unchanged. Two stages sharing an exact name still return the existing ambiguity diagnostic.
+
+### Changed
+
+- Removed the four-workflow display cap from the BACKGROUND widget so every qualifying top-level run is rendered.
+- Moved durable workflow run artifacts—including goal ledgers, Ralph implementation notes, QA evidence video paths, and worktree task outputs—from per-invocation OS temp directories to the run-scoped durable root under the Atomic config directory (`~/.atomic/workflows/runs/<runId>/`, overridable with `ATOMIC_WORKFLOW_ARTIFACT_DIR`), so they survive OS temp purges and follow state-aware retention.
+- Toggling tool-output expansion (`ctrl+o`) no longer prints a `Tool output: expanded` / `Tool output: collapsed` status line. The chat re-renders in the new state, which is the same information without the extra line.
+
+- Workflow run identifiers are now shown as full UUIDs across the BACKGROUND widget, status and detail views, run pickers, control messages, and awaiting-input attribution banners. BACKGROUND cards use a two-line identity layout at 80 columns and wider, while narrow chat surfaces wrap full ids without cutting them or breaking their borders. The public `workflow({ action: "status", format: "json" })` payload no longer includes `runIdPrefix`; read `runId` instead, which now carries the full id. The `/workflow connect` run picker now shows five runs at a time and scrolls to additional retained runs with the arrow keys or mouse wheel. The picker's type-to-filter box still narrows by name substring or id prefix, since that selects a row from a list rather than resolving a typed id.
+
+### Fixed
+
+- Fixed Escape aborts restoring queued steering and follow-up messages to the editor in the main interactive chat and attached workflow-stage chats instead of leaving them stuck in the pending-message queue.
+- Fixed `/model <model_name>` waiting indefinitely when a model-catalog refresh never settles; it now stops after the interactive 15-second deadline and searches cached models.
+- Quit workflow cards now expire from the BACKGROUND widget after the same recent-run window as finished cards while remaining resumable and discoverable through workflow status; the header count now matches the rendered cards after expiry.
+- Fixed detached foreground subagent completion notifications rendering as an unstyled dump of the full child output. They now use the same structured, collapsed notification UI as background completions while preserving the distinct detached-task wording, and persisted notifications with custom labels remain parseable.
+- Fixed workflow-stage re-attach status falling back to `Working...` while context compaction is still active; the active compaction reason now survives host remounts so manual compaction, threshold auto-compaction, and overflow recovery retain their factual status labels.
+- Fixed workflow stage file output being lost when an admitted external turn (for example an async subagent completion) arrived while the stage was still running: the deterministic `output:` write re-derived its content from session state at close time, so a trailing acknowledgement could overwrite the stage's real deliverable. Every stage that declares `output:` now also gets a durable, searchable companion transcript outside the repository tree, and the receipt names both paths with the intended access pattern, so the work remains recoverable regardless of which turn was persisted. The runner does not attempt to infer which turn was the intended deliverable; it writes the stage's final assistant message, and the receipt reports one fact only — an empty artifact.
+- Fixed the workflow resume picker offering stale or non-resumable runs. Picker and command paths now share one resumability predicate and revalidate durable state before displaying a target, while explicit ids retain their explanatory rejection.
+- Fixed workflow `reads:` references to fail loudly when an artifact path no longer exists instead of handing the model an empty, silently missing context file.
+- Fixed relayed terminal subagent results retaining their stable stage-admission identity when delivered through the intercom ordering barrier, so an acknowledgement turn cannot arrive without the admission marker that identifies it in a running stage's companion transcript.
+- Fixed a failed companion-transcript write reporting a bogus `Output file error` for an output artifact that was written correctly, and returning the full stage text under `outputMode: "file-only"` instead of the compact reference. A transcript failure now degrades to a warning naming the transcript path while the saved-output reference is unchanged, and artifact-retention pruning failures no longer propagate into the stage receipt.
+- Fixed `createWorkflowArtifactDirectory()` attributing artifacts to the ambient most-recently-started run rather than the workflow that created them, and returning one shared directory whose fixed artifact filenames could overwrite each other. Every builtin call site now passes its owning run id, and each call receives a unique directory beneath that run.
+- Fixed the workflow resume picker re-offering a live run as a durable row after the shared resumability predicate rejected it for missing artifacts or checkpoints. Rejected non-running snapshots are now suppressed from live and durable resumable rows, while completed inspection rows remain available; active-running snapshots retain their existing durable fallback.
+
+### Added
+- Added first-class Alpine/musl Linux support for x64 and arm64, including native search and PTY bindings and the `atomic-linux-x64-musl.tar.gz` and `atomic-linux-arm64-musl.tar.gz` release archives. The musl archives omit the clipboard native binding and glibc-linked `@embedded-postgres/*` binaries: Atomic falls back to Linux clipboard commands/OSC52, while durable Alpine workflows require external Postgres via `DBOS_SYSTEM_DATABASE_URL` or Docker; otherwise the existing loud non-durable in-memory fallback applies.
+- Added state-aware retention for durable workflow artifact directories: only terminal or unowned runs older than `WORKFLOW_ARTIFACT_RETENTION_MS` are pruned, while running, paused, quit, blocked, and awaiting-input runs keep live resume dependencies. Aging out a terminal run now deletes its durable entry first and removes the artifact directory only when that deletion succeeds, so a surviving durable record can never reference deleted files.
+- Added durable, searchable companion transcripts for every workflow stage that declares `output:`. The caller's receipt names both the artifact and transcript paths and says to search with `rg`, read narrow line ranges, and never read the transcript whole; under `outputMode: "file-only"`, that receipt is the entire handoff.
+- Added explicit warnings for degenerate stage artifacts instead of silently persisting them: an empty write or a write that only points to its own output path directs the reader to the companion transcript.
+- Added a real artifact-integrity probe to the shared resume predicate. A run whose snapshot references a run-scoped artifact path is offered for resume only while that run directory still exists, and durable-checkpoint eligibility is supplied from the authoritative loadable check, so `/workflow resume` matches the documented behaviour instead of relying on flags no caller set.
+
+## [0.9.11-alpha.10] - 2026-08-01
+
+### Fixed
+
+- Fixed an isolated interactive-engine exit after an admitted tool call leaving that session permanently pending and unusable on resume. Reopening an inactive session now derives explicit error results for unanswered `toolUse` calls without rewriting its append-only JSONL, so the transcript can render, compact, and accept another prompt while preserving that the interrupted command's side effects are unknown. Unexpected-restart notices now also retain the bounded exit kind, code, or signal that triggered recovery while excluding child stderr.
+- Fixed Anthropic subscription login on Bun-hosted Linux sessions remaining at `Exchanging authorization code for tokens...`. Atomic's HTTP setup relied on Undici's CommonJS `install()` helper, but Bun does not expose that helper through its ESM namespace, so source-mode and compiled interactive-engine processes silently kept Bun's native `fetch` instead of the configured Undici transport. Atomic now installs the exported Undici web globals explicitly under Bun. Login completion also ends when the provider credential is persisted and publishes that provider against the already-loaded model snapshot immediately; cache restoration, ambient availability checks, and catalog discovery no longer run inside the successful credential transaction, so none can keep the login dialog open after the provider appears in `auth.json`.
+- Fixed existing authenticated users being unable to select a model, or seeing `Refreshing model catalogs…` indefinitely, after an isolated or direct `/model` refresh stalled. The frontend's 15-second abort previously never crossed the engine RPC boundary, the engine started its deadline only after an unbounded credential/availability reload, and the selector assumed refresh work would honor cancellation. The shared deadline now covers credential reload and catalog work inside the engine, the selector races that deadline itself and replaces the progress state on both timeout and rejection, and model refreshes use a concurrent correlated lane so selection remains responsive while catalogs update. Existing `auth.json` credentials remain compatible and no `~/.atomic` reset is required.
+- Fixed `/logout` timing out after it had already deleted the credential, leaving the provider in `/model` until restart and preventing the selector from reopening. Logout now publishes credential removal immediately, skips post-logout catalog refreshes, bounds the local probe for authentication that remains in the environment, and prevents a model refresh started before the mutation from overwriting the newer login or logout snapshot when it eventually settles.
+
 ## [0.9.11-alpha.9] - 2026-08-01
 
 ### Breaking Changes

package/README.md

@@ -79,7 +79,7 @@ atomic
 
 Then just talk to Atomic. By default, Atomic gives the model six coding tools: `read`, `write`, `edit`, `bash`, `find`, and `search`. The model uses these to fulfill your requests. `read`, `search`, `write`, and successful `edit` calls emit session-scoped hashline anchors (`[path#TAG]` plus `LINE:text`) so the model can make stale-safe line edits; see [docs/tools.md](docs/tools.md). Add capabilities via [skills](#skills), [prompt templates](#prompt-templates), [extensions](#extensions), or [Atomic packages](#atomic-packages).
 
-**Platform notes:** [Windows](docs/windows.md) | [Termux (Android)](docs/termux.md) | [tmux](docs/tmux.md) | [Terminal setup](docs/terminal-setup.md) | [Shell aliases](docs/shell-aliases.md)
+**Platform notes:** [Windows](docs/windows.md) | [Alpine/musl Linux](docs/index.md#alpine-and-musl-linux-archives) | [Termux (Android)](docs/termux.md) | [tmux](docs/tmux.md) | [Terminal setup](docs/terminal-setup.md) | [Shell aliases](docs/shell-aliases.md)
 
 ---
 

package/dist/builtin/intercom/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to the `pi-intercom` extension will be documented in this fi
 
 ## [Unreleased]
 
+## [0.9.12-alpha.1] - 2026-08-04
+
+### Fixed
+
+- Fixed bundled Intercom resources failing to load on Windows when shared modules used mixed `.ts` and `.js` import spellings.
+
+## [0.9.11] - 2026-08-03
+
+### Changed
+
+- Released with Atomic 0.9.11. No functional intercom changes since 0.9.10; the extension now runs under the reworked isolated-engine and workflow-group behaviour shipped by the host.
+
 ## [0.9.11-alpha.1] - 2026-07-20
 
 ### Changed

package/dist/builtin/intercom/closed-workflow-stage-message.ts

@@ -3,7 +3,7 @@ import type { InboundMessageAdmission } from "./inbound-message-admission.js";
 import type { InboundMessageEntry } from "./intercom-utils.js";
 import { routeIncomingReply } from "./reply-routing.js";
 import type { ReplyTracker } from "./reply-tracker.js";
-import type { ReplyWaiterRecord } from "./reply-waiter.js";
+import type { ReplyWaiterRecord } from "./reply-waiter.ts";
 import { retryStableDelivery } from "./stable-delivery-retry.js";
 import { sendWorkflowStageDeliveryFailure } from "./workflow-stage-delivery-failure.js";
 

package/dist/builtin/intercom/contact-supervisor-tool.ts

@@ -2,7 +2,7 @@ import type { ExtensionAPI } from "@bastani/atomic";
 import { randomUUID } from "crypto";
 import { Type } from "typebox";
 import { Text } from "@earendil-works/pi-tui";
-import type { IntercomClient } from "./broker/client.ts";
+import type { IntercomClient } from "./broker/client.js";
 import type { ReplyWait, ReplyWaitAdmission } from "./reply-waiter.ts";
 import { renderContactSupervisorResult } from "./result-renderers.js";
 import {

package/dist/builtin/intercom/index-heavy.ts

@@ -3,10 +3,10 @@ import { appendFileSync } from "node:fs";
 import { IntercomClient } from "./broker/client.js";
 import { spawnBrokerIfNeeded } from "./broker/spawn.js";
 import { InlineMessageComponent } from "./ui/inline-message.js";
-import { loadConfig, type IntercomConfig } from "./config.js";
+import { loadConfig, type IntercomConfig } from "./config.ts";
 import type { SessionInfo, Message } from "./types.js";
 import { ReplyTracker } from "./reply-tracker.js";
-import { ReplyWaiterSlot } from "./reply-waiter.js";
+import { ReplyWaiterSlot } from "./reply-waiter.ts";
 import { registerContactSupervisorTool } from "./contact-supervisor-tool.js";
 import { registerIntercomTool } from "./intercom-tool.js";
 import { registerIntercomOverlay } from "./overlay.js";

package/dist/builtin/intercom/intercom-tool.ts

@@ -2,7 +2,7 @@ import type { ExtensionAPI } from "@bastani/atomic";
 import { randomUUID } from "crypto";
 import { Type } from "typebox";
 import { Text } from "@earendil-works/pi-tui";
-import type { IntercomClient } from "./broker/client.ts";
+import type { IntercomClient } from "./broker/client.js";
 import type { ReplyWait, ReplyWaitAdmission } from "./reply-waiter.ts";
 import { renderIntercomResult } from "./result-renderers.js";
 import {
@@ -12,7 +12,7 @@ import {
   previewText,
   toError,
 } from "./intercom-utils.js";
-import type { ReplyTracker } from "./reply-tracker.ts";
+import type { ReplyTracker } from "./reply-tracker.js";
 import { resolveSessionTargetId } from "./session-target.js";
 import { normalizeGroup } from "./group.js";
 

package/dist/builtin/intercom/intercom-utils.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI } from "@bastani/atomic";
 import { APP_NAME, getEnvValue } from "@bastani/atomic";
-import type { Attachment, Message, SessionInfo, SupervisorRegistration } from "./types.ts";
+import type { Attachment, Message, SessionInfo, SupervisorRegistration } from "./types.js";
 import { DEFAULT_GROUP, normalizeGroup } from "./group.js";
 
 

package/dist/builtin/intercom/lifecycle.ts

@@ -1,9 +1,9 @@
 import type { ExtensionAPI, ExtensionContext } from "@bastani/atomic";
-import type { IntercomClient } from "./broker/client.ts";
+import type { IntercomClient } from "./broker/client.js";
 import type { IntercomConfig } from "./config.ts";
 import { buildPresenceIdentity } from "./intercom-utils.js";
 import type { InboundIdleQueue } from "./inbound-idle-queue.js";
-import type { ReplyTracker } from "./reply-tracker.ts";
+import type { ReplyTracker } from "./reply-tracker.js";
 
 interface LifecycleDeps {
   config: IntercomConfig;

package/dist/builtin/intercom/overlay.ts

@@ -1,9 +1,9 @@
 import type { ExtensionAPI, ExtensionContext } from "@bastani/atomic";
-import type { IntercomClient } from "./broker/client.ts";
+import type { IntercomClient } from "./broker/client.js";
 import type { ComposeResult } from "./ui/compose.ts";
 import { ComposeOverlay } from "./ui/compose.ts";
 import { SessionListOverlay } from "./ui/session-list.ts";
-import type { SessionInfo } from "./types.ts";
+import type { SessionInfo } from "./types.js";
 import { duplicateSessionNames, formatSessionLabel, getErrorMessage } from "./intercom-utils.js";
 
 interface OverlayDeps {

package/dist/builtin/intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/intercom",
-  "version": "0.9.11-alpha.9",
+  "version": "0.9.12-alpha.1",
   "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/intercom/reply-tracker.ts

@@ -1,4 +1,4 @@
-import type { Message, SessionInfo } from "./types.ts";
+import type { Message, SessionInfo } from "./types.js";
 import { resolveSessionTarget, sessionTargetFailureReason } from "./session-target.js";
 
 export interface IntercomContext {

package/dist/builtin/intercom/subagent-relay.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI, ExtensionContext } from "@bastani/atomic";
 import { randomUUID } from "crypto";
-import type { IntercomClient } from "./broker/client.ts";
-import type { SessionInfo, Message } from "./types.ts";
+import type { IntercomClient } from "./broker/client.js";
+import type { SessionInfo, Message } from "./types.js";
 import {
   SUBAGENT_CONTROL_INTERCOM_EVENT,
   SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT,
@@ -33,6 +33,7 @@ async function dispatchRelayFallback(
   pi: ExtensionAPI,
   prefix: Array<{ customType: string; content: string; display: boolean; details?: unknown }>,
   terminalMessage: { customType: string; content: string; display: boolean; details?: unknown },
+  stageAdmissionKey: string,
 ): Promise<void> {
   let delivered = 0;
   try {
@@ -40,7 +41,7 @@ async function dispatchRelayFallback(
       await pi.sendMessage(message, { deliverAs: "steer" });
       delivered += 1;
     }
-    await pi.sendMessage(terminalMessage, { triggerTurn: true });
+    await pi.sendMessage(terminalMessage, { triggerTurn: true, stageAdmissionKey });
   } catch (error) {
     const failure = new Error(error instanceof Error ? error.message : String(error), { cause: error });
     Object.assign(failure, { terminalPreludeDelivered: delivered });
@@ -57,6 +58,7 @@ export function registerSubagentRelay(pi: ExtensionAPI, deps: SubagentRelayDeps)
     status: string,
     messageText: string,
     terminalBarrier?: { runId: string; terminalId?: string; sourceSessionTargets: string[] },
+    requestId?: string,
   ): Promise<void> {
     const now = Date.now();
     const entry = {
@@ -82,10 +84,11 @@ export function registerSubagentRelay(pi: ExtensionAPI, deps: SubagentRelayDeps)
             display: true,
             details: entry,
           };
+          const stageAdmissionKey = `intercom:${requestId ?? entry.message.id}`;
           if (typeof pi.sendMessages === "function") {
-            return pi.sendMessages([...prefix, terminalMessage], { triggerTurn: true });
+            return pi.sendMessages([...prefix, terminalMessage], { triggerTurn: true, stageAdmissionKey });
           }
-          return dispatchRelayFallback(pi, prefix, terminalMessage);
+          return dispatchRelayFallback(pi, prefix, terminalMessage, stageAdmissionKey);
         },
       };
       Object.defineProperty(payload, "terminalOwner", { value: pi });
@@ -139,13 +142,13 @@ export function registerSubagentRelay(pi: ExtensionAPI, deps: SubagentRelayDeps)
           void delivery.catch(() => {});
           localDeliveriesInFlight.set(parsed.requestId, { signature, completion: delivery });
           try {
-            void deliverLocalSubagentRelayMessage(options.sender, options.status, parsed.message, options.terminalBarrier).then(deferred.resolve, deferred.reject);
+            void deliverLocalSubagentRelayMessage(options.sender, options.status, parsed.message, options.terminalBarrier, parsed.requestId).then(deferred.resolve, deferred.reject);
           } catch (error) {
             deferred.reject(error);
           }
           void delivery.finally(() => { localDeliveriesInFlight.delete(parsed.requestId!); }).catch(() => {});
         } else if (!delivery) {
-          delivery = deliverLocalSubagentRelayMessage(options.sender, options.status, parsed.message, options.terminalBarrier);
+          delivery = deliverLocalSubagentRelayMessage(options.sender, options.status, parsed.message, options.terminalBarrier, parsed.requestId);
         }
         await delivery;
         if (parsed.requestId) localDeliveries.record(parsed.requestId, signature);

package/dist/builtin/mcp/CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.12-alpha.1] - 2026-08-04
+
+### Fixed
+
+- Fixed bundled MCP resources failing to load on Windows when shared modules used mixed `.ts` and `.js` import spellings.
+
+## [0.9.11] - 2026-08-03
+
+### Removed
+
+- Removed Cursor MCP configuration discovery and the `cursor` compatibility import kind ([#1994](https://github.com/bastani-inc/atomic/issues/1994)).
+
+### Fixed
+
+- Declared `handlesCtrlC` on the `/mcp` panel, the `/mcp setup` panel, and the MCP OAuth panel, so Ctrl+C still reaches each panel's own handler — and its cancel and cleanup work — in isolated interactive sessions.
+
 ## [0.9.11-alpha.9] - 2026-08-01
 
 ### Fixed

package/dist/builtin/mcp/apps-cancellation.ts

@@ -1,5 +1,5 @@
 import type { UiSessionRuntime } from "./ui-session.js";
-import { logger } from "./logger.js";
+import { logger } from "./logger.ts";
 
 function formatCancellationReason(signal: AbortSignal): string {
   const reason = signal.reason;

package/dist/builtin/mcp/commands.ts

@@ -1,5 +1,5 @@
 import type { ExtensionAPI, ExtensionContext } from "@bastani/atomic";
-import type { McpExtensionState } from "./state.ts";
+import type { McpExtensionState } from "./state.js";
 import type { McpAuthResult, McpConfig, ServerEntry, McpPanelCallbacks, McpPanelResult, ImportKind } from "./types.ts";
 import {
   ensureCompatibilityImports,
@@ -12,13 +12,13 @@ import {
   writeSharedServerEntry,
   writeStarterProjectConfig,
 } from "./config.ts";
-import { lazyConnect, updateMetadataCache, updateStatusBar, getFailureAgeSeconds } from "./init.ts";
-import { loadMetadataCache } from "./metadata-cache.ts";
-import { buildToolMetadata } from "./tool-metadata.ts";
-import { supportsOAuth, authenticate, removeAuth } from "./mcp-auth-flow.ts";
-import { getAuthForUrl } from "./mcp-auth.ts";
+import { lazyConnect, updateMetadataCache, updateStatusBar, getFailureAgeSeconds } from "./init.js";
+import { loadMetadataCache } from "./metadata-cache.js";
+import { buildToolMetadata } from "./tool-metadata.js";
+import { supportsOAuth, authenticate, removeAuth } from "./mcp-auth-flow.js";
+import { getAuthForUrl } from "./mcp-auth.js";
 import { loadOnboardingState, markSetupCompleted as persistSetupCompleted, markSharedConfigHintShown } from "./onboarding-state.ts";
-import { openPath } from "./utils.ts";
+import { openPath } from "./utils.js";
 
 export async function showStatus(state: McpExtensionState, ctx: ExtensionContext): Promise<void> {
   if (!ctx.hasUI) return;

package/dist/builtin/mcp/direct-tool-executor.ts

@@ -1,6 +1,6 @@
 import type { AgentToolResult, AgentToolUpdateCallback, ExtensionContext } from "@bastani/atomic";
 import type { McpExtensionState } from "./state.js";
-import type { DirectToolSpec, McpContent } from "./types.js";
+import type { DirectToolSpec, McpContent } from "./types.ts";
 import { getFailureAgeSeconds, lazyConnect } from "./init.js";
 import { formatSchema } from "./tool-metadata.js";
 import { transformMcpContent } from "./tool-registrar.js";

package/dist/builtin/mcp/direct-tools.ts

@@ -1,8 +1,8 @@
-import type { DirectToolSpec, McpConfig } from "./types.js";
+import type { DirectToolSpec, McpConfig } from "./types.ts";
 import type { MetadataCache } from "./metadata-cache.js";
 import { isServerCacheValid } from "./metadata-cache.js";
-import { formatToolName, isToolExcluded } from "./types.js";
-import { resourceNameToToolName } from "./resource-tools.js";
+import { formatToolName, isToolExcluded } from "./types.ts";
+import { resourceNameToToolName } from "./resource-tools.ts";
 
 const BUILTIN_NAMES = new Set(["read", "bash", "edit", "write", "grep", "find", "search", "ls", "mcp"]);
 

package/dist/builtin/mcp/host-html-template.ts

@@ -1,4 +1,4 @@
-import type { UiHostContext, UiResourceContent, UiResourceCsp } from "./types.js";
+import type { UiHostContext, UiResourceContent, UiResourceCsp } from "./types.ts";
 
 // Use locally bundled AppBridge to avoid CDN Zod bundling issues
 const DEFAULT_APP_BRIDGE_MODULE_URL = "/app-bridge.bundle.js";

package/dist/builtin/mcp/index.ts

@@ -1,6 +1,6 @@
 import type { AgentToolUpdateCallback, ExtensionAPI, ExtensionContext, ToolInfo } from "@bastani/atomic";
 import type { McpExtensionState } from "./state.js";
-import type { McpConfig } from "./types.js";
+import type { McpConfig } from "./types.ts";
 import type { MetadataCache } from "./metadata-cache.js";
 import type { ProxyToolResult } from "./proxy-types.js";
 import { waitForCaller } from "./caller-wait.js";
@@ -8,7 +8,7 @@ import { McpSessionCleanupBarrier } from "./session-cleanup-barrier.js";
 import { McpStateChangedError } from "./state-lease.js";
 import { registerMcpCommands } from "./command-registration.js";
 import { Type } from "typebox";
-import { loadMcpConfig } from "./config.js";
+import { loadMcpConfig } from "./config.ts";
 import { getConfigPathFromArgv } from "./utils.js";
 import { renderMcpToolResult } from "./tool-result-renderer.js";
 
@@ -57,7 +57,7 @@ export default function mcpAdapter(pi: ExtensionAPI) {
     cache: MetadataCache | null,
   ): Promise<{ directToolCount: number; missingConfiguredDirectToolServers: string[] }> {
     const [{ resolveDirectTools, createDirectToolExecutor, getMissingConfiguredDirectToolServers }, { truncateAtWord }] = await Promise.all([
-      import("./direct-tools.js"),
+      import("./direct-tools.ts"),
       import("./utils.js"),
     ]);
     const prefix = config.settings?.toolPrefix ?? "server";

package/dist/builtin/mcp/init.ts

@@ -1,10 +1,10 @@
 import type { ExtensionAPI, ExtensionContext } from "@bastani/atomic";
 import type { McpExtensionState } from "./state.js";
-import type { ToolMetadata } from "./types.js";
+import type { ToolMetadata } from "./types.ts";
 import { existsSync } from "node:fs";
-import { loadMcpConfig } from "./config.js";
+import { loadMcpConfig } from "./config.ts";
 import { ConsentManager } from "./consent-manager.js";
-import { McpLifecycleManager } from "./lifecycle.js";
+import { McpLifecycleManager } from "./lifecycle.ts";
 import {
   computeServerHash,
   getMetadataCachePath,
@@ -16,11 +16,11 @@ import {
   serializeTools,
   type ServerCacheEntry,
 } from "./metadata-cache.js";
-import { McpServerManager } from "./server-manager.js";
+import { McpServerManager } from "./server-manager.ts";
 import { buildToolMetadata, totalToolCount } from "./tool-metadata.js";
-import { UiResourceHandler } from "./ui-resource-handler.js";
+import { UiResourceHandler } from "./ui-resource-handler.ts";
 import { openUrl, parallelLimit } from "./utils.js";
-import { logger } from "./logger.js";
+import { logger } from "./logger.ts";
 
 const FAILURE_BACKOFF_MS = 60 * 1000;
 

package/dist/builtin/mcp/mcp-auth-flow.ts

@@ -23,7 +23,7 @@ import {
   type StoredTokens,
 } from "./mcp-auth.js"
 import { McpSessionCleanupBarrier } from "./session-cleanup-barrier.js"
-import type { ServerEntry } from "./types.js"
+import type { ServerEntry } from "./types.ts"
 
 export type AuthStatus = "authenticated" | "expired" | "not_authenticated"
 

package/dist/builtin/mcp/mcp-callback-server.ts

@@ -12,7 +12,7 @@ import {
   getOAuthCallbackPort,
   setOAuthCallbackPort,
 } from "./mcp-oauth-provider.js"
-import { logger } from "./logger.js"
+import { logger } from "./logger.ts"
 
 // HTML templates for callback responses
 const HTML_SUCCESS = `<!DOCTYPE html>

package/dist/builtin/mcp/mcp-panel-state.ts

@@ -1,5 +1,5 @@
 import { isToolExcluded } from "./types.ts";
-import type { MetadataCache, ServerCacheEntry, CachedTool } from "./metadata-cache.ts";
+import type { MetadataCache, ServerCacheEntry, CachedTool } from "./metadata-cache.js";
 import { resourceNameToToolName } from "./resource-tools.ts";
 import type { McpConfig, McpPanelCallbacks, McpPanelResult, ServerProvenance } from "./types.ts";
 import type { ServerState, ToolState, VisibleItem } from "./mcp-panel-types.ts";

package/dist/builtin/mcp/mcp-panel.ts

@@ -1,5 +1,5 @@
 import { matchesKey } from "@earendil-works/pi-tui";
-import type { MetadataCache } from "./metadata-cache.ts";
+import type { MetadataCache } from "./metadata-cache.js";
 import type { McpConfig, McpPanelCallbacks, McpPanelResult, ServerProvenance } from "./types.ts";
 import {
   buildMcpPanelResult,

package/dist/builtin/mcp/metadata-cache.ts

@@ -7,7 +7,7 @@ import { getToolUiResourceUri } from "@modelcontextprotocol/ext-apps/app-bridge"
 import type { McpTool, McpResource, ServerEntry, ToolMetadata } from "./types.ts";
 import { formatToolName, isToolExcluded } from "./types.ts";
 import { resourceNameToToolName } from "./resource-tools.ts";
-import { extractToolUiStreamMode, interpolateEnvRecord, resolveBearerToken, resolveConfigPath } from "./utils.ts";
+import { extractToolUiStreamMode, interpolateEnvRecord, resolveBearerToken, resolveConfigPath } from "./utils.js";
 
 const CACHE_VERSION = 1;
 const CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;

package/dist/builtin/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/mcp",
-  "version": "0.9.11-alpha.9",
+  "version": "0.9.12-alpha.1",
   "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": [