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

package/CHANGELOG.md

@@ -2,6 +2,48 @@
 
 ## [Unreleased]
 
+## [0.9.19-alpha.4] - 2026-09-10
+
+### Breaking Changes
+
+- Workflow controls, completion, help, and status hints use `/workflow pause`, `/workflow quit`, and `/workflow resume`. The workflow tool supports run, stage, and individual durable-tool pause targets; `/workflow pause [run-id|--all]` controls runs. Workflow lifecycle control events report `action: "pause"` for pause requests.
+- Renamed the bundled subagent `interrupt` action to `kill`. Migrate `subagent({ action: "interrupt", id })` to `subagent({ action: "kill", id })`, including calls using `runId`. The old action is no longer accepted. Kill terminally stops the child and cannot be resumed; follow-up work requires a fresh launch. Workflow controls use `/workflow pause`; parent cancellation behavior is unchanged.
+
+### Added
+
+- Added a model row to the `/workflow connect` graph node cards showing each stage's effective model and thinking level, including canonical fast model identity, with model-name truncation preserving the suffixes. Cards retain duration, status and dependencies in a six-row layout, reflect live fallbacks, and restore identity through durable resume ([#1859](https://github.com/bastani-inc/atomic/pull/1859) by [@sina85](https://github.com/sina85)).
+- Added `{ action: "wait", id, budgetMs }` to Bash and PowerShell for observing existing asynchronous tasks without rerunning commands. The observation budget is optional. Waits retain output and terminal metadata, follow owner observation policy, and release on cancellation or incoming messages without stopping execution or extending task lifetime.
+- Added the agent-callable `kill({ id })` tool for owned background bash and PowerShell tasks in main and workflow-stage chat. It cancels by task ID, preserves retained output and original outcomes, reports current cleanup state, and rejects other owners' tasks and subagents.
+- Added exact per-model overrides through `compaction.modelOverrides` for `compaction.reserveTokens` and Atomic's `compaction.preserve_recent` message count. Each field falls back to ordinary settings and then built-in defaults, with non-negative safe-integer validation. Manual, automatic, and post-tool compaction use the active model's budgets while retaining verbatim line compaction.
+
+### Fixed
+
+- First-loaded TypeScript extensions share the live host's classes and singletons when native import falls back to transformation, avoiding duplicate host evaluation and slow startup.
+- Fixed repeated yielded shell waits replaying the first output page instead of progressing through retained output while the task is still running ([#2972](https://github.com/bastani-inc/atomic/pull/2972)).
+- Preserved an explicit subagent kill when parent cancellation arrives during execution-capacity waiting, and kept grouped Intercom cancellation status consistent when a killed child has parent-cancelled siblings.
+- Embedded Postgres now starts on Windows administrative accounts. PostgreSQL refuses to run for a member of the Administrators or Power Users groups, so Atomic launches the retained server process with the same restricted access token `pg_ctl` uses, keeping exact-process shutdown semantics; non-administrative Windows accounts are unchanged. Postgres processes that exit during startup (including that administrator refusal on older builds) now fail fast with the actual server log instead of a readiness timeout.
+- Preserved embedded Postgres startup logs on regular Windows accounts, honored Unicode environment overrides on administrative launches, and prevented Windows handle leaks across repeated launches.
+- Preserved `PATH` lookup and relative executable paths for administrative Windows Postgres launches. Invalid launch inputs containing embedded NUL characters now fail before starting a process rather than using truncated paths, arguments, or environment values.
+- Fixed custom Windows Postgres `.cmd` and `.bat` launchers failing with arguments on administrative accounts, including launcher paths containing spaces. Batch arguments retain their existing quoting and line-break rejection.
+- Fixed explicit `cmd.exe` Postgres launchers and safe verbatim working directories on Windows administrative accounts. Concurrent Postgres launches no longer keep one another's log files open or expose them to unrelated commands starting at the same time.
+- Incoming Intercom send and ask messages now act as a priority interrupt queue for working subagents and live workflow stages: the receiver's current model call or cancellable tool is cancelled immediately and the message is processed within the same task, session, and stage generation. Admission survives consumed preflight input and overlapping SDK interrupt turns. Completed tool side effects are never replayed, the original task prompt is not repeated, multiple arrivals stay in arrival order with duplicate suppression, and exact ask/reply correlation survives the cancelled turn. Explicit user abort, host stop, and terminal/closed receivers still win: late input never restarts finished work.
+- Fixed a deadlock where an extension event hook awaiting an ordinary context-only message could wait behind an inbound Intercom delivery that was itself waiting for that event hook.
+- Inbound delivery retries after a transient persistence failure keep their original arrival position and remain part of both child and workflow-stage settlement, and a card appended before a failed flush is completed on retry instead of being appended a second time.
+
+## [0.9.19-alpha.3] - 2026-09-09
+
+### Fixed
+
+- Fixed `Failed to initialize class constructor` when npm-installed Node sessions create multiple task supervisors, preventing shell commands and subagent launches from failing during task-host initialization.
+- Fixed foreground subagent launches and explicit waits blocking parent user steering and incoming Intercom asks/sends. Admitted messages now release the waiting parent's observations in main and workflow-stage chat without cancelling children or affecting other owners.
+- Fixed PowerShell internal-URL path quoting so apostrophes and smart single quotes in resolved paths remain literal instead of allowing injected commands. Bash quoting, deliberate shell commands, and balanced command prefixes are unchanged.
+- Capped agent retry backoff with `retry.maxAgentDelayMs` (60 seconds by default), preserving independent provider retry limits ([#8826](https://github.com/earendil-works/pi/issues/8826)).
+- Rejected extension tools with missing or non-object parameter schema containers during registration instead of breaking provider requests ([#9300](https://github.com/earendil-works/pi/issues/9300)).
+- Workflow-stage pause now blocks new task launches, cancels active and admitted queued agents and commands, and waits for in-flight command admission and resource cleanup. Main-chat and sibling tasks stay unaffected; queued user and Intercom messages survive, and resume permits fresh work without restarting cancelled executions.
+- Fixed npm-installed Node startup failing with a missing upstream AI package after the retry-policy update. Core retry imports now use Atomic's declared AI dependency.
+- Fixed an unhandled rejection when session cancellation interrupts an in-flight stage-chat pause, while preserving pause error reporting and rejection for callers awaiting completion.
+- Fixed Windows extension reloads re-evaluating Atomic's host modules, avoiding duplicate host classes and long reload delays while preserving edits to extension dependencies. The supported `@earendil-works/pi-coding-agent` import also shares host identity with `@bastani/atomic` after reload.
+
 ## [0.9.19-alpha.2] - 2026-09-08
 
 ### Added

package/dist/builtin/intercom/CHANGELOG.md

@@ -4,6 +4,21 @@ All notable changes to the `pi-intercom` extension will be documented in this fi
 
 ## [Unreleased]
 
+## [0.9.19-alpha.4] - 2026-09-10
+
+### Fixed
+
+- Route lazy initialization, event-relay, and rejected-candidate cleanup diagnostics through the owning interactive session's notifications, including during shutdown, instead of leaking console output and stacks. Retryable initialization uses warning color; non-interactive console diagnostics (including RPC), original failures, acknowledgements, and retry behavior are preserved even when an error cannot be rendered.
+- `send` and `ask` to a working subagent or live workflow stage are delivered as a priority interrupt: the recipient's active model call or cancellable tool is cancelled immediately and the message is processed in the same task instead of waiting for the next natural turn or being refused as busy. Completed side effects are not undone or replayed. Arrival order holds across persistence retries for both receiver kinds; duplicate suppression, exact reply correlation, terminal-child and closed-stage rejection, unrelated headless protection, and group restrictions are unchanged.
+- A cancelled turn that produced no reply no longer consumes the pending ask's reply context, so replies to consecutive asks stay correlated with the right sender and message.
+
+## [0.9.19-alpha.3] - 2026-09-09
+
+### Fixed
+
+- Session listings display host-provided live/terminal reply capability separately from idle activity. Closed workflow generations publish `closed` with post-mortem-only or unavailable reply routing rather than remaining misleadingly idle; group isolation and ask rejection rules are unchanged.
+- Canonical workflow-path asks correlate replies from connected retained stages even after their active roster rows disappear. Closed stages without post-mortem routing reject asks with lifecycle guidance rather than attempting a model turn.
+
 ## [0.9.19-alpha.2] - 2026-09-08
 
 ### Breaking Changes

package/dist/builtin/intercom/broker/broker.ts

@@ -86,6 +86,7 @@ interface PendingStageAcknowledgment {
 	readonly message: Message;
 	readonly liveTargetId?: string;
 	readonly signature?: string;
+	readonly resolveReplyTarget?: true;
   readonly timeout: NodeJS.Timeout;
 }
 
@@ -681,6 +682,7 @@ class IntercomBroker {
 		message: route.message,
 		...(route.liveTargetId === undefined ? {} : { liveTargetId: route.liveTargetId }),
 		...(route.signature === undefined ? {} : { signature: route.signature }),
+		...(route.resolveReplyTarget === true ? { resolveReplyTarget: true } : {}),
       timeout,
     });
     if (
@@ -828,6 +830,8 @@ class IntercomBroker {
 						return;
 					}
 					this.pendingQuestions.record(from.info.id, target.info.id, pending.messageId);
+					if (pending.resolveReplyTarget === true && pending.attemptId !== undefined)
+						writeMessageIfOpen(pending.senderSocket, { type: "question_target", messageId: pending.messageId, attemptId: pending.attemptId, sessionId: target.info.id });
 				}
 				writeMessageIfOpen(pending.senderSocket, {
 					type: "delivered",
@@ -880,6 +884,8 @@ class IntercomBroker {
 					return;
 				}
 				this.pendingQuestions.record(from.info.id, target.info.id, pending.messageId);
+				if (pending.resolveReplyTarget === true && pending.attemptId !== undefined)
+					writeMessageIfOpen(pending.senderSocket, { type: "question_target", messageId: pending.messageId, attemptId: pending.attemptId, sessionId: target.info.id });
 			}
 			writeMessageIfOpen(pending.senderSocket, {
 				type: "delivered",
@@ -903,6 +909,8 @@ class IntercomBroker {
 			});
 			return;
 		}
+		if (pending.message.expectsReply === true && pending.resolveReplyTarget === true && pending.attemptId !== undefined)
+			writeMessageIfOpen(pending.senderSocket, { type: "question_target", messageId: pending.messageId, attemptId: pending.attemptId, sessionId: target.info.id });
 		if (!writeMessageIfOpen(target.socket, { type: "message", from: pending.sender, message: pending.message })) {
 			this.deliveredMessages.forget(pending.messageId, pending.signature);
 			writeMessageIfOpen(pending.senderSocket, {

package/dist/builtin/intercom/broker/client.ts

@@ -38,6 +38,8 @@ export interface SendOptions {
   logicalTarget?: string;
   /** Public reply must use the broker's exact pending reverse question route. */
   requirePendingReply?: true;
+  /** Broker-authorized identity for a canonical-path ask, delivered before its recipient can reply. */
+  onReplyTarget?: (sessionId: string) => void;
 }
 
 export interface SendResult {
@@ -153,6 +155,7 @@ export class IntercomClient extends EventEmitter {
   /** Source identity is captured once at connect, never read from env per message. */
   private _messageSource: Message["source"] | undefined;
   private pendingSends = new PendingSendRegistry();
+  private pendingReplyTargets = new Map<string, { messageId: string; bind(sessionId: string): void }>();
   private pendingGroupLists = new Map<string, { resolve: (groups: GroupSummary[]) => void; reject: (error: Error) => void }>();
   private pendingLists = new Map<string, { resolve: (directory: SessionDirectory) => void; reject: (e: Error) => void }>();
   private pendingPresence = new Map<string, {
@@ -415,6 +418,15 @@ export class IntercomClient extends EventEmitter {
         this.emit("_registration_failed", new Error(brokerMessage.reason));
         break;
       }
+      case "question_target": {
+        const { messageId, attemptId, sessionId } = brokerMessage;
+        if (typeof messageId !== "string" || typeof attemptId !== "string" || typeof sessionId !== "string") {
+          throw new Error("Invalid question_target message");
+        }
+        const pending = this.pendingReplyTargets.get(attemptId);
+        if (pending?.messageId === messageId) pending.bind(sessionId);
+        break;
+      }
       case "sessions": {
 		const { requestId, sessions, workflowStages, workflowFutureStages } = brokerMessage;
 		if (
@@ -989,12 +1001,16 @@ export class IntercomClient extends EventEmitter {
       source: this._messageSource,
       content: { text: options.text, attachments: options.attachments },
     };
+    if (options.onReplyTarget !== undefined) {
+      this.pendingReplyTargets.set(acquired.attempt.attemptId, { messageId, bind: options.onReplyTarget });
+    }
     try {
 		writeMessage(socket, {
 			type,
 			to,
 			...(options.logicalTarget === undefined ? {} : { logicalTarget: options.logicalTarget }),
 			...(options.requirePendingReply === undefined ? {} : { requirePendingReply: options.requirePendingReply }),
+      ...(options.onReplyTarget === undefined ? {} : { resolveReplyTarget: true as const }),
 			message,
 			attemptId: acquired.attempt.attemptId,
 			...extra,
@@ -1002,6 +1018,8 @@ export class IntercomClient extends EventEmitter {
     } catch (error) {
       this.pendingSends.reject(acquired.attempt, toError(error));
     }
+    const clearReplyTarget = () => { this.pendingReplyTargets.delete(acquired.attempt.attemptId); };
+    void acquired.attempt.promise.then(clearReplyTarget, clearReplyTarget);
     return acquired.attempt.promise;
   }
   updatePresence(updates: PresenceUpdates): boolean {

package/dist/builtin/intercom/broker/send-handler.ts

@@ -59,6 +59,7 @@ export interface PendingStageRoute {
   readonly attemptId?: string;
 	readonly liveTargetId?: string;
 	readonly signature?: string;
+	readonly resolveReplyTarget?: true;
 }
 
 export type PendingStageRouter = (route: PendingStageRoute) => boolean;
@@ -326,6 +327,8 @@ export function handleBrokerSend(
 				return;
 			}
 			pendingQuestions.record(fromSession.info.id, target.info.id, message.id);
+			if (clientMessage.resolveReplyTarget === true && attemptId !== undefined)
+				write(socket, { type: "question_target", messageId: message.id, attemptId, sessionId: target.info.id });
 		}
 		write(socket, { type: "delivered", messageId: message.id, attemptId });
 		return;
@@ -369,6 +372,7 @@ export function handleBrokerSend(
 				...(attemptId ? { attemptId } : {}),
 				liveTargetId: target.info.id,
 				signature,
+				...(clientMessage.resolveReplyTarget === true ? { resolveReplyTarget: true } : {}),
 			})
 		) {
 			return;
@@ -416,6 +420,8 @@ export function handleBrokerSend(
 			return;
 		}
 		if (message.expectsReply === true) pendingQuestions.record(fromSession.info.id, target.info.id, message.id);
+		if (message.expectsReply === true && clientMessage.resolveReplyTarget === true && attemptId !== undefined)
+			write(socket, { type: "question_target", messageId: message.id, attemptId, sessionId: target.info.id });
 		write(socket, { type: "delivered", messageId: message.id, attemptId });
 		return;
 	}
@@ -433,6 +439,8 @@ export function handleBrokerSend(
 		});
 		return;
 	}
+	if (message.expectsReply === true && clientMessage.resolveReplyTarget === true && attemptId !== undefined)
+		write(socket, { type: "question_target", messageId: message.id, attemptId, sessionId: target.info.id });
     const finishDelivery = (): void => {
 	  let accepted: ReturnType<DeliveredMessageCache["accept"]>;
 	  try {
@@ -508,6 +516,7 @@ export function handleBrokerSend(
 			message,
 			...(attemptId ? { attemptId } : {}),
 			signature,
+			...(clientMessage.resolveReplyTarget === true ? { resolveReplyTarget: true } : {}),
 		})
 	) {
 		return;