@leing2021/super-pi 0.22.0 → 0.23.0

package/extensions/subagent/schemas.ts

@@ -1,164 +0,0 @@
-// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
-// MIT License
-/**
- * TypeBox schemas for subagent tool parameters
- */
-
-import { Type } from "typebox";
-
-const SkillOverride = Type.Unsafe({
-	type: ["string", "array", "boolean"],
-	items: { type: "string" },
-	description: "Skill name(s) to inject (comma-separated), array of strings, or boolean (false disables, true uses default)",
-});
-
-const OutputOverride = Type.Unsafe({
-	type: ["string", "boolean"],
-	description: "Output filename/path (string), or false to disable file output",
-});
-
-const ReadsOverride = Type.Unsafe({
-	type: ["array", "boolean"],
-	items: { type: "string" },
-	description: "Files to read before running (array of filenames), or false to disable",
-});
-
-export const TaskItem = Type.Object({ 
-	agent: Type.String(), 
-	task: Type.String(), 
-	cwd: Type.Optional(Type.String()),
-	count: Type.Optional(Type.Integer({ minimum: 1, description: "Repeat this parallel task N times with the same settings." })),
-	output: Type.Optional(OutputOverride),
-	reads: Type.Optional(ReadsOverride),
-	progress: Type.Optional(Type.Boolean({ description: "Enable progress.md tracking for this task" })),
-	model: Type.Optional(Type.String({ description: "Override model for this task (e.g. 'google/gemini-3-pro')" })),
-	skill: Type.Optional(SkillOverride),
-});
-
-// Sequential chain step (single agent)
-export const SequentialStepSchema = Type.Object({
-	agent: Type.String(),
-	task: Type.Optional(Type.String({ 
-		description: "Task template with variables: {task}=original request, {previous}=prior step's text response, {chain_dir}=shared folder. Required for first step, defaults to '{previous}' for subsequent steps." 
-	})),
-	cwd: Type.Optional(Type.String()),
-	output: Type.Optional(OutputOverride),
-	reads: Type.Optional(ReadsOverride),
-	progress: Type.Optional(Type.Boolean({ description: "Enable progress.md tracking in {chain_dir}" })),
-	skill: Type.Optional(SkillOverride),
-	model: Type.Optional(Type.String({ description: "Override model for this step" })),
-});
-
-// Parallel task item (within a parallel step)
-export const ParallelTaskSchema = Type.Object({
-	agent: Type.String(),
-	task: Type.Optional(Type.String({ description: "Task template with {task}, {previous}, {chain_dir} variables. Defaults to {previous}." })),
-	cwd: Type.Optional(Type.String()),
-	count: Type.Optional(Type.Integer({ minimum: 1, description: "Repeat this parallel task N times with the same settings." })),
-	output: Type.Optional(OutputOverride),
-	reads: Type.Optional(ReadsOverride),
-	progress: Type.Optional(Type.Boolean({ description: "Enable progress.md tracking in {chain_dir}" })),
-	skill: Type.Optional(SkillOverride),
-	model: Type.Optional(Type.String({ description: "Override model for this task" })),
-});
-
-// Parallel chain step (multiple agents running concurrently)
-export const ParallelStepSchema = Type.Object({
-	parallel: Type.Array(ParallelTaskSchema, { minItems: 1, description: "Tasks to run in parallel" }),
-	concurrency: Type.Optional(Type.Number({ description: "Max concurrent tasks (default: 4)" })),
-	failFast: Type.Optional(Type.Boolean({ description: "Stop on first failure (default: false)" })),
-	worktree: Type.Optional(Type.Boolean({
-		description: "Create isolated git worktrees for each parallel task."
-	})),
-});
-
-// Flattened so providers that reject anyOf/oneOf can still accept either sequential or parallel steps.
-export const ChainItem = Type.Object({
-	agent: Type.Optional(Type.String({ description: "Sequential step agent name" })),
-	task: Type.Optional(Type.String({
-		description: "Task template with variables: {task}=original request, {previous}=prior step's text response, {chain_dir}=shared folder. Required for first step, defaults to '{previous}' for subsequent steps."
-	})),
-	cwd: Type.Optional(Type.String()),
-	output: Type.Optional(OutputOverride),
-	reads: Type.Optional(ReadsOverride),
-	progress: Type.Optional(Type.Boolean({ description: "Enable progress.md tracking in {chain_dir}" })),
-	skill: Type.Optional(SkillOverride),
-	model: Type.Optional(Type.String({ description: "Override model for this step" })),
-	parallel: Type.Optional(Type.Array(ParallelTaskSchema, { minItems: 1, description: "Tasks to run in parallel" })),
-	concurrency: Type.Optional(Type.Number({ description: "Max concurrent tasks (default: 4)" })),
-	failFast: Type.Optional(Type.Boolean({ description: "Stop on first failure (default: false)" })),
-	worktree: Type.Optional(Type.Boolean({
-		description: "Create isolated git worktrees for each parallel task."
-	})),
-}, { description: "Chain step: use {agent, task?, ...} for sequential or {parallel: [...]} for concurrent execution" });
-
-export const ControlOverrides = Type.Object({
-	enabled: Type.Optional(Type.Boolean({ description: "Enable/disable subagent control attention tracking for this run" })),
-	needsAttentionAfterMs: Type.Optional(Type.Integer({ minimum: 1, description: "No-observed-activity window before a run needs attention" })),
-	notifyOn: Type.Optional(Type.Array(Type.String({ enum: ["needs_attention"] }), {
-		description: "Control event types that should notify the parent/orchestrator. Defaults to needs_attention.",
-	})),
-	notifyChannels: Type.Optional(Type.Array(Type.String({ enum: ["event", "async", "intercom"] }), {
-		description: "Notification channels to use when available. Defaults to event, async, and intercom.",
-	})),
-});
-
-export const SubagentParams = Type.Object({
-	agent: Type.Optional(Type.String({ description: "Agent name (SINGLE mode) or target for management get/update/delete" })),
-	task: Type.Optional(Type.String({ description: "Task (SINGLE mode, optional for self-contained agents)" })),
-	// Management action (when present, tool operates in management mode)
-	action: Type.Optional(Type.String({
-		description: "Action: 'list', 'get', 'create', 'update', 'delete', 'status', 'interrupt', or 'doctor'. Omit for execution mode."
-	})),
-	id: Type.Optional(Type.String({
-		description: "Run id or prefix for action='status' or action='interrupt'."
-	})),
-	runId: Type.Optional(Type.String({
-		description: "Target run ID for action='interrupt'. Defaults to the most recently active controllable run in this session. Prefer id for new calls."
-	})),
-	dir: Type.Optional(Type.String({
-		description: "Async run directory for action='status'."
-	})),
-	// Chain identifier for management (can't reuse 'chain' — that's the execution array)
-	chainName: Type.Optional(Type.String({
-		description: "Chain name for get/update/delete management actions"
-	})),
-	// Agent/chain configuration for create/update (nested to avoid conflicts with execution fields)
-	config: Type.Optional(Type.Unsafe({
-		type: ["object", "string"],
-		additionalProperties: true,
-		description: "Agent or chain config for create/update. Agent: name, description, scope ('user'|'project', default 'user'), systemPrompt, systemPromptMode, inheritProjectContext, inheritSkills, model, tools (comma-separated), extensions (comma-separated), skills (comma-separated), thinking, output, reads, progress, maxSubagentDepth. Chain: name, description, scope, steps (array of {agent, task?, output?, reads?, model?, skills?, progress?}). Presence of 'steps' creates a chain instead of an agent. String values must be valid JSON."
-	})),
-	tasks: Type.Optional(Type.Array(TaskItem, { description: "PARALLEL mode: [{agent, task, count?, output?, reads?, progress?}, ...]" })),
-	concurrency: Type.Optional(Type.Integer({ minimum: 1, description: "Top-level PARALLEL mode only: max concurrent tasks. Defaults to config.parallel.concurrency or 4." })),
-	worktree: Type.Optional(Type.Boolean({
-		description: "Create isolated git worktrees for each parallel task. " +
-			"Prevents filesystem conflicts. Requires clean git state. " +
-			"Per-worktree diffs included in output."
-	})),
-	chain: Type.Optional(Type.Array(ChainItem, { description: "CHAIN mode: sequential pipeline where each step's response becomes {previous} for the next. Use {task}, {previous}, {chain_dir} in task templates." })),
-	context: Type.Optional(Type.String({
-		enum: ["fresh", "fork"],
-		description: "'fresh' (default) or 'fork' to branch from parent session",
-	})),
-	chainDir: Type.Optional(Type.String({ description: "Persistent directory for chain artifacts. Default: a user-scoped temp directory under <tmpdir>/ (auto-cleaned after 24h)" })),
-	async: Type.Optional(Type.Boolean({ description: "Run in background (default: false, or per config)" })),
-	agentScope: Type.Optional(Type.String({ description: "Agent discovery scope: 'user', 'project', or 'both' (default: 'both'; project wins on name collisions)" })),
-	cwd: Type.Optional(Type.String()),
-	artifacts: Type.Optional(Type.Boolean({ description: "Write debug artifacts (default: true)" })),
-	includeProgress: Type.Optional(Type.Boolean({ description: "Include full progress in result (default: false)" })),
-	share: Type.Optional(Type.Boolean({ description: "Upload session to GitHub Gist for sharing (default: false)" })),
-	sessionDir: Type.Optional(
-		Type.String({ description: "Directory to store session logs (default: temp; enables sessions even if share=false)" }),
-	),
-	// Clarification TUI
-	clarify: Type.Optional(Type.Boolean({ description: "Show TUI to preview/edit before execution (default: true for chains, false for single/parallel). Implies sync mode." })),
-	control: Type.Optional(ControlOverrides),
-	// Solo agent overrides
-	output: Type.Optional(Type.Unsafe({
-		type: ["string", "boolean"],
-		description: "Output file for single agent (string), or false to disable. Relative paths resolve against cwd.",
-	})),
-	skill: Type.Optional(SkillOverride),
-	model: Type.Optional(Type.String({ description: "Override model for single agent (e.g. 'anthropic/claude-sonnet-4')" })),
-});

package/extensions/subagent/session-tokens.ts

@@ -1,50 +0,0 @@
-// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
-// MIT License
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-export interface TokenUsage {
-	input: number;
-	output: number;
-	total: number;
-}
-
-function findLatestSessionFile(sessionDir: string): string | null {
-	try {
-		const files = fs.readdirSync(sessionDir)
-			.filter((f) => f.endsWith(".jsonl"))
-			.map((f) => path.join(sessionDir, f));
-		if (files.length === 0) return null;
-		files.sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
-		return files[0] ?? null;
-	} catch {
-		return null;
-	}
-}
-
-export function parseSessionTokens(sessionDir: string): TokenUsage | null {
-	const sessionFile = findLatestSessionFile(sessionDir);
-	if (!sessionFile) return null;
-	try {
-		const content = fs.readFileSync(sessionFile, "utf-8");
-		let input = 0;
-		let output = 0;
-		for (const line of content.split("\n")) {
-			if (!line.trim()) continue;
-			try {
-				const entry = JSON.parse(line);
-				const usage = entry.usage ?? entry.message?.usage;
-				if (usage) {
-					input += usage.inputTokens ?? usage.input ?? 0;
-					output += usage.outputTokens ?? usage.output ?? 0;
-				}
-			} catch {
-				// Ignore malformed lines while scanning usage entries.
-			}
-		}
-		return { input, output, total: input + output };
-	} catch {
-		// Usage extraction should not fail the run.
-		return null;
-	}
-}

package/extensions/subagent/settings.ts

@@ -1,367 +0,0 @@
-// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
-// MIT License
-/**
- * Chain behavior, template resolution, and directory management
- */
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { AgentConfig } from "./agents.ts";
-import { normalizeSkillInput } from "./skills.ts";
-import { CHAIN_RUNS_DIR } 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;
-	reads: string[] | false;
-	progress: boolean;
-	skills: string[] | false;
-	model?: string;
-}
-
-export interface StepOverrides {
-	output?: string | false;
-	reads?: string[] | false;
-	progress?: boolean;
-	skills?: string[] | false;
-	model?: string;
-}
-
-// =============================================================================
-// Chain Step Types
-// =============================================================================
-
-/** Sequential step: single agent execution */
-export interface SequentialStep {
-	agent: string;
-	task?: string;
-	cwd?: string;
-	output?: string | false;
-	reads?: string[] | false;
-	progress?: boolean;
-	skill?: string | string[] | false;
-	model?: string;
-}
-
-/** Parallel task item within a parallel step */
-export interface ParallelTaskItem {
-	agent: string;
-	task?: string;
-	cwd?: string;
-	count?: number;
-	output?: string | false;
-	reads?: string[] | false;
-	progress?: boolean;
-	skill?: string | string[] | false;
-	model?: string;
-}
-
-/** Parallel step: multiple agents running concurrently */
-export interface ParallelStep {
-	parallel: ParallelTaskItem[];
-	concurrency?: number;
-	failFast?: boolean;
-	worktree?: boolean;
-}
-
-/** Union type for chain steps */
-export type ChainStep = SequentialStep | ParallelStep;
-
-// =============================================================================
-// Type Guards
-// =============================================================================
-
-export function isParallelStep(step: ChainStep): step is ParallelStep {
-	return "parallel" in step && Array.isArray((step as ParallelStep).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);
-	}
-	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}";
-			});
-		}
-		// 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)
-	const output =
-		stepOverrides.output !== undefined
-			? stepOverrides.output
-			: 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])];
-		}
-	}
-
-	const model = stepOverrides.model ?? agentConfig.model;
-	return { output, reads, progress, skills, model };
-}
-
-// =============================================================================
-// 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 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.writeFileSync(path.join(progressDir, "progress.md"), INITIAL_PROGRESS_CONTENT);
-}
-
-export function buildChainInstructions(
-	behavior: ResolvedStepBehavior,
-	chainDir: 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
-	if (behavior.reads && behavior.reads.length > 0) {
-		const files = behavior.reads.map((f) => resolveChainPath(f, chainDir));
-		prefixParts.push(`[Read from: ${files.join(", ")}]`);
-	}
-
-	// OUTPUT - prepend so agent knows where to write
-	if (behavior.output) {
-		const outputPath = resolveChainPath(behavior.output, chainDir);
-		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 && previousSummary.trim()) {
-		suffixParts.push(`Previous step output:\n${previousSummary.trim()}`);
-	}
-
-	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;
-		if (task.output !== undefined) {
-			if (task.output === false) {
-				output = false;
-			} else if (path.isAbsolute(task.output)) {
-				output = task.output; // Absolute path: use as-is
-			} else {
-				output = path.join(subdir, task.output); // Relative: namespace under subdir
-			}
-		} else if (config.output) {
-			// Agent defaults are always relative, so namespace them
-			output = path.join(subdir, config.output);
-		}
-
-		// 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 model = task.model ?? config.model;
-		return { output, 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 "./parallel-utils.ts";
-export { aggregateParallelOutputs } from "./parallel-utils.ts";

package/extensions/subagent/single-output.ts

@@ -1,97 +0,0 @@
-// Based on pi-subagents by Nico Bailon (https://github.com/nicobailon/pi-subagents)
-// MIT License
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-export interface SingleOutputSnapshot {
-	exists: boolean;
-	mtimeMs?: number;
-	size?: number;
-}
-
-export function resolveSingleOutputPath(
-	output: string | false | undefined,
-	runtimeCwd: string,
-	requestedCwd?: string,
-): string | undefined {
-	if (typeof output !== "string" || !output) 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}`;
-}
-
-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 {
-		return { exists: false };
-	}
-}
-
-export 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 };
-
-	try {
-		const stat = fs.statSync(outputPath);
-		const changedSinceStart = !beforeRun?.exists
-			|| stat.mtimeMs !== beforeRun.mtimeMs
-			|| stat.size !== beforeRun.size;
-		if (changedSinceStart) {
-			return {
-				fullOutput: fs.readFileSync(outputPath, "utf-8"),
-				savedPath: outputPath,
-			};
-		}
-	} catch {}
-
-	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;
-	exitCode: number;
-	savedPath?: string;
-	saveError?: string;
-}): { displayOutput: string; savedPath?: string; saveError?: string } {
-	let displayOutput = params.truncatedOutput || params.fullOutput;
-	if (params.exitCode === 0 && params.savedPath) {
-		displayOutput += `\n\nOutput saved to: ${params.savedPath}`;
-		return { displayOutput, savedPath: params.savedPath };
-	}
-	if (params.exitCode === 0 && params.saveError && params.outputPath) {
-		displayOutput += `\n\nFailed to save output to: ${params.outputPath}\n${params.saveError}`;
-		return { displayOutput, saveError: params.saveError };
-	}
-	return { displayOutput };
-}