@bastani/atomic 0.9.15 → 0.9.16-alpha.1

package/dist/builtin/subagents/src/runs/inprocess/runner.ts

@@ -1,4 +1,4 @@
-import { appendFileSync, existsSync, mkdirSync, readdirSync, statSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, statSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import {
 	type AgentSession,
@@ -45,7 +45,6 @@ import {
 	type MaxOutputConfig,
 	truncateOutput,
 } from "../../shared/types.js";
-import { type InProcessAttemptResumeOutcome, registerInProcessAttempt } from "./attempt-handles.js";
 import { type ChildModePolicy, resolveChildModePolicy } from "./child-policy.js";
 import { createInProcessChildPromptBehavior, createInProcessChildSystemPromptTransform } from "./prompt-behavior.js";
 
@@ -673,9 +672,6 @@ export class SubagentControlRuntime {
 	readonly native: SubagentControl;
 	readonly parent: ParentContext;
 	readonly sessionRoot: string;
-	private readonly sessions = new Map<string, AgentSession>();
-	private readonly specs = new Map<string, ChildSpec>();
-	private readonly sessionFiles = new Map<string, string>();
 	private readonly runningAttempts = new Map<number, RunningAttempt>();
 	private readonly attemptTokens = new Map<string, number>();
 	private readonly attemptTerminators = new Map<string, (cause: TerminationCauseName) => Promise<void>>();
@@ -713,7 +709,6 @@ export class SubagentControlRuntime {
 			? dirname(spec.sessionFile)
 			: sessionDirectory(this.sessionRoot, identity.path);
 		mkdirSync(sessionDir, { recursive: true });
-		this.specs.set(identity.path, spec);
 		return {
 			admitted: AdmittedChild.create({
 				identity,
@@ -896,10 +891,9 @@ export class SubagentControlRuntime {
 						})
 					).session,
 				};
+				await created.session.extensionRunner.emit({ type: "session_start", reason: "startup" });
 			}
 			session = created.session;
-			if (session.sessionFile) this.sessionFiles.set(admitted.identity.path, session.sessionFile);
-			this.sessions.set(admitted.identity.path, session);
 			const initialModelId = modelIdForSession(session) ?? candidateModelId;
 			effectiveModelId = initialModelId;
 			effectiveThinking =
@@ -1070,7 +1064,6 @@ export class SubagentControlRuntime {
 			} catch {
 				// Session teardown must not replace the attempt result.
 			}
-			this.sessions.delete(admitted.identity.path);
 			if (this.attemptTokens.get(admitted.identity.path) === token)
 				this.attemptTokens.delete(admitted.identity.path);
 			if (this.attemptTerminators.get(admitted.identity.path) === terminate)
@@ -1142,56 +1135,6 @@ export class SubagentControlRuntime {
 		return running.child.identity.path;
 	}
 
-	reloadColdChild(pathValue: string, message: string): AdmittedResult {
-		let sessionDir: string;
-		try {
-			sessionDir = sessionDirectory(this.sessionRoot, pathValue);
-		} catch (error) {
-			return {
-				refusal: {
-					kind: "invalidCwd",
-					reason: error instanceof Error ? error.message : String(error),
-				},
-			};
-		}
-		const identity = this.native.listChildren().find((child) => child.path === pathValue);
-		if (!identity)
-			return {
-				refusal: { kind: "unknownAgent", reason: "unknown child identity" },
-			};
-		const sessionFile = this.sessionFiles.get(pathValue) ?? this.findSessionFile(sessionDir);
-		if (!sessionFile)
-			return {
-				refusal: {
-					kind: "invalidCwd",
-					reason: "child session file is missing",
-				},
-			};
-		sessionDir = dirname(sessionFile);
-		const native = this.native.reloadColdChild(pathValue, message);
-		if (!native.child) return refusal(native);
-		const previous = this.specs.get(pathValue);
-		if (!previous)
-			return {
-				refusal: {
-					kind: "unknownAgent",
-					reason: "child policy is not resident",
-				},
-			};
-		const spec: ChildSpec = { ...previous, task: message };
-		this.specs.set(pathValue, spec);
-		return {
-			admitted: AdmittedChild.create({
-				identity: native.child,
-				spec,
-				policy: { ...this.policyFor(spec, native.child.depth) },
-				sessionDir,
-				sessionFile,
-				control: this,
-			}),
-		};
-	}
-
 	getChildMetadata(pathValue: string): ChildRuntimeMetadata | undefined {
 		const running = [...this.runningAttempts.values()].find(
 			(attempt) =>
@@ -1209,34 +1152,6 @@ export class SubagentControlRuntime {
 		};
 	}
 
-	/** Expose a direct child's live attempt so `interrupt`/`resume` can reach it by run id or path. */
-	registerAttempt(runId: string, running: RunningAttempt, candidate: ModelCandidate): void {
-		registerInProcessAttempt({
-			runId,
-			path: running.child.identity.path,
-			status: () => running.status,
-			interrupt: () => this.terminateChildAttempt(running, "interrupt"),
-			resume: async (message): Promise<InProcessAttemptResumeOutcome> => {
-				const admission = this.reloadColdChild(running.child.identity.path, message);
-				if (!admission.admitted) {
-					throw new Error(admission.refusal?.reason ?? "child cold reload was refused");
-				}
-				const neverAbort = new AbortController().signal;
-				const resumed = this.startAttempt(admission.admitted, candidate, {
-					abort: neverAbort,
-					interrupt: neverAbort,
-				});
-				const outcome = await resumed.promise;
-				return {
-					status: outcome.status,
-					path: outcome.path,
-					sessionFile: outcome.sessionFile,
-					envelope: outcome.envelope,
-				};
-			},
-		});
-	}
-
 	async terminateChildAttempt(running: RunningAttempt, cause: TerminationCauseName): Promise<void> {
 		if (running.status !== "running" && running.status !== "continued") return;
 		await running.terminate?.(cause);
@@ -1285,50 +1200,11 @@ export class SubagentControlRuntime {
 		await this.terminateChildAttempt(running, "interrupt");
 		return true;
 	}
-	async resumeChild(
-		pathValue: string,
-		message: string,
-		candidate: ModelCandidate,
-		signals: AttemptSignals = {
-			abort: new AbortController().signal,
-			interrupt: new AbortController().signal,
-		},
-	): Promise<AttemptOutcome> {
-		const admission = this.reloadColdChild(pathValue, message);
-		if (!admission.admitted) {
-			const reason = admission.refusal?.reason ?? "cold child reload was refused";
-			return {
-				status: "error",
-				cause: reason,
-				stats: { ...EMPTY_STATS, sessionId: pathValue },
-				path: pathValue,
-				envelope: boundedEnvelope(reason),
-			};
-		}
-		const running = this.startAttempt(admission.admitted, candidate, signals);
-		return running.promise;
-	}
 
 	subscribe(pathValue: string, callback: (status: ChildStatus) => void): void {
 		this.native.subscribeChildStatus(pathValue, callback);
 	}
 
-	private policyFor(spec: ChildSpec, depth: number): ChildPolicy {
-		return {
-			...resolveChildModePolicy(spec),
-			cwd: spec.cwd,
-			tools: spec.tools ?? spec.agent.tools,
-			excludedTools: spec.excludedTools,
-			mcpDirectTools: spec.mcpDirectTools ?? spec.agent.mcpDirectTools,
-			skills: [...(spec.skills ?? spec.agent.skills ?? [])],
-			customTools: spec.customTools,
-			model: spec.model,
-			thinkingLevel: spec.thinkingLevel ?? (spec.agent.thinking as ChildPolicy["thinkingLevel"]),
-			intercomGroup: spec.parent?.intercomGroup,
-			depth,
-		};
-	}
-
 	private async terminateRunningAttempt(running: RunningAttempt, cause: TerminationCauseName): Promise<void> {
 		const terminate = this.attemptTerminators.get(running.child.identity.path);
 		if (terminate) {
@@ -1346,17 +1222,6 @@ export class SubagentControlRuntime {
 			// The runner's signal path owns the race with terminal completion.
 		}
 	}
-
-	private findSessionFile(sessionDir: string): string | undefined {
-		try {
-			const entry = readdirSync(sessionDir, { withFileTypes: true }).find(
-				(candidate) => candidate.isFile() && candidate.name.endsWith(".jsonl"),
-			);
-			return entry ? join(sessionDir, entry.name) : undefined;
-		} catch {
-			return undefined;
-		}
-	}
 }
 
 export function createSubagentControl(parent: ParentContext, sessionRoot?: string): SubagentControlRuntime {
@@ -1398,10 +1263,6 @@ export function continue_detached(
 	return control.continueDetached(running, reason);
 }
 
-export function reload_cold_child(control: SubagentControlRuntime, pathValue: string, message: string): AdmittedResult {
-	return control.reloadColdChild(pathValue, message);
-}
-
 export function terminate_child_attempt(
 	control: SubagentControlRuntime,
 	running: RunningAttempt,

package/dist/builtin/subagents/src/runs/shared/parallel-utils.ts

@@ -59,4 +59,12 @@ export function aggregateParallelOutputs(
 		.join("\n\n");
 }
 
+export function formatParallelResultContent(
+	results: ParallelTaskResult[],
+	headerFormat: (index: number, agent: string) => string,
+): string {
+	const ok = results.filter((result) => result.status === "ok").length;
+	return `${ok}/${results.length} succeeded\n\n${aggregateParallelOutputs(results, headerFormat)}`;
+}
+
 export const MAX_PARALLEL_CONCURRENCY = 4;

package/dist/builtin/subagents/src/shared/status-format.ts

@@ -1,6 +1,6 @@
 import type { ActivityState } from "./types.js";
 
-type StepStatus = "pending" | "running" | "complete" | "completed" | "failed" | "paused";
+type StepStatus = "pending" | "running" | "complete" | "completed" | "failed" | "interrupted";
 type StepStatusLike = { status: StepStatus };
 
 function formatActivityAge(ms: number): string {
@@ -41,10 +41,10 @@ export function formatParallelOutcome(
 	const running = steps.filter((step) => step.status === "running").length;
 	const done = steps.filter((step) => isCompletedStepStatus(step.status)).length;
 	const failed = steps.filter((step) => step.status === "failed").length;
-	const paused = steps.filter((step) => step.status === "paused").length;
+	const interrupted = steps.filter((step) => step.status === "interrupted").length;
 	const parts = [`${done}/${total} done`];
 	if (options.showRunning !== false && running > 0) parts.unshift(formatAgentRunningLabel(running));
 	if (failed > 0) parts.push(`${failed} failed`);
-	if (paused > 0) parts.push(`${paused} paused`);
+	if (interrupted > 0) parts.push(`${interrupted} interrupted`);
 	return parts.join(" · ");
 }

package/dist/builtin/subagents/src/shared/types-config.ts

@@ -41,6 +41,7 @@ export interface IntercomEventBus {
 }
 
 export const INTERCOM_DETACH_REQUEST_EVENT = "pi-intercom:detach-request";
+export const PARENT_ASK_HANDOFF_REQUEST_EVENT = "subagent:parent-ask-handoff-request";
 export const SUBAGENT_COMPLETE_EVENT = "subagent:complete";
 export const INTERCOM_DETACH_RESPONSE_EVENT = "pi-intercom:detach-response";
 export const SUBAGENT_CONTROL_EVENT = "subagent:control-event";
@@ -49,6 +50,44 @@ export const SUBAGENT_RESULT_INTERCOM_EVENT = "subagent:result-intercom";
 export const SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT = "subagent:terminal-ordering-barrier";
 export const SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT = "subagent:result-intercom-delivery";
 
+export type ParentAskKind = "decision" | "interview" | "intercom";
+
+export interface ParentAskInterviewQuestion extends Record<string, unknown> {
+	id: string;
+	type: "single" | "multi" | "text" | "image" | "info";
+	question: string;
+	options?: unknown[];
+}
+
+export interface ParentAskInterviewRequest extends Record<string, unknown> {
+	title?: string;
+	description?: string;
+	questions: ParentAskInterviewQuestion[];
+}
+
+export interface ParentAskAttachment {
+	type: "file" | "snippet" | "context";
+	name: string;
+	content: string;
+	language?: string;
+}
+
+export interface ParentAskHandoffRequest {
+	runId: string;
+	index: number;
+	agent: string;
+	childIntercomTarget: string;
+	orchestratorTarget: string;
+	kind: ParentAskKind;
+	question: string;
+	attachments?: ParentAskAttachment[];
+	interview?: ParentAskInterviewRequest;
+	resolvedTargetId?: string;
+	/** Original delegated task supplied by the parent model for a fresh-child handoff. */
+	taskContext?: string;
+	claimed: boolean;
+}
+
 // ============================================================================
 // Execution Options
 // ============================================================================
@@ -64,6 +103,8 @@ export interface RunSyncOptions {
 	intercomDetachSignal?: AbortSignal;
 	/** Releases every active foreground sibling only after this exact child accepts a detach commit. */
 	onIntercomDetachCommit?: () => void;
+	/** Claims a blocking ask from this exact child and ends it with a fresh-child handoff. */
+	onParentAskHandoff?: (request: ParentAskHandoffRequest) => void;
 	onUpdate?: (r: AgentToolResult<Details>) => void;
 	onControlEvent?: (event: ControlEvent) => void;
 	controlConfig?: ResolvedControlConfig;

package/dist/builtin/subagents/src/shared/types-foreground-state.ts

@@ -7,29 +7,21 @@
  */
 
 import type { ExtensionContext } from "@bastani/atomic";
-import type { ActivityState, SingleResult, SubagentResultStatus, SubagentRunMode } from "./types-results.js";
+import type { ParentAskHandoffRequest } from "./types-config.js";
 
-export interface ForegroundResumeChild {
-	agent: string;
-	index: number;
-	sessionFile?: string;
-	status: SubagentResultStatus;
-	result?: SingleResult;
+export interface ForegroundParentAskHandoff {
+	askingChildIndex: number;
+	releasedChildIndices: number[];
+	unlaunchedChildIndices: number[];
+	request: ParentAskHandoffRequest;
 }
 
-export interface ForegroundResumeRun {
-	runId: string;
-	mode: SubagentRunMode;
-	cwd: string;
-	updatedAt: number;
-	children: ForegroundResumeChild[];
-}
+import type { ActivityState, SubagentRunMode } from "./types-results.js";
 
 export interface SubagentState {
 	baseCwd: string;
 	currentSessionId: string | null;
 	subagentInProgress?: boolean;
-	foregroundRuns?: Map<string, ForegroundResumeRun>;
 	foregroundControls: Map<
 		string,
 		{

package/dist/builtin/subagents/src/shared/types-results.ts

@@ -91,7 +91,7 @@ export interface ControlEvent {
 	recentFailureSummary?: string;
 }
 
-export type SubagentResultStatus = "completed" | "failed" | "paused" | "detached";
+export type SubagentResultStatus = "completed" | "failed" | "interrupted" | "detached";
 export type SubagentRunMode = "single" | "parallel";
 
 export interface SubagentResultIntercomChild {
@@ -220,6 +220,8 @@ export interface Details {
 	controlEvents?: ControlEvent[];
 	progress?: AgentProgress[];
 	totalSteps?: number;
+	/** Parent ask ended the current child and returned a fresh-subagent handoff. */
+	parentAskYielded?: boolean;
 	progressSummary?: ProgressSummary;
 	artifacts?: {
 		dir: string;

package/dist/builtin/subagents/src/shared/types-runtime.ts

@@ -81,17 +81,7 @@ export const SLASH_SUBAGENT_STARTED_EVENT = "subagent:slash:started";
 export const SLASH_SUBAGENT_RESPONSE_EVENT = "subagent:slash:response";
 export const SLASH_SUBAGENT_UPDATE_EVENT = "subagent:slash:update";
 export const SLASH_SUBAGENT_CANCEL_EVENT = "subagent:slash:cancel";
-export const SUBAGENT_ACTIONS = [
-	"list",
-	"get",
-	"create",
-	"update",
-	"delete",
-	"status",
-	"interrupt",
-	"resume",
-	"doctor",
-] as const;
+export const SUBAGENT_ACTIONS = ["list", "get", "create", "update", "delete", "status", "interrupt", "doctor"] as const;
 
 export const DEFAULT_FORK_PREAMBLE =
 	"You are a delegated subagent running from a fork of the parent session. " +

package/dist/builtin/subagents/src/tui/render-progress.ts

@@ -27,7 +27,7 @@ export function buildMultiProgressLabel(
 
 	if (details.mode === "parallel") {
 		const statuses = new Array(totalCount).fill("pending") as Array<
-			"pending" | "running" | "completed" | "failed" | "paused" | "detached"
+			"pending" | "running" | "completed" | "failed" | "interrupted" | "detached"
 		>;
 		for (const progress of details.progress ?? []) {
 			if (progress.index >= 0 && progress.index < totalCount) statuses[progress.index] = progress.status;
@@ -42,7 +42,7 @@ export function buildMultiProgressLabel(
 			const status =
 				result.progress?.status ??
 				(result.interrupted || result.status === "interrupted"
-					? "paused"
+					? "interrupted"
 					: result.detached || result.status === "continued"
 						? "detached"
 						: result.status === "ok"

package/dist/builtin/subagents/src/tui/render-result-compact.ts

@@ -87,7 +87,7 @@ export function renderMultiCompact(d: Details, theme: Theme, now?: number, pulse
 	const hasRunning =
 		d.progress?.some((p) => p.status === "running") || d.results.some((r) => r.progress?.status === "running");
 	const failed = d.results.some((r) => r.status === "error" && r.progress?.status !== "running");
-	const paused = d.results.some(
+	const interruptedOrDetached = d.results.some(
 		(r) =>
 			(r.interrupted ||
 				r.detached ||
@@ -117,7 +117,7 @@ export function renderMultiCompact(d: Details, theme: Theme, now?: number, pulse
 		? theme.fg("accent", pulseGlyph(pulseFrame))
 		: failed
 			? theme.fg("error", "✗")
-			: paused
+			: interruptedOrDetached
 				? theme.fg("warning", "■")
 				: theme.fg("success", "✓");
 	const contextBadge = d.context === "fork" ? theme.fg("warning", " [fork]") : "";

package/dist/builtin/subagents/src/tui/render-result.ts

@@ -24,6 +24,19 @@ import {
 	snapshotNowForProgress,
 } from "./render-status-progress.js";
 
+function parentAskOutput(result: AgentToolResult<Details>): string | undefined {
+	if (!result.details?.parentAskYielded) return undefined;
+	return result.content.find((part) => part.type === "text")?.text;
+}
+
+function appendParentAskOutput(component: Component, output: string | undefined, theme: Theme): Component {
+	if (!output) return component;
+	const container = new Container();
+	container.addChild(component);
+	container.addChild(new Text(theme.fg("accent", output), 0, 0));
+	return container;
+}
+
 export function renderLiveSubagentResult(
 	result: AgentToolResult<Details>,
 	options: { expanded: boolean; isPartial: boolean },
@@ -79,18 +92,26 @@ export function renderSubagentResult(
 
 	const expanded = options.expanded;
 	const mdTheme = getMarkdownTheme();
+	const handoffOutput = parentAskOutput(result);
 
 	if (d.mode === "single" && d.results.length === 1) {
 		const r = d.results[0];
-		if (!expanded) return renderSingleCompact(d, r, theme, options.now, options.pulseFrame);
+		if (!expanded)
+			return appendParentAskOutput(
+				renderSingleCompact(d, r, theme, options.now, options.pulseFrame),
+				handoffOutput,
+				theme,
+			);
 		const isRunning = r.progress?.status === "running";
 		const icon = isRunning
 			? theme.fg("warning", "running")
-			: r.detached || r.status === "continued"
-				? theme.fg("warning", "detached")
-				: r.status === "ok"
-					? theme.fg("success", "ok")
-					: theme.fg("error", "failed");
+			: d.parentAskYielded
+				? theme.fg("warning", "yielded")
+				: r.detached || r.status === "continued"
+					? theme.fg("warning", "detached")
+					: r.status === "ok"
+						? theme.fg("success", "ok")
+						: theme.fg("error", "failed");
 		const contextBadge = d.context === "fork" ? theme.fg("warning", " [fork]") : "";
 		const output = r.truncation?.text || getSingleResultOutput(r);
 
@@ -183,10 +204,11 @@ export function renderSubagentResult(
 			c.addChild(new Spacer(1));
 			c.addChild(new Text(fit(theme.fg("dim", `Artifacts: ${shortenPath(r.artifactPaths.outputPath)}`)), 0, 0));
 		}
-		return c;
+		return appendParentAskOutput(c, handoffOutput, theme);
 	}
 
-	if (!expanded) return renderMultiCompact(d, theme, options.now, options.pulseFrame);
+	if (!expanded)
+		return appendParentAskOutput(renderMultiCompact(d, theme, options.now, options.pulseFrame), handoffOutput, theme);
 
 	const hasRunning =
 		d.progress?.some((p) => p.status === "running") || d.results.some((r) => r.progress?.status === "running");
@@ -201,11 +223,13 @@ export function renderSubagentResult(
 	);
 	const icon = hasRunning
 		? theme.fg("warning", "running")
-		: hasEmptyWithoutTarget
-			? theme.fg("warning", "warning")
-			: ok === d.results.length
-				? theme.fg("success", "ok")
-				: theme.fg("error", "failed");
+		: d.parentAskYielded
+			? theme.fg("warning", "yielded")
+			: hasEmptyWithoutTarget
+				? theme.fg("warning", "warning")
+				: ok === d.results.length
+					? theme.fg("success", "ok")
+					: theme.fg("error", "failed");
 
 	const totalSummary =
 		d.progressSummary ||
@@ -410,5 +434,5 @@ export function renderSubagentResult(
 		c.addChild(new Spacer(1));
 		c.addChild(new Text(fit(theme.fg("dim", `Artifacts dir: ${shortenPath(d.artifacts.dir)}`)), 0, 0));
 	}
-	return c;
+	return appendParentAskOutput(c, handoffOutput, theme);
 }

package/dist/builtin/subagents/src/tui/render-status-progress.ts

@@ -135,7 +135,7 @@ export function firstOutputLine(text: string): string {
 export function resultStatusLine(result: Details["results"][number], output: string): string {
 	if (result.detached) return result.detachedReason ? `Detached: ${result.detachedReason}` : "Detached";
 	if (result.status === "continued") return "Continued";
-	if (result.interrupted || result.status === "interrupted") return "Paused";
+	if (result.interrupted || result.status === "interrupted") return "Interrupted";
 	if (result.status === "skipped") return result.error ? `Skipped: ${result.error}` : "Skipped";
 	if (result.status === "error") return `Error: ${result.error ?? (firstOutputLine(output) || "failed")}`;
 	if (hasEmptyTextOutputWithoutOutputTarget(result.task, output)) return "Done (no text output)";

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

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

package/dist/builtin/workflows/CHANGELOG.md

@@ -6,6 +6,16 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.9.16-alpha.1] - 2026-08-23
+
+### Fixed
+
+- Fixed Windows embedded Postgres startup waiting forever when the daemon inherited `pg_ctl` pipes by directly spawning Postgres behind an opaque native process lease. Orderly shutdown now sends fast shutdown and bounded-waits on that exact retained child/HANDLE, preventing mutable-pidfile and PID-reuse races while leaving attached clusters untouched; failed or timed-out shutdown retains the lease for retry. Linux root runtime copies are now exact, root-owned, read/execute-only generations for the dropped Postgres account, with source and post-rename validation, atomically replaced monotonic setup heartbeats, final publication-lease checks, and bounded fail-closed corruption handling ([#2547](https://github.com/bastani-inc/atomic/issues/2547), [#2544](https://github.com/bastani-inc/atomic/pull/2544) by [@darionco](https://github.com/darionco)).
+
+- Fixed active zero-stage workflows whose only work is durable `ctx.tool` calls being under-represented in the below-editor `BACKGROUND` panel. Normal-width cards now show a single pending or running tool node by name and status; when multiple nodes are live, their total appears before the width-clamped node details. The narrow collapsed form shows only the live-tool count, and no synthetic stage is created. The panel mounts for tool-only runs loaded after installation, keeps updating through workflow-resource reload, and remounts from the adopted run store after full `/reload`. Installed builds can evaluate the extension and host SDK as separate jiti module copies; their canonical session-bus map is now process-shared, preventing a replacement generation from adopting an empty store and dropping the live job, cancellation, and tool-control owners. Same-process extension reload preserves the live durable tool callback so its active node settles normally alongside cached completed siblings; a real process exit continues to require explicit durable resume for unfinished callbacks.
+
+- Fixed a never-settling public workflow tool request blocking the interactive agent indefinitely. All 15 workflow actions now share one hard 30-second request deadline that aborts cancellable work, emits one structured timeout error, discards late settlement, and never retries. Timed-out mutations report an unknown outcome and direct callers to inspect workflow status before retrying; a timed-out run that already allocated detached execution returns its exact run id for that inspection, while background run/resume execution remains independent after its acknowledgement ([#2605](https://github.com/bastani-inc/atomic/issues/2605)).
+
 ## [0.9.15] - 2026-08-21
 
 Cumulative release of the `0.9.15-alpha.1` prerelease. The summary below covers the user-visible outcome of that work; the per-change detail remains in the prerelease section below.

package/dist/builtin/workflows/README.md

@@ -662,7 +662,7 @@ Named launches return only after startup admission, while the admitted workflow
 
 Graceful quit is idempotent for already-paused runs and preserves unresolved `ctx.ui` prompts in DBOS. Pausing or interrupting a stage also holds every queued steering and follow-up item in place: no queued turn, late context-bearing delivery, or workflow continuation starts while the stage is paused, and the existing `resume` action releases the items once in their existing per-queue order without queue release itself starting a provider turn. Stable author-callsite-and-composed-nested-scope reservations are created before prompting and released by exact current-format token generation after answer checkpoint, rejection, or abort. Answering while quit/paused cannot advance workflow code until explicit resume.
 
-Workflow durability requires DBOS/Postgres. Atomic configures and launches DBOS lazily on the first workflow action, reuses that process-wide instance, and awaits readiness before durable execution or control. Initialization or persistence failures fail the workflow action; no alternate backend is selected. `DBOS_SYSTEM_DATABASE_URL` selects an existing database when supplied; otherwise Atomic runs DBOS against its own embedded Postgres (npm-distributed binaries, detached `pg_ctl` daemon under `~/.atomic/postgres` on port 5439, shared across sessions and never stopped by Atomic), with DBOS's `dbos-db` Docker container only as a platform fallback. Concurrent Atomic sessions safely share one database: unique per-process executor ids, owner/heartbeat metadata on running workflows, and first-writer-wins claims on contended status transitions prevent double dispatch. Running workflows never appear as resume targets in any session; stale-heartbeat (crashed) ones surface as red `crashed` rows, paused rows render yellow, failed/blocked red, completed green, and the open picker live-updates on local changes plus a bounded cross-session poll.
+Workflow durability uses DBOS/Postgres as its only persistent backend. Atomic initializes it lazily on the first workflow action, reuses that process-wide instance, and awaits readiness before durable execution or control. `DBOS_SYSTEM_DATABASE_URL` selects an existing database when supplied. Otherwise Atomic first provisions its embedded Postgres (npm-distributed binaries, directly spawned under `~/.atomic/postgres` on port 5439, shared across sessions) and tries DBOS's reusable `dbos-db` Docker container if embedded provisioning fails without leaving retained-process cleanup pending. Linux root execution clears inherited supplementary groups before dropping Postgres to an unprivileged primary GID/UID; when that account cannot traverse the installed binaries, Atomic publishes one exact package-content runtime generation under a root-owned cache, where it stays readable/executable but not writable by Postgres. Reuse and publication re-snapshot the current source, validate the deterministic path after rename, and fail closed on source mutation, corruption, or setup-lease displacement without accumulating unbounded repair copies. If DBOS still cannot become ready, Atomic logs a loud warning and runs against one process-local in-memory backend: workflow execution continues, but its state does not survive the process and `/workflow resume` after exit has nothing to restore. Once DBOS is ready, query or write failures fail the workflow action and do not switch backends. Abrupt Atomic exit releases the retained native process lease without killing Postgres. Orderly shutdown sends fast shutdown and waits on that exact retained process; sessions attached to an already-running cluster never own or stop it. Concurrent Atomic sessions safely share one database: unique per-process executor ids, owner/heartbeat metadata on running workflows, and first-writer-wins claims on contended status transitions prevent double dispatch. Running workflows never appear as resume targets in any session; stale-heartbeat (crashed) ones surface as red `crashed` rows, paused rows render yellow, failed/blocked red, completed green, and the open picker live-updates on local changes plus a bounded cross-session poll.
 
 DBOS is the only durable catalog for resume, completed inspection, deletion, and targeted lookup. Session JSONL files remain chat transcripts only. Atomic reads one current durable format and does not convert prior local state or pre-current DBOS records. A completed current-format child checkpoint created before boundary-start or invocation-fingerprint identity existed is shown only when its child checkpoints reciprocally prove the same root, parent run, boundary, child owner, and scope. Active checkpoints without a provable invocation fingerprint, and malformed, duplicate, stale, nonreciprocal, mixed, aliased, cyclic, orphaned, or unsupported topology, fail closed before cache exposure or child/control dispatch: Atomic does not invent a child link or execute child code to repair it.
 

package/dist/builtin/workflows/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/workflows",
-  "version": "0.9.15",
+  "version": "0.9.16-alpha.1",
   "private": true,
   "description": "Atomic extension for multi-stage workflow authoring and execution.",
   "contributors": [