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

package/dist/builtin/subagents/src/runs/shared/run-history.ts

@@ -1,64 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { getAgentConfigPaths } from "@bastani/atomic";
-
-export interface RunEntry {
-	agent: string;
-	task: string;
-	ts: number;
-	status: "ok" | "error" | "skipped" | "interrupted" | "continued";
-	duration: number;
-}
-
-const HISTORY_PATH =
-	getAgentConfigPaths("run-history.jsonl")[0] ?? path.join(os.homedir(), ".atomic", "agent", "run-history.jsonl");
-const HISTORY_READ_PATHS = getAgentConfigPaths("run-history.jsonl");
-const ROTATE_READ_THRESHOLD = 1200;
-const ROTATE_KEEP = 1000;
-
-export function recordRun(agent: string, task: string, status: RunEntry["status"], durationMs: number): void {
-	try {
-		const entry: RunEntry = {
-			agent,
-			task: task.slice(0, 200),
-			ts: Math.floor(Date.now() / 1000),
-			status,
-			duration: durationMs,
-		};
-		fs.mkdirSync(path.dirname(HISTORY_PATH), { recursive: true });
-		fs.appendFileSync(HISTORY_PATH, `${JSON.stringify(entry)}\n`);
-	} catch {
-		// Best-effort — never crash the execution flow for history recording
-	}
-}
-
-export function loadRunsForAgent(agent: string): RunEntry[] {
-	let lines: string[] = [];
-	for (const historyPath of HISTORY_READ_PATHS) {
-		if (!fs.existsSync(historyPath)) continue;
-		try {
-			lines.push(...fs.readFileSync(historyPath, "utf-8").split("\n"));
-		} catch {}
-	}
-	lines = lines.map((line) => line.trim()).filter((line) => line.length > 0);
-	if (lines.length === 0) return [];
-
-	if (lines.length > ROTATE_READ_THRESHOLD) {
-		lines = lines.slice(-ROTATE_KEEP);
-		try {
-			fs.writeFileSync(HISTORY_PATH, `${lines.join("\n")}\n`, "utf-8");
-		} catch {}
-	}
-
-	return lines
-		.map((line) => {
-			try {
-				return JSON.parse(line) as RunEntry;
-			} catch {
-				return undefined;
-			}
-		})
-		.filter((entry): entry is RunEntry => entry !== undefined && entry.agent === agent)
-		.reverse();
-}

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

@@ -1,169 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { OutputMode, SavedOutputReference, SubagentAttemptStatus } from "../../shared/types.js";
-
-export interface SingleOutputSnapshot {
-	exists: boolean;
-	mtimeMs?: number;
-	size?: number;
-}
-
-export function normalizeSingleOutputOverride(
-	output: string | boolean | undefined,
-	defaultOutput: string | undefined,
-): string | false | undefined {
-	if (output === false || output === "false") return false;
-	if (output === true || output === "true") return defaultOutput;
-	if (typeof output === "string" && output.length > 0) return output;
-	return undefined;
-}
-
-export function resolveSingleOutputPath(
-	output: string | boolean | undefined,
-	runtimeCwd: string,
-	requestedCwd?: string,
-): string | undefined {
-	if (typeof output !== "string" || !output || output === "false" || output === "true") return undefined;
-	if (path.isAbsolute(output)) return output;
-	const baseCwd = requestedCwd
-		? path.isAbsolute(requestedCwd)
-			? requestedCwd
-			: path.resolve(runtimeCwd, requestedCwd)
-		: runtimeCwd;
-	return path.resolve(baseCwd, output);
-}
-
-export function injectSingleOutputInstruction(task: string, outputPath: string | undefined): string {
-	if (!outputPath) return task;
-	return `${task}\n\n---\n**Output:** Write your findings to: ${outputPath}`;
-}
-
-function countLines(text: string): number {
-	if (!text) return 0;
-	const newlineMatches = text.match(/\r\n|\r|\n/g);
-	return (newlineMatches?.length ?? 0) + (/[\r\n]$/.test(text) ? 0 : 1);
-}
-
-function formatByteSize(bytes: number): string {
-	if (bytes < 1024) return `${bytes} B`;
-	const units = ["KB", "MB", "GB", "TB"];
-	let value = bytes / 1024;
-	let unitIndex = 0;
-	while (value >= 1024 && unitIndex < units.length - 1) {
-		value /= 1024;
-		unitIndex++;
-	}
-	return `${value.toFixed(1)} ${units[unitIndex]}`;
-}
-
-export function formatSavedOutputReference(savedPath: string, fullOutput: string): SavedOutputReference {
-	const absolutePath = path.resolve(savedPath);
-	const bytes = Buffer.byteLength(fullOutput, "utf-8");
-	const lines = countLines(fullOutput);
-	return {
-		path: absolutePath,
-		bytes,
-		lines,
-		message: `Output saved to: ${absolutePath} (${formatByteSize(bytes)}, ${lines} ${lines === 1 ? "line" : "lines"}). Read this file if needed.`,
-	};
-}
-
-export function validateFileOnlyOutputMode(
-	outputMode: OutputMode | undefined,
-	outputPath: string | undefined,
-	context: string,
-): string | undefined {
-	if (outputMode === "file-only" && !outputPath) {
-		return `${context} sets outputMode: "file-only" but does not configure an output file. Set output to a path or use outputMode: "inline".`;
-	}
-	return undefined;
-}
-
-export function captureSingleOutputSnapshot(outputPath: string | undefined): SingleOutputSnapshot | undefined {
-	if (!outputPath) return undefined;
-	try {
-		const stat = fs.statSync(outputPath);
-		return { exists: true, mtimeMs: stat.mtimeMs, size: stat.size };
-	} catch {
-		// The snapshot is advisory; resolveSingleOutput reports concrete read/write failures.
-		return { exists: false };
-	}
-}
-
-function persistSingleOutput(
-	outputPath: string | undefined,
-	fullOutput: string,
-): { savedPath?: string; error?: string } {
-	if (!outputPath) return {};
-	try {
-		fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-		fs.writeFileSync(outputPath, fullOutput, "utf-8");
-		return { savedPath: outputPath };
-	} catch (err) {
-		return { error: err instanceof Error ? err.message : String(err) };
-	}
-}
-
-export function resolveSingleOutput(
-	outputPath: string | undefined,
-	fallbackOutput: string,
-	beforeRun: SingleOutputSnapshot | undefined,
-): { fullOutput: string; savedPath?: string; saveError?: string } {
-	if (!outputPath) return { fullOutput: fallbackOutput };
-
-	let changedSinceStart = false;
-	try {
-		const stat = fs.statSync(outputPath);
-		changedSinceStart = !beforeRun?.exists || stat.mtimeMs !== beforeRun.mtimeMs || stat.size !== beforeRun.size;
-	} catch (error) {
-		const code =
-			error && typeof error === "object" && "code" in error ? (error as { code?: unknown }).code : undefined;
-		if (code !== "ENOENT" && code !== "ENOTDIR") {
-			return {
-				fullOutput: fallbackOutput,
-				saveError: `Failed to inspect output file: ${error instanceof Error ? error.message : String(error)}`,
-			};
-		}
-	}
-
-	if (changedSinceStart) {
-		try {
-			return { fullOutput: fs.readFileSync(outputPath, "utf-8"), savedPath: outputPath };
-		} catch (error) {
-			return {
-				fullOutput: fallbackOutput,
-				saveError: `Failed to read changed output file: ${error instanceof Error ? error.message : String(error)}`,
-			};
-		}
-	}
-
-	const save = persistSingleOutput(outputPath, fallbackOutput);
-	if (save.savedPath) return { fullOutput: fallbackOutput, savedPath: save.savedPath };
-	return { fullOutput: fallbackOutput, saveError: save.error };
-}
-
-export function finalizeSingleOutput(params: {
-	fullOutput: string;
-	truncatedOutput?: string;
-	outputPath?: string;
-	outputMode?: OutputMode;
-	status: SubagentAttemptStatus;
-	savedPath?: string;
-	outputReference?: SavedOutputReference;
-	saveError?: string;
-}): { displayOutput: string; savedPath?: string; outputReference?: SavedOutputReference; saveError?: string } {
-	let displayOutput = params.truncatedOutput || params.fullOutput;
-	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 };
-		}
-		displayOutput += `\n\n${outputReference.message}`;
-		return { displayOutput, savedPath: params.savedPath, outputReference };
-	}
-	if (params.status === "ok" && params.saveError && params.outputPath) {
-		displayOutput += `\n\nOutput file error: ${params.outputPath}\n${params.saveError}`;
-		return { displayOutput, saveError: params.saveError };
-	}
-	return { displayOutput };
-}

package/dist/builtin/subagents/src/runs/shared/subagent-control.ts

@@ -1,234 +0,0 @@
-import type {
-	ActivityState,
-	ControlConfig,
-	ControlEvent,
-	ControlEventType,
-	ControlNotificationChannel,
-	ResolvedControlConfig,
-} from "../../shared/types.js";
-import { progressAwareThreshold } from "./progress-trend.js";
-
-const CONTROL_EVENT_TYPES: ControlEventType[] = ["active_long_running", "needs_attention"];
-const CONTROL_NOTIFICATION_CHANNELS: ControlNotificationChannel[] = ["event", "intercom"];
-const DEFAULT_NOTIFY_ON: ControlEventType[] = ["active_long_running", "needs_attention"];
-
-export const DEFAULT_CONTROL_CONFIG: ResolvedControlConfig = {
-	enabled: true,
-	needsAttentionAfterMs: 60_000,
-	activeNoticeAfterMs: 240_000,
-	failedToolAttemptsBeforeAttention: 3,
-	notifyOn: DEFAULT_NOTIFY_ON,
-	notifyChannels: CONTROL_NOTIFICATION_CHANNELS,
-};
-
-function parsePositiveInt(value: unknown): number | undefined {
-	if (typeof value !== "number") return undefined;
-	if (!Number.isFinite(value) || !Number.isInteger(value) || value < 1) return undefined;
-	return value;
-}
-
-function parseControlList<T extends string>(value: unknown, allowed: readonly T[]): T[] | undefined {
-	if (!Array.isArray(value)) return undefined;
-	if (value.length === 0) return [];
-	const allowedSet = new Set(allowed);
-	const parsed = value.filter((entry): entry is T => typeof entry === "string" && allowedSet.has(entry as T));
-	return parsed.length > 0 ? Array.from(new Set(parsed)) : undefined;
-}
-
-function parseProgressScores(value: unknown): number[] | undefined {
-	if (!Array.isArray(value)) return undefined;
-	const parsed = value.filter((entry): entry is number => typeof entry === "number" && Number.isFinite(entry));
-	return parsed.length > 0 || value.length === 0 ? parsed : undefined;
-}
-
-export function resolveControlConfig(globalConfig?: ControlConfig, override?: ControlConfig): ResolvedControlConfig {
-	const enabled = override?.enabled ?? globalConfig?.enabled ?? DEFAULT_CONTROL_CONFIG.enabled;
-	const needsAttentionAfterMs =
-		parsePositiveInt(override?.needsAttentionAfterMs) ??
-		parsePositiveInt(globalConfig?.needsAttentionAfterMs) ??
-		DEFAULT_CONTROL_CONFIG.needsAttentionAfterMs;
-	const activeNoticeAfterMs =
-		parsePositiveInt(override?.activeNoticeAfterMs) ??
-		parsePositiveInt(globalConfig?.activeNoticeAfterMs) ??
-		DEFAULT_CONTROL_CONFIG.activeNoticeAfterMs;
-	const activeNoticeAfterTurns =
-		parsePositiveInt(override?.activeNoticeAfterTurns) ?? parsePositiveInt(globalConfig?.activeNoticeAfterTurns);
-	const activeNoticeAfterTokens =
-		parsePositiveInt(override?.activeNoticeAfterTokens) ?? parsePositiveInt(globalConfig?.activeNoticeAfterTokens);
-	const failedToolAttemptsBeforeAttention =
-		parsePositiveInt(override?.failedToolAttemptsBeforeAttention) ??
-		parsePositiveInt(globalConfig?.failedToolAttemptsBeforeAttention) ??
-		DEFAULT_CONTROL_CONFIG.failedToolAttemptsBeforeAttention;
-	const progressScores =
-		parseProgressScores(override?.progressScores) ?? parseProgressScores(globalConfig?.progressScores);
-	const notifyOn =
-		parseControlList(override?.notifyOn, CONTROL_EVENT_TYPES) ??
-		parseControlList(globalConfig?.notifyOn, CONTROL_EVENT_TYPES) ??
-		DEFAULT_CONTROL_CONFIG.notifyOn;
-	const notifyChannels =
-		parseControlList(override?.notifyChannels, CONTROL_NOTIFICATION_CHANNELS) ??
-		parseControlList(globalConfig?.notifyChannels, CONTROL_NOTIFICATION_CHANNELS) ??
-		DEFAULT_CONTROL_CONFIG.notifyChannels;
-	return {
-		enabled,
-		needsAttentionAfterMs,
-		activeNoticeAfterMs,
-		activeNoticeAfterTurns,
-		activeNoticeAfterTokens,
-		failedToolAttemptsBeforeAttention,
-		...(progressScores === undefined ? {} : { progressScores: [...progressScores] }),
-		notifyOn: [...notifyOn],
-		notifyChannels: [...notifyChannels],
-	};
-}
-
-export function deriveActivityState(input: {
-	config: ResolvedControlConfig;
-	startedAt: number;
-	lastActivityAt?: number;
-	now?: number;
-}): ActivityState | undefined {
-	if (!input.config.enabled) return undefined;
-	const now = input.now ?? Date.now();
-	const lastActivity = input.lastActivityAt ?? input.startedAt;
-	const ageMs = Math.max(0, now - lastActivity);
-	const attentionThreshold = progressAwareThreshold(input.config.needsAttentionAfterMs, input.config.progressScores);
-	return ageMs > attentionThreshold ? "needs_attention" : undefined;
-}
-
-export function buildControlEvent(input: {
-	type?: ControlEventType;
-	from?: ActivityState;
-	to: ActivityState;
-	runId: string;
-	agent: string;
-	index?: number;
-	ts?: number;
-	lastActivityAt?: number;
-	message?: string;
-	reason?: ControlEvent["reason"];
-	turns?: number;
-	tokens?: number;
-	toolCount?: number;
-	currentTool?: string;
-	currentToolDurationMs?: number;
-	currentPath?: string;
-	elapsedMs?: number;
-	recentFailureSummary?: string;
-}): ControlEvent {
-	const ts = input.ts ?? Date.now();
-	const type = input.type ?? (input.to === "active_long_running" ? "active_long_running" : "needs_attention");
-	const elapsedMs = input.elapsedMs ?? (input.lastActivityAt ? Math.max(0, ts - input.lastActivityAt) : undefined);
-	const elapsedSeconds = elapsedMs !== undefined ? Math.floor(elapsedMs / 1000) : undefined;
-	const message =
-		input.message ??
-		(type === "active_long_running"
-			? `${input.agent} is still active but long-running`
-			: elapsedSeconds !== undefined
-				? `${input.agent} needs attention (no observed activity for ${elapsedSeconds}s)`
-				: `${input.agent} needs attention`);
-	return {
-		type,
-		...(input.from ? { from: input.from } : {}),
-		to: input.to,
-		ts,
-		runId: input.runId,
-		agent: input.agent,
-		...(input.index !== undefined ? { index: input.index } : {}),
-		message,
-		reason: input.reason ?? (type === "active_long_running" ? "active_long_running" : "idle"),
-		...(input.turns !== undefined ? { turns: input.turns } : {}),
-		...(input.tokens !== undefined ? { tokens: input.tokens } : {}),
-		...(input.toolCount !== undefined ? { toolCount: input.toolCount } : {}),
-		...(input.currentTool ? { currentTool: input.currentTool } : {}),
-		...(input.currentToolDurationMs !== undefined ? { currentToolDurationMs: input.currentToolDurationMs } : {}),
-		...(input.currentPath ? { currentPath: input.currentPath } : {}),
-		...(elapsedMs !== undefined ? { elapsedMs } : {}),
-		...(input.recentFailureSummary ? { recentFailureSummary: input.recentFailureSummary } : {}),
-	};
-}
-
-export function shouldNotifyControlEvent(config: ResolvedControlConfig, event: ControlEvent): boolean {
-	return config.enabled && config.notifyOn.includes(event.type);
-}
-
-export function controlNotificationKey(event: ControlEvent, childIntercomTarget?: string): string {
-	const childKey = childIntercomTarget ?? (event.index !== undefined ? `${event.runId}:${event.index}` : event.runId);
-	return `${childKey}:${event.type}:${event.reason ?? "idle"}`;
-}
-
-export function claimControlNotification(
-	config: ResolvedControlConfig,
-	event: ControlEvent,
-	seenKeys: Set<string>,
-	childIntercomTarget?: string,
-): boolean {
-	if (!shouldNotifyControlEvent(config, event)) return false;
-	const key = controlNotificationKey(event, childIntercomTarget);
-	if (seenKeys.has(key)) return false;
-	seenKeys.add(key);
-	return true;
-}
-
-function formatLongRunningFacts(event: ControlEvent): string | undefined {
-	const facts: string[] = [];
-	if (event.elapsedMs !== undefined) facts.push(`elapsed ${Math.floor(Math.max(0, event.elapsedMs) / 1000)}s`);
-	if (event.turns !== undefined) facts.push(`${event.turns} turns`);
-	if (event.tokens !== undefined) facts.push(`${event.tokens} tokens`);
-	if (event.toolCount !== undefined) facts.push(`${event.toolCount} tools`);
-	if (event.currentTool)
-		facts.push(
-			`tool ${event.currentTool}${event.currentToolDurationMs !== undefined ? ` ${Math.floor(Math.max(0, event.currentToolDurationMs) / 1000)}s` : ""}`,
-		);
-	if (event.currentPath) facts.push(`path ${event.currentPath}`);
-	return facts.length > 0 ? facts.join(" | ") : undefined;
-}
-
-export function formatControlNoticeMessage(event: ControlEvent, childIntercomTarget?: string): string {
-	const runTarget = event.runId;
-	const nudgeCommand = childIntercomTarget
-		? `intercom({ action: "send", to: "${childIntercomTarget}", message: "What are you blocked on? Reply with the smallest next step or ask for a decision." })`
-		: undefined;
-	if (event.type === "active_long_running") {
-		const facts = formatLongRunningFacts(event);
-		return [
-			`Subagent active but long-running: ${event.agent}`,
-			`Run: ${runTarget}${event.index !== undefined ? ` step ${event.index + 1}` : ""}`,
-			`Signal: ${event.message}`,
-			facts ? `Facts: ${facts}` : undefined,
-			"Hint: Inspect status, then nudge if the work seems stuck.",
-			childIntercomTarget ? `Nudge: ${nudgeCommand}` : "Nudge: no child message route registered",
-			`Status: subagent({ action: "status", id: "${runTarget}" })`,
-			`Interrupt: subagent({ action: "interrupt", id: "${runTarget}" })`,
-		]
-			.filter((line): line is string => Boolean(line))
-			.join("\n");
-	}
-
-	return [
-		`Subagent needs attention: ${event.agent}`,
-		`Run: ${runTarget}${event.index !== undefined ? ` step ${event.index + 1}` : ""}`,
-		`Signal: ${event.message}`,
-		event.recentFailureSummary ? `Recent failures: ${event.recentFailureSummary}` : undefined,
-		"Hint: Inspect status first unless the run is clearly blocked.",
-		childIntercomTarget ? `Nudge: ${nudgeCommand}` : "Nudge: no child message route registered",
-		`Status: subagent({ action: "status", id: "${runTarget}" })`,
-		`Interrupt: subagent({ action: "interrupt", id: "${runTarget}" })`,
-	]
-		.filter((line): line is string => Boolean(line))
-		.join("\n");
-}
-
-export function formatControlIntercomMessage(event: ControlEvent, childIntercomTarget?: string): string {
-	const statusLabel =
-		event.type === "active_long_running" ? "subagent active but long-running" : "subagent needs attention";
-	return [
-		statusLabel,
-		"",
-		event.type === "active_long_running"
-			? `${event.agent} is still active but long-running in run ${event.runId}.`
-			: `${event.agent} needs attention in run ${event.runId}.`,
-		"",
-		formatControlNoticeMessage(event, childIntercomTarget),
-	].join("\n");
-}

package/dist/builtin/subagents/src/runs/shared/worktree-post-create.ts

@@ -1,111 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-export interface WorktreeGitResult {
-	stdout: string;
-	stderr: string;
-	status: number | null;
-}
-export type WorktreeGitRunner = (cwd: string, args: string[]) => WorktreeGitResult;
-
-function tracked(runGit: WorktreeGitRunner, repo: string, relativePath: string): boolean {
-	return runGit(repo, ["ls-files", "--error-unmatch", "--", relativePath]).status === 0;
-}
-function hasTrackedPathComponent(runGit: WorktreeGitRunner, repo: string, relativePath: string): boolean {
-	const components = relativePath.split(/[\\/]+/).filter(Boolean);
-	let candidate = "";
-	for (const component of components) {
-		candidate = candidate ? `${candidate}/${component}` : component;
-		const result = runGit(repo, ["ls-files", "--stage", "--", candidate]);
-		if (result.stdout.split(/\r?\n/).some((line) => line.slice(line.indexOf("\t") + 1) === candidate)) return true;
-	}
-	return false;
-}
-function copySettings(
-	runGit: WorktreeGitRunner,
-	mainRoot: string,
-	worktreeRoot: string,
-	relativePath: string,
-): boolean {
-	const source = path.join(mainRoot, relativePath);
-	const destination = path.join(worktreeRoot, relativePath);
-	if (
-		!fs.existsSync(source) ||
-		fs.existsSync(destination) ||
-		hasTrackedPathComponent(runGit, worktreeRoot, relativePath)
-	)
-		return false;
-	fs.mkdirSync(path.dirname(destination), { recursive: true });
-	fs.copyFileSync(source, destination);
-	return true;
-}
-function configureHooks(runGit: WorktreeGitRunner, mainRoot: string): void {
-	const husky = path.join(mainRoot, ".husky");
-	const ordinary = path.join(mainRoot, ".git", "hooks");
-	let desired: string | undefined;
-	try {
-		if (fs.statSync(husky).isDirectory()) desired = husky;
-	} catch {
-		/* continue */
-	}
-	if (!desired) {
-		try {
-			if (
-				fs
-					.readdirSync(ordinary, { withFileTypes: true })
-					.some((entry) => entry.isFile() && !entry.name.endsWith(".sample"))
-			)
-				desired = ordinary;
-		} catch {
-			/* no hooks */
-		}
-	}
-	if (!desired) return;
-	const current = runGit(mainRoot, ["config", "--get", "core.hooksPath"]);
-	if (current.status === 0 && path.resolve(mainRoot, current.stdout.trim()) === desired) return;
-	const result = runGit(mainRoot, ["config", "core.hooksPath", desired]);
-	if (result.status !== 0) throw new Error(result.stderr.trim() || "failed to configure shared core.hooksPath");
-}
-function copyIncludes(runGit: WorktreeGitRunner, mainRoot: string, worktreeRoot: string): void {
-	if (!fs.existsSync(path.join(mainRoot, ".worktreeinclude"))) return;
-	const ignored = runGit(mainRoot, ["ls-files", "--others", "--ignored", "--exclude-standard"]);
-	const included = runGit(mainRoot, ["ls-files", "--others", "--ignored", "--exclude-from=.worktreeinclude"]);
-	if (ignored.status !== 0 || included.status !== 0) return;
-	const ignoredPaths = new Set(ignored.stdout.split(/\r?\n/).filter(Boolean));
-	for (const relativePath of included.stdout.split(/\r?\n/).filter(Boolean)) {
-		if (!ignoredPaths.has(relativePath) || hasTrackedPathComponent(runGit, worktreeRoot, relativePath)) continue;
-		const source = path.join(mainRoot, relativePath);
-		const destination = path.join(worktreeRoot, relativePath);
-		try {
-			if (!fs.statSync(source).isFile() || fs.existsSync(destination)) continue;
-			fs.mkdirSync(path.dirname(destination), { recursive: true });
-			fs.copyFileSync(source, destination);
-		} catch {
-			/* concurrent removal */
-		}
-	}
-}
-export function performPostCreationSetup(runGit: WorktreeGitRunner, mainRoot: string, worktreeRoot: string): string[] {
-	const synthetic: string[] = [];
-	if (copySettings(runGit, mainRoot, worktreeRoot, ".atomic/settings.local.json"))
-		synthetic.push(".atomic/settings.local.json");
-	if (
-		!tracked(runGit, mainRoot, ".atomic/settings.json") &&
-		copySettings(runGit, mainRoot, worktreeRoot, ".atomic/settings.json")
-	) {
-		synthetic.push(".atomic/settings.json");
-	}
-	configureHooks(runGit, mainRoot);
-	const source = path.join(mainRoot, "node_modules");
-	const destination = path.join(worktreeRoot, "node_modules");
-	if (fs.existsSync(source) && !fs.existsSync(destination) && !tracked(runGit, worktreeRoot, "node_modules")) {
-		try {
-			fs.symlinkSync(source, destination, process.platform === "win32" ? "junction" : undefined);
-			synthetic.push("node_modules");
-		} catch {
-			/* optional */
-		}
-	}
-	copyIncludes(runGit, mainRoot, worktreeRoot);
-	return synthetic;
-}

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

@@ -1,67 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-function readText(file: string): string | undefined {
-	try {
-		return fs.readFileSync(file, "utf8");
-	} catch {
-		return undefined;
-	}
-}
-function samePath(left: string, right: string): boolean {
-	try {
-		const a = fs.realpathSync.native(left);
-		const b = fs.realpathSync.native(right);
-		return process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
-	} catch {
-		return false;
-	}
-}
-export function findGitRoot(cwd: string): string | undefined {
-	let current = path.resolve(cwd);
-	try {
-		if (!fs.statSync(current).isDirectory()) current = path.dirname(current);
-	} catch {
-		return undefined;
-	}
-	while (true) {
-		try {
-			const entry = fs.statSync(path.join(current, ".git"));
-			if (entry.isDirectory() || entry.isFile()) return current;
-		} catch {
-			/* walk */
-		}
-		const parent = path.dirname(current);
-		if (parent === current) return undefined;
-		current = parent;
-	}
-}
-export function resolveMainRepoRoot(repoRoot: string): string | undefined {
-	const gitEntry = path.join(repoRoot, ".git");
-	let stats: fs.Stats;
-	try {
-		stats = fs.statSync(gitEntry);
-	} catch {
-		return undefined;
-	}
-	if (stats.isDirectory()) return path.resolve(repoRoot);
-	if (!stats.isFile()) return undefined;
-	const contents = readText(gitEntry);
-	if (contents === undefined || !contents.startsWith("gitdir:")) return undefined;
-	const pointer = contents.slice("gitdir:".length).trim();
-	if (!pointer) return undefined;
-	const gitDir = path.resolve(repoRoot, pointer);
-	if (path.basename(path.dirname(gitDir)) !== "worktrees") return undefined;
-	const commonGitDir = path.dirname(path.dirname(gitDir));
-	if (path.basename(commonGitDir) !== ".git") return undefined;
-	const back = readText(path.join(gitDir, "gitdir"))?.trim();
-	const common = readText(path.join(gitDir, "commondir"))?.trim();
-	if (!back || !common) return undefined;
-	if (!samePath(path.resolve(gitDir, back), gitEntry)) return undefined;
-	if (!samePath(path.resolve(gitDir, common), commonGitDir)) return undefined;
-	return path.dirname(commonGitDir);
-}
-export function findCanonicalGitRoot(cwd: string): string | undefined {
-	const repoRoot = findGitRoot(cwd);
-	return repoRoot === undefined ? undefined : resolveMainRepoRoot(repoRoot);
-}