@bastani/atomic 0.9.12 → 0.9.13-alpha.1

package/dist/builtin/subagents/src/runs/background/subagent-runner-dynamic.ts

@@ -1,376 +0,0 @@
-import * as path from "node:path";
-import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
-import type { SupervisorAuthorization } from "../../intercom/supervisor-authorization.ts";
-import { appendJsonl } from "../../shared/artifacts.ts";
-import { resolveEffectiveThinking } from "../../shared/model-info.ts";
-import {
-	collectDynamicResults,
-	DynamicFanoutError,
-	materializeDynamicParallelStep,
-	validateDynamicCollection,
-} from "../shared/dynamic-fanout.ts";
-import { createMutatingFailureState } from "../shared/long-running-guard.ts";
-import { aggregateParallelOutputs, MAX_PARALLEL_CONCURRENCY, mapConcurrent } from "../shared/parallel-utils.ts";
-import {
-	markDynamicGraphGroup,
-	resetStepLiveDetail,
-	updateStepFromChildEvent,
-	updateStepModel,
-	writeStatusPayload,
-} from "./subagent-runner-state.ts";
-import { runSingleStep } from "./subagent-runner-step.ts";
-import type { RunnerExecutionState, RunnerStatusStep, RunnerStep, SubagentStep } from "./subagent-runner-types.ts";
-
-export async function runDynamicGroup(
-	state: RunnerExecutionState,
-	step: RunnerStep,
-	stepIndex: number,
-): Promise<boolean> {
-	const {
-		outputs,
-		statusPayload,
-		asyncDir,
-		id,
-		cwd,
-		placeholder,
-		sessionEnabled,
-		config,
-		artifactsDir,
-		artifactConfig,
-	} = state;
-	const groupStartFlatIndex = state.flatIndex;
-	let materialized: ReturnType<typeof materializeDynamicParallelStep>;
-	try {
-		materialized = materializeDynamicParallelStep(
-			step as Parameters<typeof materializeDynamicParallelStep>[0],
-			outputs,
-			stepIndex,
-			{ maxItems: config.dynamicFanoutMaxItems, allowRunnerFields: true },
-		);
-		if (materialized.collectedOnEmpty)
-			validateDynamicCollection(
-				(step as Parameters<typeof materializeDynamicParallelStep>[0]).collect.outputSchema,
-				materialized.collectedOnEmpty,
-			);
-	} catch (error) {
-		const now = Date.now();
-		const message =
-			error instanceof DynamicFanoutError ? error.message : error instanceof Error ? error.message : String(error);
-		statusPayload.state = "failed";
-		statusPayload.error = message;
-		statusPayload.currentStep = state.flatIndex;
-		const placeholderStep = statusPayload.steps[groupStartFlatIndex];
-		if (placeholderStep) {
-			placeholderStep.status = "failed";
-			placeholderStep.error = message;
-			placeholderStep.startedAt = now;
-			placeholderStep.endedAt = now;
-			placeholderStep.durationMs = 0;
-			placeholderStep.exitCode = 1;
-		}
-		statusPayload.lastUpdate = now;
-		markDynamicGraphGroup(state, stepIndex, "failed", message);
-		writeStatusPayload(state);
-		const dynamicStep = step as Parameters<typeof materializeDynamicParallelStep>[0];
-		state.results.push({
-			agent: dynamicStep.parallel.agent,
-			output: message,
-			error: message,
-			success: false,
-			exitCode: 1,
-		});
-		return false;
-	}
-
-	const dynamicStep = step as Parameters<typeof materializeDynamicParallelStep>[0];
-	const parallelTemplate = dynamicStep.parallel as unknown as SubagentStep;
-	if (materialized.parallel.length === 0) {
-		const now = Date.now();
-		const collection = materialized.collectedOnEmpty ?? [];
-		outputs[dynamicStep.collect.as] = {
-			text: JSON.stringify(collection),
-			structured: collection,
-			agent: dynamicStep.parallel.agent,
-			stepIndex,
-		};
-		statusPayload.outputs = outputs;
-		const placeholderStep = statusPayload.steps[groupStartFlatIndex];
-		if (placeholderStep) {
-			placeholderStep.status = "complete";
-			placeholderStep.startedAt = now;
-			placeholderStep.endedAt = now;
-			placeholderStep.durationMs = 0;
-		}
-		state.previousOutput = "Dynamic fanout produced 0 results.";
-		state.flatIndex++;
-		statusPayload.lastUpdate = now;
-		markDynamicGraphGroup(state, stepIndex, "completed");
-		writeStatusPayload(state);
-		return true;
-	}
-
-	const dynamicSteps: SubagentStep[] = materialized.parallel.map((task) => ({
-		...parallelTemplate,
-		task: task.task ?? parallelTemplate.task,
-		label: task.label ?? parallelTemplate.label,
-		structuredOutput: undefined,
-		structuredOutputSchema: parallelTemplate.structuredOutputSchema ?? parallelTemplate.structuredOutput?.schema,
-	}));
-	const dynamicStatusSteps: RunnerStatusStep[] = dynamicSteps.map((task) => ({
-		agent: task.agent,
-		phase: task.phase ?? dynamicStep.phase,
-		label: task.label,
-		outputName: undefined,
-		structured: Boolean(task.structuredOutputSchema),
-		status: "pending",
-		...(task.sessionFile ? { sessionFile: task.sessionFile } : {}),
-		skills: task.skills,
-		model: task.model,
-		thinking: task.thinking,
-		attemptedModels:
-			task.modelCandidates && task.modelCandidates.length > 0
-				? task.modelCandidates
-				: task.model
-					? [task.model]
-					: undefined,
-		recentTools: [],
-		recentOutput: [],
-	}));
-	statusPayload.steps.splice(groupStartFlatIndex, 1, ...dynamicStatusSteps);
-	if (config.childIntercomTargets)
-		config.childIntercomTargets = statusPayload.steps.map((statusStep, index) =>
-			resolveSubagentIntercomTarget(id, statusStep.agent, index),
-		);
-	const dynamicAuthorizations = config.dynamicSupervisorAuthorizations?.[stepIndex];
-	if (dynamicAuthorizations) {
-		const authorizations =
-			config.supervisorAuthorizations ??
-			new Array<SupervisorAuthorization | undefined>(
-				statusPayload.steps.length - dynamicStatusSteps.length + 1,
-			).fill(undefined);
-		authorizations.splice(groupStartFlatIndex, 1, ...dynamicSteps.map((_, index) => dynamicAuthorizations[index]));
-		config.supervisorAuthorizations = authorizations;
-	}
-	state.mutatingFailureStates.splice(
-		groupStartFlatIndex,
-		1,
-		...dynamicStatusSteps.map(() => createMutatingFailureState()),
-	);
-	state.pendingToolResults.splice(groupStartFlatIndex, 1, ...dynamicStatusSteps.map(() => undefined));
-	const materializedDelta = dynamicStatusSteps.length - 1;
-	for (const group of statusPayload.parallelGroups) {
-		if (group.stepIndex === stepIndex) {
-			group.start = groupStartFlatIndex;
-			group.count = dynamicStatusSteps.length;
-		} else if (group.start > groupStartFlatIndex) {
-			group.start += materializedDelta;
-		}
-	}
-	if (statusPayload.workflowGraph) {
-		const shiftFlatIndexes = (nodes: NonNullable<typeof statusPayload.workflowGraph>["nodes"]): void => {
-			for (const node of nodes) {
-				if (
-					node.stepIndex !== undefined &&
-					node.stepIndex > stepIndex &&
-					node.flatIndex !== undefined &&
-					node.flatIndex >= groupStartFlatIndex
-				)
-					node.flatIndex += dynamicStatusSteps.length;
-				if (node.children) shiftFlatIndexes(node.children);
-			}
-		};
-		shiftFlatIndexes(statusPayload.workflowGraph.nodes);
-		const groupNode = statusPayload.workflowGraph.nodes.find((node) => node.id === `step-${stepIndex}`);
-		if (groupNode) {
-			groupNode.children = materialized.items.map((item, itemIndex) => ({
-				id: `step-${stepIndex}-item-${item.idKey}`,
-				kind: "agent",
-				agent: parallelTemplate.agent,
-				phase: dynamicSteps[itemIndex]?.phase ?? dynamicStep.phase,
-				label: dynamicSteps[itemIndex]?.label?.trim() || `${parallelTemplate.agent} ${item.key}`,
-				status: "pending",
-				flatIndex: groupStartFlatIndex + itemIndex,
-				stepIndex,
-				itemKey: item.key,
-				structured: Boolean(dynamicSteps[itemIndex]?.structuredOutputSchema),
-			}));
-		}
-	}
-	writeStatusPayload(state);
-
-	const concurrency = dynamicStep.concurrency ?? MAX_PARALLEL_CONCURRENCY;
-	const failFast = dynamicStep.failFast ?? false;
-	let aborted = false;
-	const parallelResults = await mapConcurrent(dynamicSteps, concurrency, async (task, taskIdx) => {
-		const fi = groupStartFlatIndex + taskIdx;
-		if (aborted && failFast) {
-			const skippedAt = Date.now();
-			statusPayload.steps[fi].status = "failed";
-			statusPayload.steps[fi].error = "Skipped due to fail-fast";
-			statusPayload.steps[fi].startedAt = skippedAt;
-			statusPayload.steps[fi].endedAt = skippedAt;
-			statusPayload.steps[fi].durationMs = 0;
-			statusPayload.steps[fi].exitCode = -1;
-			statusPayload.lastUpdate = skippedAt;
-			writeStatusPayload(state);
-			return { agent: task.agent, output: "(skipped — fail-fast)", exitCode: -1 as number | null, skipped: true };
-		}
-		const taskStartTime = Date.now();
-		statusPayload.currentStep = fi;
-		statusPayload.steps[fi].status = "running";
-		statusPayload.steps[fi].error = undefined;
-		statusPayload.steps[fi].activityState = undefined;
-		resetStepLiveDetail(statusPayload.steps[fi]);
-		statusPayload.steps[fi].startedAt = taskStartTime;
-		statusPayload.steps[fi].lastActivityAt = taskStartTime;
-		statusPayload.outputFile = path.join(asyncDir, `output-${fi}.log`);
-		statusPayload.lastActivityAt = taskStartTime;
-		statusPayload.lastUpdate = taskStartTime;
-		writeStatusPayload(state);
-		appendJsonl(
-			state.eventsPath,
-			JSON.stringify({
-				type: "subagent.step.started",
-				ts: taskStartTime,
-				runId: id,
-				stepIndex: fi,
-				agent: task.agent,
-			}),
-		);
-		const singleResult = await runSingleStep(task, {
-			previousOutput: state.previousOutput,
-			placeholder,
-			cwd,
-			sessionEnabled,
-			outputs,
-			sessionDir: config.sessionDir ? path.join(config.sessionDir, `dynamic-${stepIndex}-${taskIdx}`) : undefined,
-			artifactsDir,
-			artifactConfig,
-			id,
-			flatIndex: fi,
-			flatStepCount: Math.max(statusPayload.steps.length, 1),
-			outputFile: path.join(asyncDir, `output-${fi}.log`),
-			piPackageRoot: config.piPackageRoot,
-			piArgv1: config.piArgv1,
-			childIntercomTarget: config.childIntercomTargets?.[fi],
-			orchestratorIntercomTarget: config.controlIntercomTarget,
-			supervisorAuthorization: config.supervisorAuthorizations?.[fi],
-			nestedRoute: config.nestedRoute,
-			registerInterrupt: (interrupt) => {
-				state.activeChildInterrupt = interrupt;
-			},
-			onAttemptStart: (attempt) => updateStepModel(state, fi, attempt.model, attempt.thinking),
-			onChildEvent: (event) => updateStepFromChildEvent(state, fi, event),
-		});
-		const taskEndTime = Date.now();
-		statusPayload.steps[fi].status = singleResult.exitCode === 0 ? "complete" : "failed";
-		statusPayload.steps[fi].endedAt = taskEndTime;
-		statusPayload.steps[fi].durationMs = taskEndTime - taskStartTime;
-		statusPayload.steps[fi].exitCode = singleResult.exitCode;
-		statusPayload.steps[fi].model = singleResult.model;
-		statusPayload.steps[fi].thinking = resolveEffectiveThinking(singleResult.model, statusPayload.steps[fi].thinking);
-		statusPayload.steps[fi].attemptedModels = singleResult.attemptedModels;
-		statusPayload.steps[fi].modelAttempts = singleResult.modelAttempts;
-		statusPayload.steps[fi].error = singleResult.error;
-		statusPayload.steps[fi].structuredOutput = singleResult.structuredOutput;
-		statusPayload.steps[fi].structuredOutputPath = singleResult.structuredOutputPath;
-		statusPayload.steps[fi].structuredOutputSchemaPath = singleResult.structuredOutputSchemaPath;
-		statusPayload.lastUpdate = taskEndTime;
-		writeStatusPayload(state);
-		appendJsonl(
-			state.eventsPath,
-			JSON.stringify({
-				type: singleResult.exitCode === 0 ? "subagent.step.completed" : "subagent.step.failed",
-				ts: taskEndTime,
-				runId: id,
-				stepIndex: fi,
-				agent: task.agent,
-				exitCode: singleResult.exitCode,
-				durationMs: taskEndTime - taskStartTime,
-			}),
-		);
-		if (singleResult.exitCode !== 0 && failFast) aborted = true;
-		return { ...singleResult, skipped: false };
-	});
-
-	state.flatIndex += dynamicSteps.length;
-	for (const pr of parallelResults)
-		state.results.push({
-			agent: pr.agent,
-			output: pr.output,
-			error: pr.error,
-			success: pr.exitCode === 0,
-			exitCode: pr.exitCode,
-			skipped: pr.skipped,
-			sessionFile: pr.sessionFile,
-			intercomTarget: pr.intercomTarget,
-			model: pr.model,
-			attemptedModels: pr.attemptedModels,
-			modelAttempts: pr.modelAttempts,
-			artifactPaths: pr.artifactPaths,
-			structuredOutput: pr.structuredOutput,
-			structuredOutputPath: pr.structuredOutputPath,
-			structuredOutputSchemaPath: pr.structuredOutputSchemaPath,
-		});
-	const collection = collectDynamicResults(
-		dynamicStep as Parameters<typeof collectDynamicResults>[0],
-		materialized.items,
-		parallelResults as Parameters<typeof collectDynamicResults>[2],
-	);
-	const failures = parallelResults.filter((result) => result.exitCode !== 0 && result.exitCode !== -1);
-	if (failures.length === 0) {
-		try {
-			validateDynamicCollection(dynamicStep.collect.outputSchema, collection);
-			outputs[dynamicStep.collect.as] = {
-				text: JSON.stringify(collection),
-				structured: collection,
-				agent: parallelTemplate.agent,
-				stepIndex,
-			};
-			statusPayload.outputs = outputs;
-			markDynamicGraphGroup(state, stepIndex, "completed");
-		} catch (error) {
-			const message =
-				error instanceof DynamicFanoutError
-					? error.message
-					: error instanceof Error
-						? error.message
-						: String(error);
-			state.results.push({
-				agent: parallelTemplate.agent,
-				output: message,
-				error: message,
-				success: false,
-				exitCode: 1,
-				structuredOutput: collection,
-			});
-			statusPayload.error = message;
-			markDynamicGraphGroup(state, stepIndex, "failed", message);
-		}
-	}
-	state.previousOutput = aggregateParallelOutputs(
-		parallelResults.map((r, i) => ({
-			agent: r.agent,
-			taskIndex: i,
-			output: r.output,
-			exitCode: r.exitCode,
-			error: r.error,
-		})),
-		(i, agent) => `=== Dynamic Item ${i + 1} (${agent}, key ${materialized.items[i]?.key ?? i}) ===`,
-	);
-	appendJsonl(
-		state.eventsPath,
-		JSON.stringify({
-			type: "subagent.dynamic.completed",
-			ts: Date.now(),
-			runId: id,
-			stepIndex,
-			success: failures.length === 0,
-		}),
-	);
-	if (failures.length > 0)
-		markDynamicGraphGroup(state, stepIndex, "failed", failures[0]?.error ?? "Dynamic fanout child failed.");
-	statusPayload.lastUpdate = Date.now();
-	writeStatusPayload(state);
-	return !(failures.length > 0 || statusPayload.error);
-}

package/dist/builtin/subagents/src/runs/background/subagent-runner-finalize.ts

@@ -1,150 +0,0 @@
-import * as path from "node:path";
-import { appendJsonl } from "../../shared/artifacts.ts";
-import { writeAtomicJson } from "../../shared/atomic-json.ts";
-import { DEFAULT_MAX_OUTPUT, truncateOutput } from "../../shared/types.ts";
-import { createShareLink, exportSessionHtml, writeRunLog } from "./subagent-runner-output.ts";
-import { cleanupActivityTimer, writeStatusPayload } from "./subagent-runner-state.ts";
-import type { RunnerExecutionState } from "./subagent-runner-types.ts";
-import { findLatestSessionFile } from "./subagent-runner-utils.ts";
-
-export async function finalizeRun(state: RunnerExecutionState): Promise<void> {
-	const { config, results, maxOutput, flatSteps, statusPayload, artifactsDir, cwd, asyncDir, id } = state;
-	let summary = results.map((r) => `${r.agent}:\n${r.output}`).join("\n\n");
-	let truncated = false;
-
-	if (maxOutput) {
-		const config = { ...DEFAULT_MAX_OUTPUT, ...maxOutput };
-		const lastArtifactPath = results[results.length - 1]?.artifactPaths?.outputPath;
-		const truncResult = truncateOutput(summary, config, lastArtifactPath);
-		if (truncResult.truncated) {
-			summary = truncResult.text;
-			truncated = true;
-		}
-	}
-
-	const resultMode = config.resultMode ?? statusPayload.mode;
-	const agentName =
-		flatSteps.length === 1
-			? flatSteps[0].agent
-			: resultMode === "parallel"
-				? `parallel:${flatSteps.map((s) => s.agent).join("+")}`
-				: `chain:${flatSteps.map((s) => s.agent).join("->")}`;
-	let sessionFile: string | undefined;
-	let shareUrl: string | undefined;
-	let gistUrl: string | undefined;
-	let shareError: string | undefined;
-
-	if (state.shareEnabled) {
-		sessionFile = config.sessionDir ? (findLatestSessionFile(config.sessionDir) ?? undefined) : undefined;
-		if (!sessionFile && state.latestSessionFile) sessionFile = state.latestSessionFile;
-		if (sessionFile) {
-			try {
-				const exportDir = config.sessionDir ?? path.dirname(sessionFile);
-				const htmlPath = await exportSessionHtml(sessionFile, exportDir, config.piPackageRoot);
-				const share = createShareLink(htmlPath);
-				if ("error" in share) shareError = share.error;
-				else {
-					shareUrl = share.shareUrl;
-					gistUrl = share.gistUrl;
-				}
-			} catch (err) {
-				shareError = String(err);
-			}
-		} else {
-			shareError = "Session file not found.";
-		}
-	}
-
-	cleanupActivityTimer(state);
-	const effectiveSessionFile = sessionFile ?? state.latestSessionFile;
-	const runEndedAt = Date.now();
-	statusPayload.state = state.interrupted ? "paused" : results.every((r) => r.success) ? "complete" : "failed";
-	statusPayload.activityState = undefined;
-	statusPayload.endedAt = runEndedAt;
-	statusPayload.lastUpdate = runEndedAt;
-	statusPayload.sessionFile = effectiveSessionFile;
-	statusPayload.shareUrl = shareUrl;
-	statusPayload.gistUrl = gistUrl;
-	statusPayload.shareError = shareError;
-	if (statusPayload.state === "failed" && !statusPayload.error) {
-		const failedStep = statusPayload.steps.find((s) => s.status === "failed");
-		if (failedStep?.agent) statusPayload.error = `Step failed: ${failedStep.agent}`;
-	}
-	writeStatusPayload(state);
-	appendJsonl(
-		state.eventsPath,
-		JSON.stringify({
-			type: "subagent.run.completed",
-			ts: runEndedAt,
-			runId: id,
-			status: statusPayload.state,
-			durationMs: runEndedAt - state.overallStartTime,
-		}),
-	);
-	writeRunLog(state.logPath, {
-		id,
-		mode: statusPayload.mode,
-		cwd,
-		startedAt: state.overallStartTime,
-		endedAt: runEndedAt,
-		steps: statusPayload.steps.map((step) => ({
-			agent: step.agent,
-			status: step.status,
-			durationMs: step.durationMs,
-		})),
-		summary,
-		truncated,
-		artifactsDir,
-		sessionFile: effectiveSessionFile,
-		shareUrl,
-		shareError,
-	});
-
-	try {
-		writeAtomicJson(state.resultPath, {
-			id,
-			agent: agentName,
-			mode: resultMode,
-			success: !state.interrupted && results.every((r) => r.success),
-			state: state.interrupted ? "paused" : results.every((r) => r.success) ? "complete" : "failed",
-			summary: state.interrupted ? "Paused after interrupt. Waiting for explicit next action." : summary,
-			results: results.map((r) => ({
-				agent: r.agent,
-				output: r.output,
-				error: r.error,
-				success: r.success,
-				skipped: r.skipped || undefined,
-				sessionFile: r.sessionFile,
-				intercomTarget: r.intercomTarget,
-				model: r.model,
-				fastMode: r.fastMode,
-				attemptedModels: r.attemptedModels,
-				modelAttempts: r.modelAttempts,
-				artifactPaths: r.artifactPaths,
-				truncated: r.truncated,
-				structuredOutput: r.structuredOutput,
-				structuredOutputPath: r.structuredOutputPath,
-				structuredOutputSchemaPath: r.structuredOutputSchemaPath,
-			})),
-			outputs: state.outputs,
-			workflowGraph: statusPayload.workflowGraph,
-			exitCode: state.interrupted || results.every((r) => r.success) ? 0 : 1,
-			timestamp: runEndedAt,
-			durationMs: runEndedAt - state.overallStartTime,
-			truncated,
-			artifactsDir,
-			cwd,
-			asyncDir,
-			sessionId: config.sessionId,
-			sessionFile: effectiveSessionFile,
-			intercomTarget: config.controlIntercomTarget,
-			shareUrl,
-			gistUrl,
-			shareError,
-			...(state.taskIndex !== undefined && { taskIndex: state.taskIndex }),
-			...(state.totalTasks !== undefined && { totalTasks: state.totalTasks }),
-		});
-	} catch (err) {
-		console.error(`Failed to write result file ${state.resultPath}:`, err);
-	}
-}

package/dist/builtin/subagents/src/runs/background/subagent-runner-output.ts

@@ -1,109 +0,0 @@
-import { spawnSync } from "node:child_process";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { pathToFileURL } from "node:url";
-import type { SubagentRunMode } from "../../shared/types.ts";
-import { PI_CODING_AGENT_PACKAGE, resolveInstalledPiPackageRoot } from "../shared/pi-spawn.ts";
-import { formatDuration } from "./subagent-runner-utils.ts";
-
-function resolvePiPackageRootFallback(): string {
-	const root = resolveInstalledPiPackageRoot();
-	if (root) return root;
-	throw new Error(`Could not resolve ${PI_CODING_AGENT_PACKAGE} package root`);
-}
-
-export async function exportSessionHtml(
-	sessionFile: string,
-	outputDir: string,
-	piPackageRoot?: string,
-): Promise<string> {
-	const pkgRoot = piPackageRoot ?? resolvePiPackageRootFallback();
-	const exportModulePath = path.join(pkgRoot, "dist", "core", "export-html", "index.js");
-	const moduleUrl = pathToFileURL(exportModulePath).href;
-	const mod = await import(moduleUrl);
-	const exportFromFile = (mod as { exportFromFile?: (inputPath: string, options?: { outputPath?: string }) => string })
-		.exportFromFile;
-	if (typeof exportFromFile !== "function") {
-		throw new Error("exportFromFile not available");
-	}
-	const outputPath = path.join(outputDir, `${path.basename(sessionFile, ".jsonl")}.html`);
-	return exportFromFile(sessionFile, { outputPath });
-}
-
-export function createShareLink(htmlPath: string): { shareUrl: string; gistUrl: string } | { error: string } {
-	try {
-		const auth = spawnSync("gh", ["auth", "status"], { encoding: "utf-8" });
-		if (auth.status !== 0) {
-			return { error: "GitHub CLI is not logged in. Run 'gh auth login' first." };
-		}
-	} catch {
-		return { error: "GitHub CLI (gh) is not installed." };
-	}
-
-	try {
-		const result = spawnSync("gh", ["gist", "create", htmlPath], { encoding: "utf-8" });
-		if (result.status !== 0) {
-			const err = (result.stderr || "").trim() || "Failed to create gist.";
-			return { error: err };
-		}
-		const gistUrl = (result.stdout || "").trim();
-		const gistId = gistUrl.split("/").pop();
-		if (!gistId) return { error: "Failed to parse gist ID." };
-		const shareUrl = `https://shittycodingagent.ai/session/?${gistId}`;
-		return { shareUrl, gistUrl };
-	} catch (err) {
-		return { error: String(err) };
-	}
-}
-
-export function writeRunLog(
-	logPath: string,
-	input: {
-		id: string;
-		mode: SubagentRunMode;
-		cwd: string;
-		startedAt: number;
-		endedAt: number;
-		steps: Array<{
-			agent: string;
-			status: string;
-			durationMs?: number;
-		}>;
-		summary: string;
-		truncated: boolean;
-		artifactsDir?: string;
-		sessionFile?: string;
-		shareUrl?: string;
-		shareError?: string;
-	},
-): void {
-	const lines: string[] = [];
-	lines.push(`# Subagent run ${input.id}`);
-	lines.push("");
-	lines.push(`- **Mode:** ${input.mode}`);
-	lines.push(`- **CWD:** ${input.cwd}`);
-	lines.push(`- **Started:** ${new Date(input.startedAt).toISOString()}`);
-	lines.push(`- **Ended:** ${new Date(input.endedAt).toISOString()}`);
-	lines.push(`- **Duration:** ${formatDuration(input.endedAt - input.startedAt)}`);
-	if (input.sessionFile) lines.push(`- **Session:** ${input.sessionFile}`);
-	if (input.shareUrl) lines.push(`- **Share:** ${input.shareUrl}`);
-	if (input.shareError) lines.push(`- **Share error:** ${input.shareError}`);
-	if (input.artifactsDir) lines.push(`- **Artifacts:** ${input.artifactsDir}`);
-	lines.push("");
-	lines.push("## Steps");
-	lines.push("| Step | Agent | Status | Duration |");
-	lines.push("| --- | --- | --- | --- |");
-	input.steps.forEach((step, i) => {
-		const duration = step.durationMs !== undefined ? formatDuration(step.durationMs) : "-";
-		lines.push(`| ${i + 1} | ${step.agent} | ${step.status} | ${duration} |`);
-	});
-	lines.push("");
-	lines.push("## Summary");
-	if (input.truncated) {
-		lines.push("_Output truncated_");
-		lines.push("");
-	}
-	lines.push(input.summary.trim() || "(no output)");
-	lines.push("");
-	fs.writeFileSync(logPath, lines.join("\n"), "utf-8");
-}