@bastani/atomic 0.9.12 → 0.9.13-alpha.2

package/dist/builtin/subagents/src/runs/shared/single-output.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { OutputMode, SavedOutputReference } from "../../shared/types.ts";
+import type { OutputMode, SavedOutputReference, SubagentAttemptStatus } from "../../shared/types.ts";
 
 export interface SingleOutputSnapshot {
 	exists: boolean;
@@ -147,13 +147,13 @@ export function finalizeSingleOutput(params: {
 	truncatedOutput?: string;
 	outputPath?: string;
 	outputMode?: OutputMode;
-	exitCode: number;
+	status: SubagentAttemptStatus;
 	savedPath?: string;
 	outputReference?: SavedOutputReference;
 	saveError?: string;
 }): { displayOutput: string; savedPath?: string; outputReference?: SavedOutputReference; saveError?: string } {
 	let displayOutput = params.truncatedOutput || params.fullOutput;
-	if (params.exitCode === 0 && params.savedPath) {
+	if (params.status === "ok" && params.savedPath) {
 		const outputReference = params.outputReference ?? formatSavedOutputReference(params.savedPath, params.fullOutput);
 		if (params.outputMode === "file-only") {
 			return { displayOutput: outputReference.message, savedPath: params.savedPath, outputReference };
@@ -161,7 +161,7 @@ export function finalizeSingleOutput(params: {
 		displayOutput += `\n\n${outputReference.message}`;
 		return { displayOutput, savedPath: params.savedPath, outputReference };
 	}
-	if (params.exitCode === 0 && params.saveError && params.outputPath) {
+	if (params.status === "ok" && params.saveError && params.outputPath) {
 		displayOutput += `\n\nOutput file error: ${params.outputPath}\n${params.saveError}`;
 		return { displayOutput, saveError: params.saveError };
 	}

package/dist/builtin/subagents/src/runs/shared/worktree.ts

@@ -2,7 +2,7 @@ import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { createGitEnvironment } from "@bastani/atomic";
+import { createChildProcessEnvironment, createGitEnvironment } from "@bastani/atomic";
 import { performPostCreationSetup } from "./worktree-post-create.js";
 import { findCanonicalGitRoot } from "./worktree-root.js";
 export interface WorktreeSetup {
@@ -70,9 +70,13 @@ interface RepoState {
 	baseCommit: string;
 	baseRef: string;
 }
+
 const DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS = 30000;
 function runGit(cwd: string, args: string[]): GitResult {
-	const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8", env: createGitEnvironment() });
+	const result = spawnSync("git", ["-C", cwd, ...args], {
+		encoding: "utf-8",
+		env: createGitEnvironment({}, createChildProcessEnvironment()),
+	});
 	return {
 		stdout: result.stdout ?? "",
 		stderr: result.stderr ?? "",
@@ -268,6 +272,7 @@ function runWorktreeSetupHook(hook: ResolvedWorktreeSetupHook, input: WorktreeSe
 		cwd: input.worktreePath,
 		encoding: "utf-8",
 		input: JSON.stringify(input),
+		env: createChildProcessEnvironment(),
 		timeout: hook.timeoutMs,
 		shell: false,
 	});

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

@@ -2,12 +2,8 @@
  * Formatting utilities for display output
  */
 
-import * as fs from "node:fs";
-import * as path from "node:path";
 import { splitKnownThinkingSuffix, THINKING_LEVELS } from "./model-info.ts";
-import type { ChainStep } from "./settings.ts";
-import { isDynamicParallelStep, isParallelStep } from "./settings.ts";
-import type { SingleResult, Usage } from "./types.ts";
+import type { Usage } from "./types.ts";
 
 /**
  * Format token count with k suffix for large numbers
@@ -33,7 +29,7 @@ export function formatModelThinking(model?: string, thinking?: string, fastMode?
 /**
  * Format usage statistics into a compact string
  */
-export function formatUsage(u: Usage, model?: string): string {
+export function formatUsage(u: Usage): string {
 	const parts: string[] = [];
 	if (u.turns) parts.push(`${u.turns} turn${u.turns > 1 ? "s" : ""}`);
 	if (u.input) parts.push(`in:${formatTokens(u.input)}`);
@@ -41,7 +37,6 @@ export function formatUsage(u: Usage, model?: string): string {
 	if (u.cacheRead) parts.push(`R${formatTokens(u.cacheRead)}`);
 	if (u.cacheWrite) parts.push(`W${formatTokens(u.cacheWrite)}`);
 	if (u.cost) parts.push(`$${u.cost.toFixed(4)}`);
-	if (model) parts.push(model);
 	return parts.join(" ");
 }
 
@@ -59,55 +54,6 @@ export function formatDuration(ms: number): string {
 	return `${seconds}s`;
 }
 
-/**
- * Build a summary string for a completed/failed chain
- */
-export function buildChainSummary(
-	steps: ChainStep[],
-	results: SingleResult[],
-	chainDir: string,
-	status: "completed" | "failed",
-	failedStep?: { index: number; error: string },
-): string {
-	const stepNames = steps
-		.map((step) =>
-			isParallelStep(step)
-				? `parallel[${step.parallel.length}]`
-				: isDynamicParallelStep(step)
-					? `expand:${step.parallel.agent}`
-					: step.agent,
-		)
-		.join(" → ");
-
-	const totalDuration = results.reduce((sum, r) => sum + (r.progress?.durationMs || 0), 0);
-	const durationStr = formatDuration(totalDuration);
-
-	const progressPath = path.join(chainDir, "progress.md");
-	const hasProgress = fs.existsSync(progressPath);
-	const allSkills = new Set<string>();
-	for (const r of results) {
-		if (r.skills) {
-			for (const skill of r.skills) allSkills.add(skill);
-		}
-	}
-	const skillsLine = allSkills.size > 0 ? `🔧 Skills: ${[...allSkills].join(", ")}` : "";
-
-	if (status === "completed") {
-		const stepWord = results.length === 1 ? "step" : "steps";
-		return `✅ Chain completed: ${stepNames} (${results.length} ${stepWord}, ${durationStr})${skillsLine ? `\n${skillsLine}` : ""}
-
-📋 Progress: ${hasProgress ? progressPath : "(none)"}
-📁 Artifacts: ${chainDir}`;
-	} else {
-		const stepInfo = failedStep ? ` at step ${failedStep.index + 1}` : "";
-		const errorInfo = failedStep?.error ? `: ${failedStep.error}` : "";
-		return `❌ Chain failed${stepInfo}${errorInfo}${skillsLine ? `\n${skillsLine}` : ""}
-
-📋 Progress: ${hasProgress ? progressPath : "(none)"}
-📁 Artifacts: ${chainDir}`;
-	}
-}
-
 /**
  * Format a tool call for display
  */

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

@@ -1,20 +1,12 @@
-/**
- * Chain behavior, template resolution, and directory management
- */
+/** Shared behavior, progress, and task instruction helpers. */
 
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentConfig } from "../agents/agents.ts";
-import { normalizeSkillInput } from "../agents/skills.ts";
-import { CHAIN_RUNS_DIR, type JsonSchemaObject, type OutputMode } from "./types.ts";
+import type { OutputMode } from "./types.ts";
 
-const CHAIN_DIR_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24 hours
 const INITIAL_PROGRESS_CONTENT = "# Progress\n\n## Status\nIn Progress\n\n## Tasks\n\n## Files Changed\n\n## Notes\n";
 
-// =============================================================================
-// Behavior Resolution Types
-// =============================================================================
-
 export interface ResolvedStepBehavior {
 	output: string | false;
 	outputMode: OutputMode;
@@ -37,244 +29,23 @@ function normalizeOutputOverride(output: string | false | undefined): string | f
 	return output === "false" ? false : output;
 }
 
-// =============================================================================
-// Chain Step Types
-// =============================================================================
-
-/** Sequential step: single agent execution */
-export interface SequentialStep {
-	agent: string;
-	task?: string;
-	phase?: string;
-	label?: string;
-	as?: string;
-	outputSchema?: JsonSchemaObject;
-	cwd?: string;
-	output?: string | false;
-	outputMode?: OutputMode;
-	reads?: string[] | false;
-	progress?: boolean;
-	skill?: string | string[] | false;
-	model?: string;
-	group?: string | true;
-}
-
-/** Parallel task item within a parallel step */
-export interface ParallelTaskItem {
-	agent: string;
-	task?: string;
-	phase?: string;
-	label?: string;
-	as?: string;
-	outputSchema?: JsonSchemaObject;
-	cwd?: string;
-	count?: number;
-	output?: string | false;
-	outputMode?: OutputMode;
-	reads?: string[] | false;
-	progress?: boolean;
-	skill?: string | string[] | false;
-	model?: string;
-	group?: string | true;
-}
-
-export interface DynamicExpandSpec {
-	from: {
-		output: string;
-		path: string;
-	};
-	item?: string;
-	key?: string;
-	maxItems?: number;
-	onEmpty?: "skip" | "fail";
-}
-
-export type DynamicParallelTemplate = Omit<ParallelTaskItem, "as" | "count">;
-
-export interface DynamicCollectSpec {
-	as: string;
-	outputSchema?: JsonSchemaObject;
-}
-
-export interface DynamicParallelStep {
-	expand: DynamicExpandSpec;
-	parallel: DynamicParallelTemplate;
-	collect: DynamicCollectSpec;
-	concurrency?: number;
-	failFast?: boolean;
-	phase?: string;
-	label?: string;
-	group?: string | true;
-}
-
-/** Parallel step: multiple agents running concurrently */
-export interface ParallelStep {
-	parallel: ParallelTaskItem[];
-	cwd?: string;
-	concurrency?: number;
-	failFast?: boolean;
-	worktree?: boolean;
-	group?: string | true;
-}
-
-/** Union type for chain steps */
-export type ChainStep = SequentialStep | ParallelStep | DynamicParallelStep;
-
-// =============================================================================
-// Type Guards
-// =============================================================================
-
-export function isParallelStep(step: ChainStep): step is ParallelStep {
-	return "parallel" in step && Array.isArray((step as ParallelStep).parallel);
-}
-
-export function isDynamicParallelStep(step: ChainStep): step is DynamicParallelStep {
-	return (
-		"expand" in step &&
-		"collect" in step &&
-		"parallel" in step &&
-		!Array.isArray((step as { parallel?: unknown }).parallel)
-	);
-}
-
-/** Get all agent names in a step (single for sequential, multiple for parallel) */
-export function getStepAgents(step: ChainStep): string[] {
-	if (isParallelStep(step)) {
-		return step.parallel.map((t) => t.agent);
-	}
-	if (isDynamicParallelStep(step)) {
-		return [step.parallel.agent];
-	}
-	return [step.agent];
-}
-
-// =============================================================================
-// Chain Directory Management
-// =============================================================================
-
-export function createChainDir(runId: string, baseDir?: string): string {
-	const chainDir = path.join(baseDir ? path.resolve(baseDir) : CHAIN_RUNS_DIR, runId);
-	fs.mkdirSync(chainDir, { recursive: true });
-	return chainDir;
-}
-
-export function removeChainDir(chainDir: string): void {
-	try {
-		fs.rmSync(chainDir, { recursive: true });
-	} catch {
-		// Chain cleanup is best-effort. Runs can already have cleaned their temp dir.
-	}
-}
-
-export function cleanupOldChainDirs(): void {
-	if (!fs.existsSync(CHAIN_RUNS_DIR)) return;
-	const now = Date.now();
-	let dirs: string[];
-	try {
-		dirs = fs.readdirSync(CHAIN_RUNS_DIR);
-	} catch {
-		// Startup cleanup is best-effort. If the scoped temp root is unreadable,
-		// skip cleanup instead of failing extension startup.
-		return;
-	}
-
-	for (const dir of dirs) {
-		try {
-			const dirPath = path.join(CHAIN_RUNS_DIR, dir);
-			const stat = fs.statSync(dirPath);
-			if (stat.isDirectory() && now - stat.mtimeMs > CHAIN_DIR_MAX_AGE_MS) {
-				fs.rmSync(dirPath, { recursive: true });
-			}
-		} catch {
-			// Skip directories that can't be processed; continue with others
-		}
-	}
-}
-
-// =============================================================================
-// Template Resolution
-// =============================================================================
-
-/** Resolved templates for a chain - string for sequential, string[] for parallel */
-export type ResolvedTemplates = (string | string[])[];
-
-/**
- * Resolve templates for a chain with parallel step support.
- * Returns string for sequential steps, string[] for parallel steps.
- */
-export function resolveChainTemplates(steps: ChainStep[]): ResolvedTemplates {
-	return steps.map((step, i) => {
-		if (isParallelStep(step)) {
-			// Parallel step: resolve each task's template
-			return step.parallel.map((task) => {
-				if (task.task) return task.task;
-				// Default for parallel tasks is {previous}
-				return "{previous}";
-			});
-		}
-		if (isDynamicParallelStep(step)) {
-			return step.parallel.task ?? "{previous}";
-		}
-		// Sequential step: existing logic
-		const seq = step as SequentialStep;
-		if (seq.task) return seq.task;
-		// Default: first step uses {task}, others use {previous}
-		return i === 0 ? "{task}" : "{previous}";
-	});
-}
-
-// =============================================================================
-// Behavior Resolution
-// =============================================================================
-
-/**
- * Resolve effective chain behavior per step.
- * Priority: step override > agent frontmatter > false (disabled)
- */
-export function resolveStepBehavior(
-	agentConfig: AgentConfig,
-	stepOverrides: StepOverrides,
-	chainSkills?: string[],
-): ResolvedStepBehavior {
-	// Output: step override > frontmatter > false (no output)
+export function resolveStepBehavior(agentConfig: AgentConfig, stepOverrides: StepOverrides): ResolvedStepBehavior {
 	const stepOutput = normalizeOutputOverride(stepOverrides.output);
 	const output = stepOutput !== undefined ? stepOutput : (normalizeOutputOverride(agentConfig.output) ?? false);
-
-	// Reads: step override > frontmatter defaultReads > false (no reads)
 	const reads = stepOverrides.reads !== undefined ? stepOverrides.reads : (agentConfig.defaultReads ?? false);
-
-	// Progress: step override > frontmatter defaultProgress > false
 	const progress =
 		stepOverrides.progress !== undefined ? stepOverrides.progress : (agentConfig.defaultProgress ?? false);
 
 	let skills: string[] | false;
-	if (stepOverrides.skills === false) {
-		skills = false;
-	} else if (stepOverrides.skills !== undefined) {
-		skills = [...stepOverrides.skills];
-		if (chainSkills && chainSkills.length > 0) {
-			skills = [...new Set([...skills, ...chainSkills])];
-		}
-	} else {
-		skills = agentConfig.skills ? [...agentConfig.skills] : [];
-		if (chainSkills && chainSkills.length > 0) {
-			skills = [...new Set([...skills, ...chainSkills])];
-		}
-	}
+	if (stepOverrides.skills === false) skills = false;
+	else if (stepOverrides.skills !== undefined) skills = [...stepOverrides.skills];
+	else skills = agentConfig.skills ? [...agentConfig.skills] : [];
 
 	const outputMode = stepOverrides.outputMode ?? "inline";
 	const model = stepOverrides.model ?? agentConfig.model;
 	return { output, outputMode, reads, progress, skills, model };
 }
 
-export function resolveTaskTextForFileUpdatePolicy(
-	task: string | undefined,
-	originalTask?: string,
-): string | undefined {
-	if (!task) return originalTask;
-	return originalTask ? task.replaceAll("{task}", originalTask) : task;
-}
-
 export function taskDisallowsFileUpdates(task: string | undefined): boolean {
 	if (!task) return false;
 	return (
@@ -289,13 +60,10 @@ export function taskDisallowsFileUpdates(task: string | undefined): boolean {
 export function suppressProgressForReadOnlyTask(
 	behavior: ResolvedStepBehavior,
 	task: string | undefined,
-	originalTask?: string,
 ): ResolvedStepBehavior {
-	const policyTask = resolveTaskTextForFileUpdatePolicy(task, originalTask);
-	return behavior.progress && taskDisallowsFileUpdates(policyTask) ? { ...behavior, progress: false } : behavior;
+	return behavior.progress && taskDisallowsFileUpdates(task) ? { ...behavior, progress: false } : behavior;
 }
 
-/** Resolve single-agent progress, preserving read-only suppression only for inherited defaults. */
 export function resolveSingleProgress(
 	agentConfig: AgentConfig,
 	override: boolean | undefined,
@@ -305,150 +73,46 @@ export function resolveSingleProgress(
 	return override !== undefined ? behavior.progress : suppressProgressForReadOnlyTask(behavior, task).progress;
 }
 
-// =============================================================================
-// Chain Instruction Injection
-// =============================================================================
-
-/** 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(", ")}]`;
 }
 
-/**
- * Build chain instructions from resolved behavior.
- * 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(
+export function buildTaskInstructions(
 	behavior: ResolvedStepBehavior,
-	chainDir: string,
+	cwd: string,
 	isFirstProgressAgent: boolean,
-	previousSummary?: string,
 ): { prefix: string; suffix: string } {
 	const prefixParts: string[] = [];
 	const suffixParts: string[] = [];
-
-	// READS - prepend to override any hardcoded filenames in task text
-	const readInstruction = buildReadInstruction(behavior.reads, chainDir);
+	const readInstruction = buildReadInstruction(behavior.reads, cwd);
 	if (readInstruction) prefixParts.push(readInstruction);
 
-	// OUTPUT - prepend so agent knows where to write
 	if (behavior.output) {
-		const outputPath = path.isAbsolute(behavior.output) ? behavior.output : path.join(chainDir, behavior.output);
+		const outputPath = path.isAbsolute(behavior.output) ? behavior.output : path.join(cwd, behavior.output);
 		prefixParts.push(`[Write to: ${outputPath}]`);
 	}
 
-	// Progress instructions in suffix (less critical)
 	if (behavior.progress) {
-		const progressPath = path.join(chainDir, "progress.md");
-		if (isFirstProgressAgent) {
-			suffixParts.push(`Create and maintain progress at: ${progressPath}`);
-		} else {
-			suffixParts.push(`Update progress at: ${progressPath}`);
-		}
-	}
-
-	// Include previous step's summary in suffix if available
-	if (previousSummary?.trim()) {
-		suffixParts.push(`Previous step output:\n${previousSummary.trim()}`);
+		const progressPath = path.join(cwd, "progress.md");
+		if (isFirstProgressAgent) suffixParts.push(`Create and maintain progress at: ${progressPath}`);
+		else suffixParts.push(`Update progress at: ${progressPath}`);
 	}
 
 	const prefix = prefixParts.length > 0 ? `${prefixParts.join("\n")}\n\n` : "";
-
 	const suffix = suffixParts.length > 0 ? `\n\n---\n${suffixParts.join("\n")}` : "";
-
 	return { prefix, suffix };
 }
 
-// =============================================================================
-// Parallel Step Support
-// =============================================================================
-
-/**
- * Resolve behaviors for all tasks in a parallel step.
- * Creates namespaced output paths to avoid collisions.
- */
-export function resolveParallelBehaviors(
-	tasks: ParallelTaskItem[],
-	agentConfigs: AgentConfig[],
-	stepIndex: number,
-	chainSkills?: string[],
-): ResolvedStepBehavior[] {
-	return tasks.map((task, taskIndex) => {
-		const config = agentConfigs.find((a) => a.name === task.agent);
-		if (!config) {
-			throw new Error(`Unknown agent: ${task.agent}`);
-		}
-
-		// Build subdirectory path for this parallel task
-		const subdir = path.join(`parallel-${stepIndex}`, `${taskIndex}-${task.agent}`);
-
-		// Output: task override > agent default (namespaced) > false
-		// Absolute paths pass through unchanged; relative paths get namespaced under subdir
-		let output: string | false = false;
-		const taskOutput = normalizeOutputOverride(task.output);
-		const configOutput = normalizeOutputOverride(config.output);
-		if (taskOutput !== undefined) {
-			if (taskOutput === false) {
-				output = false;
-			} else if (path.isAbsolute(taskOutput)) {
-				output = taskOutput; // Absolute path: use as-is
-			} else {
-				output = path.join(subdir, taskOutput); // Relative: namespace under subdir
-			}
-		} else if (configOutput) {
-			// Agent defaults are always relative, so namespace them
-			output = path.join(subdir, configOutput);
-		}
-
-		// Reads: task override > agent default > false
-		const reads = task.reads !== undefined ? task.reads : (config.defaultReads ?? false);
-
-		// Progress: task override > agent default > false
-		const progress = task.progress !== undefined ? task.progress : (config.defaultProgress ?? false);
-
-		const taskSkillInput = normalizeSkillInput(task.skill);
-		let skills: string[] | false;
-		if (taskSkillInput === false) {
-			skills = false;
-		} else if (taskSkillInput !== undefined) {
-			skills = [...taskSkillInput];
-			if (chainSkills && chainSkills.length > 0) {
-				skills = [...new Set([...skills, ...chainSkills])];
-			}
-		} else {
-			skills = config.skills ? [...config.skills] : [];
-			if (chainSkills && chainSkills.length > 0) {
-				skills = [...new Set([...skills, ...chainSkills])];
-			}
-		}
-
-		const outputMode = task.outputMode ?? "inline";
-		const model = task.model ?? config.model;
-		return { output, outputMode, reads, progress, skills, model };
-	});
-}
-
-/**
- * Create subdirectories for parallel step outputs
- */
-export function createParallelDirs(chainDir: string, stepIndex: number, taskCount: number, agentNames: string[]): void {
-	for (let i = 0; i < taskCount; i++) {
-		const subdir = path.join(chainDir, `parallel-${stepIndex}`, `${i}-${agentNames[i]}`);
-		fs.mkdirSync(subdir, { recursive: true });
-	}
-}
-
 export type { ParallelTaskResult } from "../runs/shared/parallel-utils.ts";
 export { aggregateParallelOutputs } from "../runs/shared/parallel-utils.ts";