@bastani/atomic 0.9.15 → 0.9.16-alpha.2

package/dist/builtin/subagents/src/slash/slash-commands.ts

@@ -1,469 +1,5 @@
-import { randomUUID } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import {
-	type ExtensionAPI,
-	type ExtensionContext,
-	isStaleExtensionContextError,
-	keyHintIfBound,
-} from "@bastani/atomic";
-import { Key, matchesKey } from "@earendil-works/pi-tui";
-import { discoverAgents } from "../agents/agents.js";
-import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.js";
-import {
-	type SingleResult,
-	SLASH_RESULT_TYPE,
-	SLASH_SUBAGENT_CANCEL_EVENT,
-	SLASH_SUBAGENT_REQUEST_EVENT,
-	SLASH_SUBAGENT_RESPONSE_EVENT,
-	SLASH_SUBAGENT_STARTED_EVENT,
-	SLASH_SUBAGENT_UPDATE_EVENT,
-	type SubagentState,
-} from "../shared/types.js";
-import { registerBridgeRequestSettlement } from "./bridge-settlement.js";
-import type { SlashSubagentResponse, SlashSubagentUpdate } from "./slash-bridge.js";
-import { applySlashUpdate, buildSlashInitialResult, failSlashResult, finalizeSlashResult } from "./slash-live-state.js";
+import type { ExtensionAPI } from "@bastani/atomic";
+import type { SubagentState } from "../shared/types.js";
 
-interface InlineConfig {
-	output?: string | false;
-	outputMode?: "inline" | "file-only";
-	reads?: string[] | false;
-	model?: string;
-	skill?: string[] | false;
-	progress?: boolean;
-}
-
-const parseInlineConfig = (raw: string): InlineConfig => {
-	const config: InlineConfig = {};
-	for (const part of raw.split(",")) {
-		const trimmed = part.trim();
-		if (!trimmed) continue;
-		const eq = trimmed.indexOf("=");
-		if (eq === -1) {
-			if (trimmed === "progress") config.progress = true;
-			continue;
-		}
-		const key = trimmed.slice(0, eq).trim();
-		const val = trimmed.slice(eq + 1).trim();
-		switch (key) {
-			case "output":
-				config.output = val === "false" ? false : val;
-				break;
-			case "outputMode":
-				if (val === "inline" || val === "file-only") config.outputMode = val;
-				break;
-			case "reads":
-				config.reads = val === "false" ? false : val.split("+").filter(Boolean);
-				break;
-			case "model":
-				config.model = val || undefined;
-				break;
-			case "skill":
-			case "skills":
-				config.skill = val === "false" ? false : val.split("+").filter(Boolean);
-				break;
-			case "progress":
-				config.progress = val !== "false";
-				break;
-		}
-	}
-	return config;
-};
-
-const parseAgentToken = (token: string): { name: string; config: InlineConfig } => {
-	const bracket = token.indexOf("[");
-	if (bracket === -1) return { name: token, config: {} };
-	const end = token.lastIndexOf("]");
-	return {
-		name: token.slice(0, bracket),
-		config: parseInlineConfig(token.slice(bracket + 1, end !== -1 ? end : undefined)),
-	};
-};
-
-const extractExecutionFlags = (rawArgs: string): { args: string; fork: boolean } => {
-	let args = rawArgs.trim();
-	let fork = false;
-	while (true) {
-		if (args.endsWith(" --fork") || args === "--fork") {
-			fork = true;
-			args = args === "--fork" ? "" : args.slice(0, -7).trim();
-			continue;
-		}
-		break;
-	}
-	return { args, fork };
-};
-
-const makeAgentCompletions = (state: SubagentState, multiAgent: boolean) => (prefix: string) => {
-	if (!state.baseCwd) return null;
-	const agents = discoverAgents(state.baseCwd, "both").agents;
-	if (!multiAgent) {
-		if (prefix.includes(" ")) return null;
-		return agents.filter((a) => a.name.startsWith(prefix)).map((a) => ({ value: a.name, label: a.name }));
-	}
-
-	const lastArrow = prefix.lastIndexOf(" -> ");
-	const segment = lastArrow !== -1 ? prefix.slice(lastArrow + 4) : prefix;
-	if (segment.includes(" -- ") || segment.includes('"') || segment.includes("'")) return null;
-
-	const lastWord = (prefix.match(/(\S*)$/) || ["", ""])[1];
-	const beforeLastWord = prefix.slice(0, prefix.length - lastWord.length);
-
-	if (lastWord === "->") {
-		return agents.map((a) => ({ value: `${prefix} ${a.name}`, label: a.name }));
-	}
-
-	return agents
-		.filter((a) => a.name.startsWith(lastWord))
-		.map((a) => ({ value: `${beforeLastWord}${a.name}`, label: a.name }));
-};
-
-async function requestSlashRun(
-	pi: ExtensionAPI,
-	ctx: ExtensionContext,
-	requestId: string,
-	params: SubagentParamsLike,
-): Promise<SlashSubagentResponse> {
-	return new Promise((resolve, reject) => {
-		let done = false;
-		let started = false;
-
-		const startTimeoutMs = 15_000;
-		const startTimeout = setTimeout(() => {
-			finish(() =>
-				reject(
-					new Error("Slash subagent bridge did not start within 15s. Ensure the extension is loaded correctly."),
-				),
-			);
-		}, startTimeoutMs);
-
-		const onStarted = (data: unknown) => {
-			if (done || !data || typeof data !== "object") return;
-			if ((data as { requestId?: unknown }).requestId !== requestId) return;
-			started = true;
-			clearTimeout(startTimeout);
-			if (ctx.hasUI) ctx.ui.setStatus("subagent-slash", "running...");
-		};
-
-		const onResponse = (data: unknown) => {
-			if (done || !data || typeof data !== "object") return;
-			const response = data as Partial<SlashSubagentResponse>;
-			if (response.requestId !== requestId) return;
-			clearTimeout(startTimeout);
-			finish(() => resolve(response as SlashSubagentResponse));
-		};
-
-		const onUpdate = (data: unknown) => {
-			if (done || !data || typeof data !== "object") return;
-			const update = data as SlashSubagentUpdate;
-			if (update.requestId !== requestId) return;
-			applySlashUpdate(requestId, update, pi);
-			if (!ctx.hasUI) return;
-			const tool = update.currentTool ? ` ${update.currentTool}` : "";
-			const count = update.toolCount ?? 0;
-			const expandHint = keyHintIfBound("app.tools.expand", "live detail");
-			ctx.ui.setStatus("subagent-slash", `${count} tools${tool}${expandHint ? ` | ${expandHint}` : ""}`);
-		};
-
-		const onTerminalInput = ctx.hasUI
-			? ctx.ui.onTerminalInput((input) => {
-					if (!matchesKey(input, Key.escape)) return undefined;
-					try {
-						pi.events.emit(SLASH_SUBAGENT_CANCEL_EVENT, { requestId });
-						finish(() => reject(new Error("Cancelled")));
-					} catch (error) {
-						finish(() => reject(error));
-					}
-					return { consume: true };
-				})
-			: undefined;
-
-		const unsubStarted = pi.events.on(SLASH_SUBAGENT_STARTED_EVENT, onStarted);
-		const unsubResponse = pi.events.on(SLASH_SUBAGENT_RESPONSE_EVENT, onResponse);
-		const unsubUpdate = pi.events.on(SLASH_SUBAGENT_UPDATE_EVENT, onUpdate);
-
-		let unregisterSettlement: (() => void) | undefined;
-		let reportedStop = false;
-		const finish = (next: () => void) => {
-			if (done) return;
-			done = true;
-			clearTimeout(startTimeout);
-			unsubStarted();
-			unsubResponse();
-			unsubUpdate();
-			onTerminalInput?.();
-			unregisterSettlement?.();
-			next();
-		};
-
-		unregisterSettlement = registerBridgeRequestSettlement("slash", requestId, {
-			reject: (error: unknown) => {
-				if (!reportedStop) {
-					reportedStop = true;
-					console.error(
-						isStaleExtensionContextError(error)
-							? "Subagent slash command stopped because its response runtime was replaced or reloaded."
-							: "Subagent slash command stopped before its response was delivered.",
-					);
-				}
-				finish(() => reject(error));
-			},
-		});
-		try {
-			pi.events.emit(SLASH_SUBAGENT_REQUEST_EVENT, { requestId, params });
-		} catch (error) {
-			finish(() => reject(error));
-			return;
-		}
-
-		// Bridge emits STARTED synchronously during REQUEST emit.
-		// If not started, no bridge received the request.
-		if (!started && done) return;
-		if (!started) {
-			finish(() =>
-				reject(new Error("No slash subagent bridge responded. Ensure the subagent extension is loaded correctly.")),
-			);
-		}
-	});
-}
-
-function extractSlashMessageText(content: string | Array<{ type?: string; text?: string }>): string {
-	if (typeof content === "string") return content;
-	if (!Array.isArray(content)) return "";
-	return content
-		.filter((part): part is { type: "text"; text: string } => part?.type === "text" && typeof part.text === "string")
-		.map((part) => part.text)
-		.join("\n");
-}
-
-function formatExportPathList(paths: string[]): string {
-	return paths.map((file) => `- \`${file}\``).join("\n");
-}
-
-function collectResultPaths(results: SingleResult[], getPath: (result: SingleResult) => string | undefined): string[] {
-	return results.map(getPath).filter((file): file is string => typeof file === "string" && file.length > 0);
-}
-
-function buildSlashExportText(response: SlashSubagentResponse): string {
-	const output = extractSlashMessageText(response.result.content) || response.errorText || "(no output)";
-	const results = response.result.details?.results ?? [];
-	const sessionFiles = collectResultPaths(results, (result) => result.sessionFile);
-	const savedOutputs = collectResultPaths(results, (result) => result.savedOutputPath);
-	const artifactOutputs = collectResultPaths(results, (result) => result.artifactPaths?.outputPath);
-	const sections = ["## Subagent result", output];
-	if (sessionFiles.length > 0) sections.push("## Child session exports", formatExportPathList(sessionFiles));
-	if (savedOutputs.length > 0) sections.push("## Saved outputs", formatExportPathList(savedOutputs));
-	if (artifactOutputs.length > 0) sections.push("## Artifact outputs", formatExportPathList(artifactOutputs));
-	return sections.join("\n\n");
-}
-
-function persistSlashSessionSnapshot(ctx: ExtensionContext): void {
-	try {
-		if (!ctx.sessionManager) return;
-		const sessionManager = ctx.sessionManager as typeof ctx.sessionManager & {
-			_rewriteFile?: () => void;
-			flushed?: boolean;
-		};
-		const sessionFile = sessionManager.getSessionFile();
-		if (!sessionFile || typeof sessionManager._rewriteFile !== "function") return;
-		fs.mkdirSync(path.dirname(sessionFile), { recursive: true });
-		sessionManager._rewriteFile();
-		sessionManager.flushed = true;
-	} catch (error) {
-		console.error("Failed to persist slash session snapshot for export:", error);
-	}
-}
-
-async function runSlashSubagent(pi: ExtensionAPI, ctx: ExtensionContext, params: SubagentParamsLike): Promise<void> {
-	if (ctx.hasUI) ctx.ui.setToolsExpanded(false);
-	const requestId = randomUUID();
-	const initialDetails = buildSlashInitialResult(requestId, params, pi);
-	const initialText = extractSlashMessageText(initialDetails.result.content) || "Running subagent...";
-	pi.sendMessage({
-		customType: SLASH_RESULT_TYPE,
-		content: initialText,
-		display: true,
-		details: initialDetails,
-	});
-	persistSlashSessionSnapshot(ctx);
-
-	try {
-		const response = await requestSlashRun(pi, ctx, requestId, params);
-		const finalDetails = finalizeSlashResult(response, pi);
-		pi.sendMessage({
-			customType: SLASH_RESULT_TYPE,
-			content: buildSlashExportText(response),
-			display: true,
-			details: finalDetails,
-		});
-		persistSlashSessionSnapshot(ctx);
-		if (ctx.hasUI) {
-			ctx.ui.setStatus("subagent-slash", undefined);
-		}
-		if (response.isError && ctx.hasUI) {
-			ctx.ui.notify(response.errorText || "Subagent failed", "error");
-		}
-	} catch (error) {
-		if (isStaleExtensionContextError(error)) throw error;
-		const message = error instanceof Error ? error.message : String(error);
-		const failedDetails = failSlashResult(requestId, params, message, pi);
-		pi.sendMessage({
-			customType: SLASH_RESULT_TYPE,
-			content: `## Subagent result\n\n${message}`,
-			display: true,
-			details: failedDetails,
-		});
-		persistSlashSessionSnapshot(ctx);
-		if (ctx.hasUI) {
-			ctx.ui.setStatus("subagent-slash", undefined);
-		}
-		if (message === "Cancelled") {
-			if (ctx.hasUI) ctx.ui.notify("Cancelled", "warning");
-			return;
-		}
-		if (ctx.hasUI) ctx.ui.notify(message, "error");
-	}
-}
-
-interface ParsedStep {
-	name: string;
-	config: InlineConfig;
-	task?: string;
-}
-const parseAgentArgs = (
-	state: SubagentState,
-	args: string,
-	command: string,
-	ctx: ExtensionContext,
-): { steps: ParsedStep[]; task: string } | null => {
-	const input = args.trim();
-	const usage = `Usage: /${command} agent1 "task1" -> agent2 "task2"`;
-	let steps: ParsedStep[];
-	let sharedTask: string;
-	if (input.includes(" -> ")) {
-		const segments = input.split(" -> ");
-		steps = [];
-		for (const seg of segments) {
-			const trimmed = seg.trim();
-			if (!trimmed) continue;
-			let agentPart: string;
-			let task: string | undefined;
-			const qMatch = trimmed.match(/^(\S+(?:\[[^\]]*\])?)\s+(?:"([^"]*)"|'([^']*)')$/);
-			if (qMatch) {
-				agentPart = qMatch[1]!;
-				task = (qMatch[2] ?? qMatch[3]) || undefined;
-			} else {
-				const dashIdx = trimmed.indexOf(" -- ");
-				if (dashIdx !== -1) {
-					agentPart = trimmed.slice(0, dashIdx).trim();
-					task = trimmed.slice(dashIdx + 4).trim() || undefined;
-				} else {
-					agentPart = trimmed;
-				}
-			}
-			const parsed = parseAgentToken(agentPart);
-			steps.push({ ...parsed, task });
-		}
-		sharedTask = steps.find((s) => s.task)?.task ?? "";
-	} else {
-		const delimiterIndex = input.indexOf(" -- ");
-		if (delimiterIndex === -1) {
-			ctx.ui.notify(usage, "error");
-			return null;
-		}
-		const agentsPart = input.slice(0, delimiterIndex).trim();
-		sharedTask = input.slice(delimiterIndex + 4).trim();
-		if (!agentsPart || !sharedTask) {
-			ctx.ui.notify(usage, "error");
-			return null;
-		}
-		steps = agentsPart
-			.split(/\s+/)
-			.filter(Boolean)
-			.map((t) => parseAgentToken(t));
-	}
-	if (steps.length === 0) {
-		ctx.ui.notify(usage, "error");
-		return null;
-	}
-	if (!state.baseCwd) {
-		ctx.ui.notify("Subagent session cwd is not initialized yet", "error");
-		return null;
-	}
-	const agents = discoverAgents(state.baseCwd, "both").agents;
-	for (const step of steps) {
-		if (!agents.find((a) => a.name === step.name)) {
-			ctx.ui.notify(`Unknown agent: ${step.name}`, "error");
-			return null;
-		}
-	}
-	if (command === "parallel" && !steps.some((s) => s.task) && !sharedTask) {
-		ctx.ui.notify("At least one step must have a task", "error");
-		return null;
-	}
-	return { steps, task: sharedTask };
-};
-export function registerSlashCommands(pi: ExtensionAPI, state: SubagentState): void {
-	pi.registerCommand("run", {
-		description: "Run a subagent directly: /run agent[output=file] [task] [--fork]",
-		getArgumentCompletions: makeAgentCompletions(state, false),
-		handler: async (args, ctx) => {
-			const { args: cleanedArgs, fork } = extractExecutionFlags(args);
-			const input = cleanedArgs.trim();
-			const firstSpace = input.indexOf(" ");
-			if (!input) {
-				ctx.ui.notify("Usage: /run <agent> [task] [--fork]", "error");
-				return;
-			}
-			const { name: agentName, config: inline } = parseAgentToken(
-				firstSpace === -1 ? input : input.slice(0, firstSpace),
-			);
-			const task = firstSpace === -1 ? "" : input.slice(firstSpace + 1).trim();
-			if (!state.baseCwd) {
-				ctx.ui.notify("Subagent session cwd is not initialized yet", "error");
-				return;
-			}
-			const agents = discoverAgents(state.baseCwd, "both").agents;
-			if (!agents.find((a) => a.name === agentName)) {
-				ctx.ui.notify(`Unknown agent: ${agentName}`, "error");
-				return;
-			}
-			const params: SubagentParamsLike = { agent: agentName, task, agentScope: "both" };
-			if (inline.reads !== undefined) params.reads = inline.reads;
-			if (inline.output !== undefined) params.output = inline.output;
-			if (inline.outputMode !== undefined) params.outputMode = inline.outputMode;
-			if (inline.skill !== undefined) params.skill = inline.skill;
-			if (inline.model) params.model = inline.model;
-			if (fork) params.context = "fork";
-			await runSlashSubagent(pi, ctx, params);
-		},
-	});
-	pi.registerCommand("parallel", {
-		description: 'Run agents in parallel: /parallel scout "task1" -> reviewer "task2" [--fork]',
-		getArgumentCompletions: makeAgentCompletions(state, true),
-		handler: async (args, ctx) => {
-			const { args: cleanedArgs, fork } = extractExecutionFlags(args);
-			const parsed = parseAgentArgs(state, cleanedArgs, "parallel", ctx);
-			if (!parsed) return;
-			const tasks = parsed.steps.map(({ name, config, task: stepTask }) => ({
-				agent: name,
-				task: stepTask ?? parsed.task,
-				...(config.output !== undefined ? { output: config.output } : {}),
-				...(config.outputMode !== undefined ? { outputMode: config.outputMode } : {}),
-				...(config.reads !== undefined ? { reads: config.reads } : {}),
-				...(config.model ? { model: config.model } : {}),
-				...(config.skill !== undefined ? { skill: config.skill } : {}),
-				...(config.progress !== undefined ? { progress: config.progress } : {}),
-			}));
-			const params: SubagentParamsLike = { tasks, agentScope: "both" };
-			if (fork) params.context = "fork";
-			await runSlashSubagent(pi, ctx, params);
-		},
-	});
-	pi.registerCommand("subagents-doctor", {
-		description: "Show subagent diagnostics",
-		handler: async (_args, ctx) => {
-			await runSlashSubagent(pi, ctx, { action: "doctor" });
-		},
-	});
-}
+/** Human `/run` and `/parallel` commands are gone. Launch children with `subagent`. */
+export function registerSlashCommands(_pi: ExtensionAPI, _state: SubagentState): void {}

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.2",
   "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,22 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.9.16-alpha.2] - 2026-08-23
+
+### Added
+
+- Added Lauren Tan's bundled `bro`, `how`, `teach`, `unslop`, and `why` pstack skills for plain-language restatement, codebase explanation, teaching, writing cleanup, and evidence-backed design rationale. Sourced from https://github.com/cursor/plugins and distributed under the MIT License.
+
+## [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.2",
   "private": true,
   "description": "Atomic extension for multi-stage workflow authoring and execution.",
   "contributors": [