@bastani/atomic 0.9.5-alpha.8 → 0.9.5

package/dist/builtin/subagents/src/shared/event-jsonl-writer.ts

@@ -0,0 +1,294 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { DrainableSource, JsonlWriteStream } from "./jsonl-writer.ts";
+
+interface TelemetryState {
+	telemetryBytes: number;
+	telemetryTruncated: boolean;
+}
+
+interface SharedEventWriter extends TelemetryState {
+	stream: JsonlWriteStream;
+	sources: Set<DrainableSource>;
+	refs: number;
+	backpressured: boolean;
+	closed: boolean;
+	failed: boolean;
+	filePath: string;
+	key: string;
+	closingLines: string[];
+	settled: Promise<void>;
+	resolveSettled: () => void;
+}
+
+const writers = new Map<string, SharedEventWriter>();
+
+interface TelemetryHydration extends TelemetryState {
+	dev: number;
+	ino: number;
+	size: number;
+	mtimeMs: number;
+	ctimeMs: number;
+}
+
+const hydrationCache = new Map<string, TelemetryHydration>();
+const MAX_HYDRATION_ENTRIES = 512;
+const HYDRATION_CHUNK_BYTES = 64 * 1024;
+const TRUNCATION_MARKER = '"type":"subagent.child.telemetry_truncated"';
+let hydrationScanCount = 0;
+let hydrationScannedBytes = 0;
+
+function keyFor(filePath: string): string {
+	return path.resolve(filePath);
+}
+
+function cacheHydration(key: string, hydration: TelemetryHydration): void {
+	hydrationCache.delete(key);
+	hydrationCache.set(key, hydration);
+	while (hydrationCache.size > MAX_HYDRATION_ENTRIES) {
+		const oldest = hydrationCache.keys().next().value as string | undefined;
+		if (oldest === undefined) break;
+		hydrationCache.delete(oldest);
+	}
+}
+
+function scanForTruncationMarker(filePath: string): boolean {
+	hydrationScanCount += 1;
+	const handle = fs.openSync(filePath, "r");
+	try {
+		const buffer = Buffer.allocUnsafe(HYDRATION_CHUNK_BYTES);
+		let offset = 0;
+		let overlap = "";
+		while (true) {
+			const count = fs.readSync(handle, buffer, 0, buffer.length, offset);
+			if (count === 0) return false;
+			hydrationScannedBytes += count;
+			const text = overlap + buffer.subarray(0, count).toString("utf-8");
+			if (text.includes(TRUNCATION_MARKER)) return true;
+			overlap = text.slice(-(TRUNCATION_MARKER.length - 1));
+			offset += count;
+		}
+	} finally {
+		fs.closeSync(handle);
+	}
+}
+
+function hydrationFromStat(stat: fs.Stats, state: TelemetryState): TelemetryHydration {
+	return { dev: Number(stat.dev), ino: Number(stat.ino), size: stat.size, mtimeMs: stat.mtimeMs, ctimeMs: stat.ctimeMs, ...state };
+}
+
+function existingTelemetryState(filePath: string, seed?: TelemetryState): TelemetryState {
+	const key = keyFor(filePath);
+	try {
+		const stat = fs.statSync(filePath);
+		const telemetryTruncated = Boolean(seed?.telemetryTruncated) || scanForTruncationMarker(filePath);
+		const telemetryBytes = Math.max(stat.size, seed?.telemetryBytes ?? 0);
+		cacheHydration(key, hydrationFromStat(stat, { telemetryBytes, telemetryTruncated }));
+		return { telemetryBytes, telemetryTruncated };
+	} catch {
+		hydrationCache.delete(key);
+		return seed
+			? { telemetryBytes: seed.telemetryBytes, telemetryTruncated: seed.telemetryTruncated }
+			: { telemetryBytes: 0, telemetryTruncated: false };
+	}
+}
+
+function cacheSettledWriter(writer: SharedEventWriter): void {
+	try {
+		const stat = fs.statSync(writer.filePath);
+		cacheHydration(writer.key, hydrationFromStat(stat, {
+			telemetryBytes: Math.max(stat.size, writer.telemetryBytes),
+			telemetryTruncated: writer.telemetryTruncated,
+		}));
+	} catch { hydrationCache.delete(writer.key); }
+}
+
+export function resetEventWriterHydrationCacheForTests(): void {
+	hydrationCache.clear();
+	hydrationScanCount = 0;
+	hydrationScannedBytes = 0;
+}
+
+export function eventWriterHydrationCacheSizeForTests(): number {
+	return hydrationCache.size;
+}
+
+export function eventWriterHydrationScanStatsForTests(): { scans: number; bytes: number } {
+	return { scans: hydrationScanCount, bytes: hydrationScannedBytes };
+}
+
+function resumeSources(writer: SharedEventWriter): void {
+	for (const source of writer.sources) source.resume();
+	writer.sources.clear();
+	writer.backpressured = false;
+}
+
+function settleWriter(writer: SharedEventWriter): void {
+	if (!writer.failed) cacheSettledWriter(writer);
+	if (writers.get(writer.key) === writer) writers.delete(writer.key);
+	resumeSources(writer);
+	writer.resolveSettled();
+}
+
+function failWriter(writer: SharedEventWriter): void {
+	if (writer.failed) return;
+	writer.failed = true;
+	writer.closed = true;
+	settleWriter(writer);
+}
+
+function write(writer: SharedEventWriter, chunk: string): void {
+	if (writer.closed || writer.failed) return;
+	try {
+		const accepted = writer.stream.write(chunk);
+		if (!accepted && !writer.backpressured) {
+			writer.backpressured = true;
+			for (const source of writer.sources) source.pause();
+			writer.stream.once("drain", () => {
+				writer.backpressured = false;
+				if (!writer.closed && !writer.failed) for (const source of writer.sources) source.resume();
+			});
+		}
+	} catch {
+		failWriter(writer);
+	}
+}
+
+export interface EventWriterLease {
+	reserveTelemetry(bytes: number, maxBytes: number): boolean;
+	claimTruncationMarker(): boolean;
+	writeLine(line: string): void;
+	close(): Promise<void>;
+}
+
+type StreamFactory = (filePath: string) => JsonlWriteStream;
+
+function createDeferredLease(
+	closingWriter: SharedEventWriter,
+	filePath: string,
+	source: DrainableSource,
+	createWriteStream: StreamFactory,
+): EventWriterLease {
+	const bufferedLines: string[] = [];
+	let inner: EventWriterLease | undefined;
+	let closePromise: Promise<void> | undefined;
+	const activate = async (): Promise<void> => {
+		await closingWriter.settled;
+		inner = acquireEventWriterInternal(filePath, source, createWriteStream, closingWriter);
+		if (!inner) return;
+		for (const line of bufferedLines) inner.writeLine(line);
+		bufferedLines.length = 0;
+	};
+	const activated = activate();
+	return {
+		reserveTelemetry(bytes, maxBytes) {
+			if (inner) return inner.reserveTelemetry(bytes, maxBytes);
+			if (closingWriter.telemetryTruncated || closingWriter.telemetryBytes + bytes > maxBytes) return false;
+			closingWriter.telemetryBytes += bytes;
+			return true;
+		},
+		claimTruncationMarker() {
+			if (inner) return inner.claimTruncationMarker();
+			if (closingWriter.telemetryTruncated) return false;
+			closingWriter.telemetryTruncated = true;
+			return true;
+		},
+		writeLine(line) {
+			if (!line.trim()) return;
+			if (inner) inner.writeLine(line);
+			else bufferedLines.push(line);
+		},
+		close() {
+			closePromise ??= activated.then(() => inner?.close());
+			return closePromise;
+		},
+	};
+}
+
+function createWriter(filePath: string, key: string, createWriteStream: StreamFactory, seed?: TelemetryState): SharedEventWriter | undefined {
+	let stream: JsonlWriteStream;
+	try {
+		stream = createWriteStream(filePath);
+	} catch {
+		return undefined;
+	}
+	let resolveSettled = () => {};
+	const settled = new Promise<void>((resolve) => { resolveSettled = resolve; });
+	const writer: SharedEventWriter = {
+		stream, sources: new Set(), refs: 0, backpressured: false,
+		...existingTelemetryState(filePath, seed),
+		closed: false, failed: false, filePath, key, closingLines: [], settled, resolveSettled,
+	};
+	stream.on?.("error", () => failWriter(writer));
+	writers.set(key, writer);
+	return writer;
+}
+
+function acquireEventWriterInternal(
+	filePath: string,
+	source: DrainableSource,
+	createWriteStream: StreamFactory,
+	seed?: TelemetryState,
+): EventWriterLease | undefined {
+	const key = keyFor(filePath);
+	let writer = writers.get(key);
+	if (writer?.closed) return createDeferredLease(writer, filePath, source, createWriteStream);
+	writer ??= createWriter(filePath, key, createWriteStream, seed);
+	if (!writer) return undefined;
+	writer.refs += 1;
+	writer.sources.add(source);
+	if (writer.backpressured) source.pause();
+	let closePromise: Promise<void> | undefined;
+	return {
+		reserveTelemetry(bytes, maxBytes) {
+			if (writer!.failed || writer!.telemetryTruncated || writer!.telemetryBytes + bytes > maxBytes) return false;
+			writer!.telemetryBytes += bytes;
+			return true;
+		},
+		claimTruncationMarker() {
+			if (writer!.failed || writer!.telemetryTruncated) return false;
+			writer!.telemetryTruncated = true;
+			return true;
+		},
+		writeLine(line) {
+			if (line.trim()) write(writer!, `${line}\n`);
+		},
+		close() {
+			if (closePromise) return closePromise;
+			writer!.sources.delete(source);
+			writer!.refs -= 1;
+			if (writer!.refs > 0 || writer!.failed) return closePromise = Promise.resolve();
+			writer!.closed = true;
+			try {
+				writer!.stream.end(() => {
+					if (!writer!.failed) {
+						for (const line of writer!.closingLines) {
+							try { fs.appendFileSync(writer!.filePath, line); } catch { /* telemetry failure is non-fatal */ }
+						}
+						settleWriter(writer!);
+					}
+				});
+			} catch {
+				failWriter(writer!);
+			}
+			return closePromise = writer!.settled;
+		},
+	};
+}
+
+export function acquireEventWriter(
+	filePath: string,
+	source: DrainableSource,
+	createWriteStream: StreamFactory = (target) => fs.createWriteStream(target, { flags: "a" }),
+): EventWriterLease | undefined {
+	return acquireEventWriterInternal(filePath, source, createWriteStream);
+}
+
+/** Route lifecycle/control appends through an active child writer to avoid mixed handles. */
+export function appendToActiveEventWriter(filePath: string, line: string): boolean {
+	const writer = writers.get(keyFor(filePath));
+	if (!writer) return false;
+	if (writer.closed) writer.closingLines.push(`${line}\n`);
+	else write(writer, `${line}\n`);
+	return true;
+}

package/dist/builtin/subagents/src/shared/exclusive-file-publication.ts

@@ -0,0 +1,44 @@
+import * as fs from "node:fs";
+
+export interface ExclusivePublicationFs {
+	linkSync?: typeof fs.linkSync;
+	copyFileSync?: typeof fs.copyFileSync;
+	unlinkSync: typeof fs.unlinkSync;
+}
+
+export function errorCode(error: unknown): string | undefined {
+	return typeof error === "object" && error !== null && "code" in error
+		? (error as NodeJS.ErrnoException).code
+		: undefined;
+}
+
+/** Publish an existing file without ever replacing the destination. */
+export function publishFileExclusive(
+	source: string,
+	destination: string,
+	fsApi: ExclusivePublicationFs = fs,
+): "published" | "exists" {
+	try {
+		(fsApi.linkSync ?? fs.linkSync)(source, destination);
+		return "published";
+	} catch (error) {
+		const code = errorCode(error);
+		if (code === "EEXIST") return "exists";
+		if (code !== "EPERM" && code !== "EACCES" && code !== "ENOTSUP" && code !== "EXDEV") throw error;
+	}
+	try {
+		(fsApi.copyFileSync ?? fs.copyFileSync)(source, destination, fs.constants.COPYFILE_EXCL);
+		return "published";
+	} catch (error) {
+		if (errorCode(error) === "EEXIST") return "exists";
+		throw error;
+	}
+}
+
+export function unlinkIfPresent(file: string, fsApi: Pick<typeof fs, "unlinkSync"> = fs): void {
+	try {
+		fsApi.unlinkSync(file);
+	} catch (error) {
+		if (errorCode(error) !== "ENOENT") throw error;
+	}
+}

package/dist/builtin/subagents/src/shared/jsonl-writer.ts

@@ -7,6 +7,7 @@ export interface DrainableSource {
 
 export interface JsonlWriteStream {
 	write(chunk: string): boolean;
+	on?(event: "error", listener: (error: Error) => void): JsonlWriteStream;
 	once(event: "drain", listener: () => void): JsonlWriteStream;
 	end(callback?: () => void): void;
 }

package/dist/builtin/subagents/src/shared/model-info.ts

@@ -1,4 +1,4 @@
-export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
+export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
 export type ThinkingLevel = typeof THINKING_LEVELS[number];
 export type ThinkingLevelMap = Partial<Record<ThinkingLevel, string | null>>;
 
@@ -87,7 +87,7 @@ export function getSupportedThinkingLevels(model: ModelInfo | undefined): Thinki
 	const levels = THINKING_LEVELS.filter((level) => {
 		const mapped = model.thinkingLevelMap?.[level];
 		if (mapped === null) return false;
-		if (level === "xhigh") return mapped !== undefined;
+		if (level === "xhigh" || level === "max") return mapped !== undefined;
 		return true;
 	});
 	return levels;

package/dist/builtin/subagents/src/shared/settings.ts

@@ -286,15 +286,21 @@ export function suppressProgressForReadOnlyTask(behavior: ResolvedStepBehavior,
 	return behavior.progress && taskDisallowsFileUpdates(policyTask) ? { ...behavior, progress: false } : behavior;
 }
 
+/** Resolve single-agent progress, preserving read-only suppression only for inherited defaults. */
+export function resolveSingleProgress(agentConfig: AgentConfig, override: boolean | undefined, task: string | undefined): boolean {
+	const behavior = resolveStepBehavior(agentConfig, { progress: override });
+	return override !== undefined ? behavior.progress : suppressProgressForReadOnlyTask(behavior, task).progress;
+}
+
 // =============================================================================
 // Chain Instruction Injection
 // =============================================================================
 
-/**
- * Resolve a file path: absolute paths pass through, relative paths get chainDir prepended.
- */
-function resolveChainPath(filePath: string, chainDir: string): string {
-	return path.isAbsolute(filePath) ? filePath : path.join(chainDir, filePath);
+/** Build the common read prefix, resolving relative paths against the child's effective cwd. */
+export function buildReadInstruction(reads: string[] | false | undefined, cwd: string): string {
+	if (!reads || reads.length === 0) return "";
+	const files = reads.map((file) => path.resolve(cwd, file));
+	return `[Read from: ${files.join(", ")}]`;
 }
 
 /**
@@ -302,9 +308,15 @@ function resolveChainPath(filePath: string, chainDir: string): string {
  * These are appended to the task to tell the agent what to read/write.
  */
 export function writeInitialProgressFile(progressDir: string): void {
+	fs.mkdirSync(progressDir, { recursive: true });
 	fs.writeFileSync(path.join(progressDir, "progress.md"), INITIAL_PROGRESS_CONTENT);
 }
 
+/** Add the child-facing instruction for a single-agent progress file. */
+export function injectSingleProgressInstruction(task: string, progressDir: string): string {
+	return `${task}\n\n---\nCreate and maintain progress at: ${path.join(progressDir, "progress.md")}`;
+}
+
 export function buildChainInstructions(
 	behavior: ResolvedStepBehavior,
 	chainDir: string,
@@ -315,14 +327,12 @@ export function buildChainInstructions(
 	const suffixParts: string[] = [];
 
 	// READS - prepend to override any hardcoded filenames in task text
-	if (behavior.reads && behavior.reads.length > 0) {
-		const files = behavior.reads.map((f) => resolveChainPath(f, chainDir));
-		prefixParts.push(`[Read from: ${files.join(", ")}]`);
-	}
+	const readInstruction = buildReadInstruction(behavior.reads, chainDir);
+	if (readInstruction) prefixParts.push(readInstruction);
 
 	// OUTPUT - prepend so agent knows where to write
 	if (behavior.output) {
-		const outputPath = resolveChainPath(behavior.output, chainDir);
+		const outputPath = path.isAbsolute(behavior.output) ? behavior.output : path.join(chainDir, behavior.output);
 		prefixParts.push(`[Write to: ${outputPath}]`);
 	}
 

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

@@ -8,6 +8,7 @@ import type {
 	ActivityState,
 	ChainOutputMap,
 	ModelAttempt,
+	SingleResult,
 	SubagentResultStatus,
 	SubagentRunMode,
 	TokenUsage,
@@ -216,6 +217,7 @@ export interface ForegroundResumeChild {
 	index: number;
 	sessionFile?: string;
 	status: SubagentResultStatus;
+	result?: SingleResult;
 }
 
 export interface ForegroundResumeRun {
@@ -256,7 +258,7 @@ export interface SubagentState {
 	cleanupTimers: Map<string, ReturnType<typeof setTimeout>>;
 	lastUiContext: ExtensionContext | null;
 	poller: NodeJS.Timeout | null;
-	completionSeen: Map<string, number>;
+	completionSeen: Map<string, number | { seenAt: number; signature?: string }>;
 	watcher: FSWatcher | null;
 	watcherRestartTimer: ReturnType<typeof setTimeout> | null;
 	resultFileCoalescer: {

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

@@ -13,6 +13,7 @@ import type {
 	MaxOutputConfig,
 	OutputMode,
 	ResolvedControlConfig,
+	SingleResult,
 } from "./types-results.ts";
 
 // ============================================================================
@@ -58,6 +59,7 @@ export interface RunSyncOptions {
 	interruptSignal?: AbortSignal;
 	allowIntercomDetach?: boolean;
 	intercomEvents?: IntercomEventBus;
+	onDetachedExit?: (result: SingleResult) => void;
 	onUpdate?: (r: AgentToolResult<Details>) => void;
 	onControlEvent?: (event: ControlEvent) => void;
 	controlConfig?: ResolvedControlConfig;

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

@@ -77,7 +77,7 @@ export function resolveTempScopeId(options?: {
 	return "shared";
 }
 
-const MAX_PARALLEL = 8;
+export const MAX_PARALLEL_TASKS = 50;
 export const MAX_CONCURRENCY = 4;
 export const TEMP_ROOT_DIR = path.join(os.tmpdir(), `${APP_NAME}-subagents-${resolveTempScopeId()}`);
 export const RESULTS_DIR = path.join(TEMP_ROOT_DIR, "async-subagent-results");
@@ -110,7 +110,8 @@ function normalizeTopLevelParallelValue(value: unknown): number | undefined {
 }
 
 export function resolveTopLevelParallelMaxTasks(value: unknown): number {
-	return normalizeTopLevelParallelValue(value) ?? MAX_PARALLEL;
+	const configuredMax = normalizeTopLevelParallelValue(value);
+	return configuredMax === undefined ? MAX_PARALLEL_TASKS : Math.min(configuredMax, MAX_PARALLEL_TASKS);
 }
 
 export function resolveTopLevelParallelConcurrency(

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

@@ -160,7 +160,7 @@ async function requestSlashRun(
 			if (done || !data || typeof data !== "object") return;
 			const update = data as SlashSubagentUpdate;
 			if (update.requestId !== requestId) return;
-			applySlashUpdate(requestId, update);
+			applySlashUpdate(requestId, update, pi);
 			if (!ctx.hasUI) return;
 			const tool = update.currentTool ? ` ${update.currentTool}` : "";
 			const count = update.toolCount ?? 0;
@@ -260,7 +260,7 @@ async function runSlashSubagent(
 ): Promise<void> {
 	if (ctx.hasUI) ctx.ui.setToolsExpanded(false);
 	const requestId = randomUUID();
-	const initialDetails = buildSlashInitialResult(requestId, params);
+	const initialDetails = buildSlashInitialResult(requestId, params, pi);
 	const initialText = extractSlashMessageText(initialDetails.result.content) || "Running subagent...";
 	pi.sendMessage({
 		customType: SLASH_RESULT_TYPE,
@@ -272,7 +272,7 @@ async function runSlashSubagent(
 
 	try {
 		const response = await requestSlashRun(pi, ctx, requestId, params);
-		const finalDetails = finalizeSlashResult(response);
+		const finalDetails = finalizeSlashResult(response, pi);
 		pi.sendMessage({
 			customType: SLASH_RESULT_TYPE,
 			content: buildSlashExportText(response),
@@ -288,7 +288,7 @@ async function runSlashSubagent(
 		}
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
-		const failedDetails = failSlashResult(requestId, params, message);
+		const failedDetails = failSlashResult(requestId, params, message, pi);
 		pi.sendMessage({
 			customType: SLASH_RESULT_TYPE,
 			content: `## Subagent result\n\n${message}`,
@@ -402,11 +402,8 @@ export function registerSlashCommands(
 			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; }
-			let finalTask = task;
-			if (inline.reads && Array.isArray(inline.reads) && inline.reads.length > 0) {
-				finalTask = `[Read from: ${inline.reads.join(", ")}]\n\n${finalTask}`;
-			}
-			const params: SubagentParamsLike = { agent: agentName, task: finalTask, clarify: false, agentScope: "both" };
+			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;
@@ -433,7 +430,7 @@ export function registerSlashCommands(
 				...(config.skill !== undefined ? { skill: config.skill } : {}),
 				...(config.progress !== undefined ? { progress: config.progress } : {}),
 			}));
-			const params: SubagentParamsLike = { chain, task: parsed.task, clarify: false, agentScope: "both" };
+			const params: SubagentParamsLike = { chain, task: parsed.task, agentScope: "both" };
 			if (bg) params.async = true;
 			if (fork) params.context = "fork";
 			await runSlashSubagent(pi, ctx, params);
@@ -462,7 +459,7 @@ export function registerSlashCommands(
 				ctx.ui.notify(`Unknown chain: ${chainName}`, "error");
 				return;
 			}
-			const params: SubagentParamsLike = { chain: mapSavedChainSteps(chain), task, clarify: false, agentScope: "both" };
+			const params: SubagentParamsLike = { chain: mapSavedChainSteps(chain), task, agentScope: "both" };
 			if (bg) params.async = true;
 			if (fork) params.context = "fork";
 			await runSlashSubagent(pi, ctx, params);
@@ -485,7 +482,7 @@ export function registerSlashCommands(
 				...(config.skill !== undefined ? { skill: config.skill } : {}),
 				...(config.progress !== undefined ? { progress: config.progress } : {}),
 			}));
-			const params: SubagentParamsLike = { tasks, clarify: false, agentScope: "both" };
+			const params: SubagentParamsLike = { tasks, agentScope: "both" };
 			if (bg) params.async = true;
 			if (fork) params.context = "fork";
 			await runSlashSubagent(pi, ctx, params);