@bastani/atomic 0.9.12 → 0.9.13-alpha.2

package/dist/builtin/mcp/startup-warmup.ts

@@ -1,3 +1,4 @@
+import type { SubagentChildPolicy } from "@bastani/atomic";
 import type { McpExtensionState } from "./state.js";
 import { getMissingConfiguredDirectToolServers } from "./direct-tools.ts";
 import { loadMetadataCache } from "./metadata-cache.js";
@@ -7,9 +8,11 @@ import { logger } from "./logger.ts";
 import { updateMetadataCache, updateStatusBar } from "./init.js";
 
 export interface McpStartupWarmupOptions {
-  shouldContinue?: () => boolean;
-  onDirectToolsChanged?: () => void | Promise<void>;
-  onSettled?: () => void;
+	/** Typed child selection issued during in-process admission. */
+	subagentPolicy?: SubagentChildPolicy;
+	shouldContinue?: () => boolean;
+	onDirectToolsChanged?: () => void | Promise<void>;
+	onSettled?: () => void;
 }
 
 export interface McpStartupWarmupHandle {
@@ -17,6 +20,17 @@ export interface McpStartupWarmupHandle {
   cancel(): void;
 }
 
+export interface McpDirectToolsSelection {
+  readonly disabled: boolean;
+  readonly tools?: readonly string[];
+}
+
+/** Resolve direct-tool selection exclusively from typed admission policy. */
+export function resolveMcpDirectToolsSelection(subagentPolicy?: SubagentChildPolicy): McpDirectToolsSelection {
+	const tools = subagentPolicy?.mcpDirectTools;
+	return { disabled: tools !== undefined && tools.length === 0, ...(tools === undefined ? {} : { tools: [...tools] }) };
+}
+
 function deferToMacrotask(): Promise<void> {
   return new Promise((resolve) => setImmediate(resolve));
 }
@@ -31,12 +45,10 @@ export function scheduleMcpStartupWarmup(
   const promise = (async () => {
     await deferToMacrotask();
     if (!shouldContinue()) return;
+    const selection = resolveMcpDirectToolsSelection(options.subagentPolicy);
+    if (selection.disabled) return;
 
-    const envDirect = process.env.MCP_DIRECT_TOOLS;
-    if (envDirect === "__none__") return;
-
-    const envDirectTools = envDirect?.split(",").map((item) => item.trim()).filter(Boolean);
-    const missingCacheServers = getMissingConfiguredDirectToolServers(state.config, loadMetadataCache(), envDirectTools)
+    const missingCacheServers = getMissingConfiguredDirectToolServers(state.config, loadMetadataCache(), selection.tools)
       .filter((name) => state.manager.getConnection(name)?.status !== "connected");
     if (missingCacheServers.length === 0) return;
 

package/dist/builtin/subagents/CHANGELOG.md

@@ -2,6 +2,69 @@
 
 ## [Unreleased]
 
+## [0.9.13-alpha.2] - 2026-08-12
+
+### Breaking Changes
+
+- **Removed CHAIN execution mode from the `subagent` tool.** The tool now supports only SINGLE (`{agent, task?, progress?}`) and top-level PARALLEL (`{tasks: [...], concurrency?, worktree?}`) execution. The `chain` parameter is gone from the tool schema, so a call that still passes it is rejected by ordinary schema validation rather than by a migration shim — there is no deprecation path. This also removes, with no replacement: sequential chain steps; static parallel steps inside a chain (`{parallel: [...]}` as a chain step); dynamic fan-out steps (`expand` / `collect` / `as` / `{outputs.name}`), which were **not** ported to top-level PARALLEL mode; the chain template variables `{previous}` and `{chain_dir}` and chain-scoped `{task}` substitution; the `chainName` and `chainDir` parameters; and saved chain definitions in `.chain.md` / `.chain.json` files under `~/.atomic/agent/chains/` and `.atomic/chains/`, along with their discovery, parsing, serialization, and management actions. Migrate a sequential chain to successive `subagent` calls, passing each step's result forward in the task text yourself; migrate an in-chain parallel step to a top-level PARALLEL call. Agent definitions, agent management, and every other mode are unaffected.
+- **Removed the `/chain` and `/run-chain` slash commands.** `/run` (single) and `/parallel` (top-level parallel) are unchanged, including their `--bg` and `--fork` flags. `/run-chain`, which launched a saved `.chain.md` workflow directly, has no replacement; re-express the workflow as `/run` and `/parallel` invocations, or as an `@bastani/workflows` workflow, which keeps first-class sequential composition through `ctx.chain(...)`.
+- **Action required: delete leftover `.chain.md` files from your agents directories.** Saved-chain discovery is gone, so agent discovery no longer recognises — or skips — the `.chain.md` suffix. A leftover `.chain.md` file carries `name` and `description` frontmatter, so it now loads as an ordinary agent and appears in `subagent list`, `/run` completions, and agent management. Delete or move those files. Restoring a `.chain.md` exclusion was considered and rejected: it would keep saved-chain knowledge alive in shipped code, which this removal is meant to end.
+
+### Removed
+
+- Removed every chain-only implementation surface: the chain execution engine and its sequential, parallel, and dynamic-fan-out step runners; chain output bindings and named-output resolution; the chain serializer and saved-chain discovery, including the `.chain.md` exclusion in agent discovery; the saved-chain slash mapping; chain TUI graph rendering and the chain workflow-graph model; chain async/background run handling; chain reporting in `subagent doctor`; and the chain types, results, settings, and formatters. Agent discovery now treats every `.md` file in an agents directory uniformly.
+
+### Changed
+
+- Subagent worktree Git/setup-hook commands and optional global npm probes now receive `AI_AGENT=atomic` for generic child-process attribution without mutating caller-supplied environment objects.
+
+### Fixed
+
+- Fixed repeated collapsed-tool-output requests from subagent launch paths forcing an already-collapsed host transcript to update.
+- Fixed detached subagent completions and terminal notifications that finish after an extension reload. Stale event-bus emits are now best-effort, and notification ownership moves to the replacement API after invalidation while a rejected same-API registration leaves its existing subscription intact.
+- Fixed stale-context checks in detached completion, authorization, notification, and in-process continuation paths by consuming the host's exported predicate instead of copying its error-message marker.
+- Fixed failed replacement of a background completion subscription leaving a registry entry after activation abort; the new subscription is rolled back before the cleanup error escapes.
+- Fixed `/run`, `/parallel`, and prompt-template subagent requests waiting forever when an extension reload or session replacement made their response runtime stale after a long child run. Bridge emits now classify stale drops through the host predicate and reject the request's direct settlement path; settlement-less prompt-template drops log an explicit diagnostic. Bridge shutdown cancellation uses a distinct terminal error, so ordinary deactivation renders a failure result instead of being misclassified as stale. Completion-notification stale drops still reject instead of masquerading as an ordinary `delivered: false` acknowledgement. A genuine stale-runtime reload is still rethrown before the old API can render, so the command's guarantee is termination and logged diagnosis, not a persistent pane notice after reload repaint.
+- Exposed `registerPromptTemplateBridgeRequestSettlement` from `@bastani/subagents` for the separately installed `pi-prompt-template-model` emitter, which cannot be registered by Atomic because it owns a different extension runtime.
+
+- Fixed every `subagent` action being refused with "Subagent fanout is not authorized for this child." for a child without fanout authorization. The fanout check ran before the management branch, so the observing actions — `list`, `get`, `status`, and `doctor` — were rejected with a message about delegation, which they do not perform. Those four now pass the gate. Fanout authorization gates delegation and every management action that can start or continue agent execution: `resume` revives a child and `interrupt` is privileged control over a running one, so both now receive the fanout refusal instead of reaching their handlers. Mutating management (`create`, `update`, `delete`) is still refused for a management-restricted child, by the narrower gate that this bug had made unreachable. Registration is not authority: a child loads bundled extensions through normal discovery and may therefore have the `subagent` tool registered, while typed admission policy decides which of its actions run. The bundled subagents skill stays parent-only and is stripped from every child prompt, including fanout-authorized children ([#2220](https://github.com/bastani-inc/atomic/pull/2220), regression from [#2205](https://github.com/bastani-inc/atomic/pull/2205)).
+- Fixed the in-process depth guard and nested workflow-stage children. Admission-issued child depth now travels in the typed policy into every single, parallel, async, and resume path, so the executor can reject delegation at the configured limit while Rust admission keeps the hard five-level ceiling; the orphaned process-environment depth bridge and its self-fulfilling tests are gone. In-process children now load the bundled package resources needed to register `subagent`, so a nested child no longer starts with only the base built-in tools and no way to delegate, while workflow-stage children suppress only the workflow extension lifecycle ([#2220](https://github.com/bastani-inc/atomic/pull/2220), regression from [#2205](https://github.com/bastani-inc/atomic/pull/2205)).
+- Fixed an agent's `maxSubagentDepth` being dropped at the in-process admission door. A child admitted from an agent whose definition tightened the limit received a policy carrying no maximum, so it could keep delegating as if only the global five-level ceiling applied. The effective limit — the stricter of the parent's limit and the child agent's own — now travels on the admitted child spec and policy, is reissued unchanged by a cold reload, and is applied by the executor's depth check alongside the local configuration. Admission also derives the limit from the agent definition when a caller supplies a child spec without one, so the admission door no longer issues an unbounded policy for an agent that declared a limit ([#2220](https://github.com/bastani-inc/atomic/pull/2220), regression from [#2205](https://github.com/bastani-inc/atomic/pull/2205)).
+- Fixed a resumed foreground child losing the delegation limit its agent definition had narrowed. Retained resume re-derived the limit from the current stage or process configuration, so a child that ran under an agent maximum of 1 resumed with the configured maximum instead. The effective limit is now recorded per retained child and reused on resume, so editing an agent definition between a run and its resume cannot widen that child's budget ([#2220](https://github.com/bastani-inc/atomic/pull/2220), regression from [#2205](https://github.com/bastani-inc/atomic/pull/2205)).
+- Reduced redundant live subagent repaints by publishing progress only for widget-visible milestones. The in-process runner published `AgentProgress` from a catch-all over every child session event, including the high-frequency `message_update` streaming deltas and `tool_execution_update`, and each publish rewrites the elapsed fields the widget renders. With a subagent expanded via Ctrl+O, that made the live widget repaint for the whole run rather than when its contents changed, and each repaint of a row above the terminal fold costs a destructive pi-tui full redraw that clears terminal scrollback. Progress is now published only on events that change what the widget shows — `agent_start`, `tool_execution_start`, `tool_execution_end`, and (throttled) `message_end` — which is the emission profile foreground subagents had before the in-process runner. Measured against a 20-second replay in the tight geometry, scrollback clears drop from 23 to 3; a live tmux run against the built CLI dropped from 8 clears (7 of them repaints that changed nothing visible) to 3 (none of them). **Genuine above-fold milestone changes can still require a pi-tui redraw**, so a short terminal whose editor/footer region plus the live widget exceed the terminal height will still lose scrollback at tool boundaries; that path is upstream (earendil-works/pi#4785, #7194) and outside this package. The 400 ms throttle, the forced-emit milestones, the depth guard, and the typed status contract are unchanged ([#2213](https://github.com/bastani-inc/atomic/pull/2213), regression from [#2205](https://github.com/bastani-inc/atomic/pull/2205)).
+- Fixed in-process foreground and async subagent fast-mode propagation for workflow stages. The child session keeps the real workflow orchestration context, so the SDK applies `service_tier: "priority"` to eligible requests; nested `ctx.workflow(...)` stages inherit the same scope, and fallback attempts recompute the marker and tier for the effective model. Live, continued, detached, and terminal result surfaces now keep the effective model's marker while main-chat children keep using `codexFastMode.chat` ([#2336](https://github.com/bastani-inc/atomic/issues/2336)).
+- Fixed running subagent widgets and result rows dropping the child's effective reasoning level. In-process single, parallel, async, and workflow-stage steps now carry resolved model, thinking, and applied Codex fast-mode metadata from launch through fallback and completion, so the live badge and final result render the same values; async registry hydration preserves fresh per-step metadata ([#2335](https://github.com/bastani-inc/atomic/issues/2335)).
+
+## [0.9.13-alpha.1] - 2026-08-05
+
+### Breaking Changes
+
+- `async: true` no longer survives parent exit. Async subagents now run as in-process children of the parent session on the same foreground executor, so quitting Atomic ends any in-flight async run. The child's canonical identity and its session file persist on disk and can be reloaded on a later start, but the running work does not continue in the background across a restart. The detached runner process that previously provided parent-exit survival has been deleted ([#2188](https://github.com/bastani-inc/atomic/issues/2188)).
+- Removed the `ATOMIC_SUBAGENT_*` process-era environment bridge variables consumed by the deleted spawn path and the synthesized numeric child-result exit-code protocol (`0/1/-1/-2/143`). Child identity, policy, supervisor capability, and terminal outcomes now cross typed admission; results use required `status` (`ok | error | skipped | interrupted | continued`) plus `cause` and `stats` ([#2188](https://github.com/bastani-inc/atomic/issues/2188)).
+
+### Added
+
+- Added the in-process subagent control-plane doors and `InProcessChildRunner` foundation backed by the Rust N-API registry, typed statuses, session statistics, and bounded result envelopes ([#2188](https://github.com/bastani-inc/atomic/issues/2188)).
+
+### Changed
+
+- Nested in-process children now route live `interrupt` and cold `resume` actions directly through the Rust control plane. Nested event and control records use an in-memory host route while retaining the validated file shape for cold-start compatibility; session JSONL is flushed before forced interruption, and the former 200 ms nested-control polling loop is replaced by event-driven delivery ([#2188](https://github.com/bastani-inc/atomic/issues/2188)).
+- In-process children now advance through their model-fallback ladder via the SDK session's `fallbackModels` — the exact classification, same-model retry, and candidate-advancement behavior main chat and workflow stages converged on ([#2170](https://github.com/bastani-inc/atomic/issues/2170)) — instead of a subagents-local walk. Pre-spawn auth filtering still builds the ladder, and results report the effective `model`, `attemptedModels`, and skipped pre-spawn attempts ([#2188](https://github.com/bastani-inc/atomic/issues/2188)).
+- Foreground subagent attempts now enter through the in-process session runner, expose typed terminal status and `SessionStats`, and record typed run-history statuses; the foreground process-attempt implementation was removed ([#2188](https://github.com/bastani-inc/atomic/issues/2188)).
+- In-process admission now resolves child management and fanout capabilities as a typed policy carried into the session and tool executor; restricted children cannot create, update, or delete agent definitions, and fanout authorization cannot be widened by a descendant ([#2188](https://github.com/bastani-inc/atomic/issues/2188)).
+- `async: true` chain and parallel runs now execute on the same in-process foreground executor as their synchronous counterparts, un-awaited, instead of a separately serialized detached runner. Chain `{previous}` substitution, chain output bindings, dynamic fanout, worktree setup and cleanup, structured-output schemas, skills resolution, progress files, fail-fast, and per-step model-candidate ladders are now served by one implementation for both modes ([#2188](https://github.com/bastani-inc/atomic/issues/2188)).
+- Child prompt behavior now enters in-process `AgentSession` construction through typed admission policy: boundary instructions, project-context and inherited-skill filtering, orchestration-skill removal, and parent-only message filtering no longer depend on the process-era extension injection path ([#2188](https://github.com/bastani-inc/atomic/issues/2188)).
+- Child MCP direct-tool selection and Intercom identity/capability now cross the in-process admission boundary as typed policy; omitted MCP selection preserves defaults, empty selection disables direct tools, and supervisor grants are never inherited through environment ([#2188](https://github.com/bastani-inc/atomic/issues/2188)).
+
+### Fixed
+
+- Fixed in-process parallel siblings colliding on the same canonical identity and terminal artifact path, and fixed async completions omitting their persisted result envelope from the parent notification ([#2188](https://github.com/bastani-inc/atomic/issues/2188)).
+- Fixed model-failure classification sharing so subagent fallback decisions stay aligned with main chat and workflow candidates for auth, unavailable-model, request-incompatible, quota, and transport failures ([#2170](https://github.com/bastani-inc/atomic/issues/2170)).
+
+### Removed
+
+- Removed every remaining OS child-process code path from subagent execution, satisfying the spec's zero-process goal: the detached jiti async runner and its twelve `subagent-runner*` modules, the `async-execution-*` spawn layer, the async event journal, the idle/wall attempt watchdog, the stdout drain grace, the CLI spawn resolver, the environment-bridge builder, and the post-exit stdio guard ([#2188](https://github.com/bastani-inc/atomic/issues/2188)).
+
 ## [0.9.12] - 2026-08-04
 
 ### Fixed