@duckmind/dm-darwin-x64 0.43.4 → 0.48.5

package/extensions/dm-subagents/src/shared/atomic-json.ts

@@ -1,86 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-type AtomicJsonFs = Pick<typeof fs, "mkdirSync" | "writeFileSync" | "renameSync" | "rmSync">;
-
-type AtomicJsonWriterOptions = {
-	fs?: AtomicJsonFs;
-	now?: () => number;
-	pid?: number;
-	random?: () => number;
-	retryRenameErrors?: boolean;
-	retryDelaysMs?: readonly number[];
-	wait?: (delayMs: number) => void;
-};
-
-const DEFAULT_RENAME_RETRY_DELAYS_MS = [10, 25, 50, 100, 200, 500, 1000, 2000, 4000] as const;
-const RETRYABLE_RENAME_ERROR_CODES = new Set(["EACCES", "EBUSY", "EPERM"]);
-const WAIT_BUFFER = typeof SharedArrayBuffer !== "undefined" ? new SharedArrayBuffer(4) : undefined;
-const WAIT_VIEW = WAIT_BUFFER ? new Int32Array(WAIT_BUFFER) : undefined;
-
-function waitSync(delayMs: number): void {
-	if (delayMs <= 0) return;
-	if (WAIT_VIEW) {
-		try {
-			// writeAtomicJson is synchronous because callers often update status from sync callbacks.
-			// Atomics.wait gives Windows rename locks time to clear without burning CPU.
-			Atomics.wait(WAIT_VIEW, 0, 0, delayMs);
-			return;
-		} catch {
-			// Fall through to the portable busy wait below.
-		}
-	}
-	const end = Date.now() + delayMs;
-	while (Date.now() < end) {
-		// Portable fallback for runtimes where Atomics.wait is unavailable.
-	}
-}
-
-function isRetryableRenameError(error: unknown): boolean {
-	const code = (error as NodeJS.ErrnoException | undefined)?.code;
-	return typeof code === "string" && RETRYABLE_RENAME_ERROR_CODES.has(code);
-}
-
-function renameWithRetry(
-	fsImpl: AtomicJsonFs,
-	sourcePath: string,
-	targetPath: string,
-	retryDelaysMs: readonly number[],
-	wait: (delayMs: number) => void,
-): void {
-	for (let attempt = 0; ; attempt++) {
-		try {
-			fsImpl.renameSync(sourcePath, targetPath);
-			return;
-		} catch (error) {
-			const delayMs = retryDelaysMs[attempt];
-			if (delayMs === undefined || !isRetryableRenameError(error)) throw error;
-			wait(delayMs);
-		}
-	}
-}
-
-export function createAtomicJsonWriter(options: AtomicJsonWriterOptions = {}): (filePath: string, payload: object) => void {
-	const fsImpl = options.fs ?? fs;
-	const now = options.now ?? Date.now;
-	const pid = options.pid ?? process.pid;
-	const random = options.random ?? Math.random;
-	const retryRenameErrors = options.retryRenameErrors ?? process.platform === "win32";
-	const retryDelaysMs = retryRenameErrors ? options.retryDelaysMs ?? DEFAULT_RENAME_RETRY_DELAYS_MS : [];
-	const wait = options.wait ?? waitSync;
-	return (filePath: string, payload: object): void => {
-		fsImpl.mkdirSync(path.dirname(filePath), { recursive: true });
-		const tempPath = path.join(
-			path.dirname(filePath),
-			`.${path.basename(filePath)}.${pid}.${now()}.${random().toString(36).slice(2)}.tmp`,
-		);
-		try {
-			fsImpl.writeFileSync(tempPath, JSON.stringify(payload, null, 2), "utf-8");
-			renameWithRetry(fsImpl, tempPath, filePath, retryDelaysMs, wait);
-		} finally {
-			fsImpl.rmSync(tempPath, { force: true });
-		}
-	};
-}
-
-export const writeAtomicJson = createAtomicJsonWriter();

package/extensions/dm-subagents/src/shared/child-transcript.ts

@@ -1,212 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { Message } from "@duckmind/dm-ai";
-import { extractTextFromContent, extractToolArgsPreview } from "./utils.ts";
-
-export const CHILD_TRANSCRIPT_ARTIFACT_VERSION = 1;
-const DEFAULT_MAX_CHILD_TRANSCRIPT_BYTES = 50 * 1024 * 1024;
-
-type ChildTranscriptSource = "foreground" | "async";
-type ChildTranscriptRecordType = "message" | "tool_start" | "tool_end" | "stdout" | "stderr" | "truncated";
-
-type ChildTranscriptMessage = Message & {
-	model?: string;
-	errorMessage?: string;
-	stopReason?: string;
-	usage?: unknown;
-};
-
-interface ChildTranscriptEvent {
-	type?: string;
-	message?: ChildTranscriptMessage;
-	toolName?: string;
-	args?: unknown;
-}
-
-interface ChildTranscriptWriterInput {
-	transcriptPath: string;
-	source: ChildTranscriptSource;
-	runId: string;
-	agent: string;
-	childIndex?: number;
-	cwd: string;
-	maxBytes?: number;
-}
-
-export interface ChildTranscriptWriter {
-	path: string;
-	writeInitialUserMessage(prompt: string): void;
-	writeChildEvent(event: ChildTranscriptEvent): void;
-	writeStdoutLine(line: string): void;
-	writeStderrLine(line: string): void;
-	writeStderrText(text: string): void;
-	getError(): string | undefined;
-}
-
-function errorMessage(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
-}
-
-function finiteNumber(value: unknown): number | undefined {
-	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-
-function normalizeUsage(value: unknown): { input: number; output: number; cacheRead: number; cacheWrite: number; cost: number } | undefined {
-	if (!value || typeof value !== "object") return undefined;
-	const raw = value as Record<string, unknown>;
-	const rawCost = raw.cost;
-	const cost = rawCost && typeof rawCost === "object"
-		? finiteNumber((rawCost as { total?: unknown }).total) ?? 0
-		: finiteNumber(rawCost) ?? 0;
-	return {
-		input: finiteNumber(raw.input) ?? finiteNumber(raw.inputTokens) ?? 0,
-		output: finiteNumber(raw.output) ?? finiteNumber(raw.outputTokens) ?? 0,
-		cacheRead: finiteNumber(raw.cacheRead) ?? 0,
-		cacheWrite: finiteNumber(raw.cacheWrite) ?? 0,
-		cost,
-	};
-}
-
-function eventArgs(event: ChildTranscriptEvent): Record<string, unknown> {
-	return event.args && typeof event.args === "object" && !Array.isArray(event.args)
-		? event.args as Record<string, unknown>
-		: {};
-}
-
-export function createChildTranscriptWriter(input: ChildTranscriptWriterInput): ChildTranscriptWriter {
-	let bytesWritten = 0;
-	let writeError: string | undefined;
-	let truncated = false;
-	const maxBytes = input.maxBytes ?? DEFAULT_MAX_CHILD_TRANSCRIPT_BYTES;
-
-	const baseRecord = (recordType: ChildTranscriptRecordType) => {
-		const ts = Date.now();
-		return {
-			version: CHILD_TRANSCRIPT_ARTIFACT_VERSION,
-			recordType,
-			source: input.source,
-			runId: input.runId,
-			agent: input.agent,
-			...(input.childIndex !== undefined ? { childIndex: input.childIndex } : {}),
-			cwd: input.cwd,
-			ts,
-			timestamp: new Date(ts).toISOString(),
-		};
-	};
-
-	const writeTruncatedMarker = () => {
-		truncated = true;
-		const marker = `${JSON.stringify({
-			...baseRecord("truncated"),
-			maxBytes,
-			message: `Child transcript exceeded ${maxBytes} bytes; further records were omitted.`,
-		})}\n`;
-		const markerBytes = Buffer.byteLength(marker, "utf-8");
-		if (bytesWritten + markerBytes > maxBytes) return false;
-		try {
-			fs.appendFileSync(input.transcriptPath, marker, "utf-8");
-			bytesWritten += markerBytes;
-			return true;
-		} catch (error) {
-			writeError = `Failed to write child transcript '${input.transcriptPath}': ${errorMessage(error)}`;
-			return false;
-		}
-	};
-
-	const writeRecord = (record: Record<string, unknown>) => {
-		if (writeError || truncated) return;
-		const line = `${JSON.stringify(record)}\n`;
-		const bytes = Buffer.byteLength(line, "utf-8");
-		if (bytesWritten + bytes > maxBytes) {
-			writeTruncatedMarker();
-			return;
-		}
-		const markerProbe = `${JSON.stringify({
-			...baseRecord("truncated"),
-			maxBytes,
-			message: `Child transcript exceeded ${maxBytes} bytes; further records were omitted.`,
-		})}\n`;
-		if (bytesWritten + bytes + Buffer.byteLength(markerProbe, "utf-8") > maxBytes) {
-			writeTruncatedMarker();
-			return;
-		}
-		try {
-			fs.appendFileSync(input.transcriptPath, line, "utf-8");
-			bytesWritten += bytes;
-		} catch (error) {
-			writeError = `Failed to write child transcript '${input.transcriptPath}': ${errorMessage(error)}`;
-		}
-	};
-
-	try {
-		fs.mkdirSync(path.dirname(input.transcriptPath), { recursive: true });
-		fs.writeFileSync(input.transcriptPath, "", "utf-8");
-	} catch (error) {
-		writeError = `Failed to initialize child transcript '${input.transcriptPath}': ${errorMessage(error)}`;
-	}
-
-	const writeMessage = (sourceEventType: string, message: ChildTranscriptMessage) => {
-		const text = extractTextFromContent(message.content);
-		writeRecord({
-			...baseRecord("message"),
-			sourceEventType,
-			role: message.role,
-			...(text ? { text } : {}),
-			...(message.model ? { model: message.model } : {}),
-			...(message.stopReason ? { stopReason: message.stopReason } : {}),
-			...(message.errorMessage ? { errorMessage: message.errorMessage } : {}),
-			...(message.usage ? { usage: normalizeUsage(message.usage) } : {}),
-			message,
-		});
-	};
-
-	return {
-		path: input.transcriptPath,
-		writeInitialUserMessage(prompt: string) {
-			writeRecord({
-				...baseRecord("message"),
-				sourceEventType: "initial_prompt",
-				role: "user",
-				text: prompt,
-				message: { role: "user", content: [{ type: "text", text: prompt }] },
-			});
-		},
-		writeChildEvent(event: ChildTranscriptEvent) {
-			if ((event.type === "message_end" || event.type === "tool_result_end") && event.message) {
-				writeMessage(event.type, event.message);
-				return;
-			}
-			if (event.type === "tool_execution_start" && event.toolName) {
-				const args = eventArgs(event);
-				writeRecord({
-					...baseRecord("tool_start"),
-					sourceEventType: event.type,
-					toolName: event.toolName,
-					...(Object.keys(args).length > 0 ? { argsPreview: extractToolArgsPreview(args) } : {}),
-				});
-				return;
-			}
-			if (event.type === "tool_execution_end") {
-				writeRecord({
-					...baseRecord("tool_end"),
-					sourceEventType: event.type,
-					...(event.toolName ? { toolName: event.toolName } : {}),
-				});
-			}
-		},
-		writeStdoutLine(line: string) {
-			if (!line.trim()) return;
-			writeRecord({ ...baseRecord("stdout"), text: line });
-		},
-		writeStderrLine(line: string) {
-			if (!line.trim()) return;
-			writeRecord({ ...baseRecord("stderr"), text: line });
-		},
-		writeStderrText(text: string) {
-			for (const line of text.split(/\r?\n/)) this.writeStderrLine(line);
-		},
-		getError() {
-			return writeError;
-		},
-	};
-}

package/extensions/dm-subagents/src/shared/file-coalescer.ts

@@ -1,40 +0,0 @@
-interface TimerApi {
-	setTimeout(handler: () => void, delayMs: number): unknown;
-	clearTimeout(handle: unknown): void;
-}
-
-interface FileCoalescer {
-	schedule(file: string, delayMs?: number): boolean;
-	clear(): void;
-}
-
-const defaultTimerApi: TimerApi = {
-	setTimeout: (handler, delayMs) => setTimeout(handler, delayMs),
-	clearTimeout: (handle) => clearTimeout(handle as ReturnType<typeof setTimeout>),
-};
-
-export function createFileCoalescer(
-	handler: (file: string) => void,
-	defaultDelayMs: number,
-	timerApi: TimerApi = defaultTimerApi,
-): FileCoalescer {
-	const pending = new Map<string, unknown>();
-
-	return {
-		schedule(file: string, delayMs = defaultDelayMs): boolean {
-			if (pending.has(file)) return false;
-			const timer = timerApi.setTimeout(() => {
-				pending.delete(file);
-				handler(file);
-			}, delayMs);
-			pending.set(file, timer);
-			return true;
-		},
-		clear(): void {
-			for (const timer of pending.values()) {
-				timerApi.clearTimeout(timer);
-			}
-			pending.clear();
-		},
-	};
-}

package/extensions/dm-subagents/src/shared/fork-context.ts

@@ -1,194 +0,0 @@
-import { randomUUID } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { SessionManager } from "@duckmind/dm-coding-agent";
-
-type SubagentExecutionContext = "fresh" | "fork";
-
-interface BranchSessionEntry {
-	type: string;
-	id?: string;
-	parentId?: string | null;
-	timestamp?: string;
-	message?: {
-		role?: string;
-		content?: unknown;
-		provider?: string;
-		api?: string;
-		model?: string;
-	};
-	thinkingLevel?: string;
-}
-
-interface BranchSessionManager {
-	createBranchedSession(leafId: string): string | undefined;
-	getHeader?: () => BranchSessionEntry | null;
-	getEntries?: () => BranchSessionEntry[];
-}
-
-interface ForkableSessionManager {
-	getSessionFile(): string | undefined;
-	getLeafId(): string | null;
-	getSessionDir?(): string;
-	createBranchedSession?(leafId: string): string | undefined;
-	getHeader?: () => BranchSessionEntry | null;
-	getEntries?: () => BranchSessionEntry[];
-	openSession?: (path: string, sessionDir?: string) => BranchSessionManager;
-}
-
-interface ForkContextResolverOptions {
-	openSession?: (path: string, sessionDir?: string) => BranchSessionManager;
-}
-
-interface ForkContextResolution {
-	sessionFile: string;
-	thinkingOverride?: "off";
-}
-
-interface ForkContextResolver {
-	sessionFileForIndex(index?: number): string | undefined;
-	thinkingOverrideForIndex(index?: number): "off" | undefined;
-}
-
-export function resolveSubagentContext(value: unknown): SubagentExecutionContext {
-	return value === "fork" ? "fork" : "fresh";
-}
-
-function isUnsafeAnthropicThinkingBlock(message: BranchSessionEntry["message"], block: unknown): boolean {
-	if (!message || !block || typeof block !== "object" || !("type" in block)) return false;
-	const provider = typeof message.provider === "string" ? message.provider.toLowerCase() : "";
-	const api = typeof message.api === "string" ? message.api.toLowerCase() : "";
-	const model = typeof message.model === "string" ? message.model.toLowerCase() : "";
-	const isAnthropic = provider === "anthropic" || api === "anthropic-messages" || model.startsWith("anthropic/");
-	if (block.type === "redacted_thinking") return true;
-	if (block.type !== "thinking" || !isAnthropic) return false;
-	const signature = "thinkingSignature" in block ? block.thinkingSignature : "signature" in block ? block.signature : undefined;
-	return block.redacted === true || (typeof signature === "string" && signature.length > 0);
-}
-
-function createEntryId(entries: BranchSessionEntry[]): string {
-	const ids = new Set(entries.map((entry) => entry.id).filter((id): id is string => typeof id === "string"));
-	for (let attempt = 0; attempt < 100; attempt++) {
-		const id = randomUUID().slice(0, 8);
-		if (!ids.has(id)) return id;
-	}
-	return randomUUID();
-}
-
-function appendThinkingOffEntry(entries: BranchSessionEntry[]): void {
-	const last = entries[entries.length - 1];
-	if (last?.type === "thinking_level_change" && last.thinkingLevel === "off") return;
-	const parent = [...entries].reverse().find((entry) => typeof entry.id === "string");
-	entries.push({
-		type: "thinking_level_change",
-		id: createEntryId(entries),
-		parentId: parent?.id ?? null,
-		timestamp: new Date().toISOString(),
-		thinkingLevel: "off",
-	});
-}
-
-function sanitizeUnsafeThinkingBlocks(entries: BranchSessionEntry[]): boolean {
-	let sanitized = false;
-	for (const entry of entries) {
-		if (entry.type !== "message" || entry.message?.role !== "assistant" || !Array.isArray(entry.message.content)) continue;
-		const filtered = entry.message.content.filter((block) => !isUnsafeAnthropicThinkingBlock(entry.message, block));
-		if (filtered.length === entry.message.content.length) continue;
-		entry.message.content = filtered;
-		sanitized = true;
-	}
-	if (sanitized) appendThinkingOffEntry(entries);
-	return sanitized;
-}
-
-function readSessionEntries(sessionFile: string): BranchSessionEntry[] {
-	const lines = fs.readFileSync(sessionFile, "utf-8").split("\n").filter((line) => line.trim().length > 0);
-	return lines.map((line, index) => {
-		try {
-			return JSON.parse(line) as BranchSessionEntry;
-		} catch (error) {
-			const cause = error instanceof Error ? error : new Error(String(error));
-			throw new Error(`Unable to inspect forked session ${sessionFile}: invalid JSONL on line ${index + 1}: ${cause.message}`, { cause });
-		}
-	});
-}
-
-export function createForkContextResolver(
-	sessionManager: ForkableSessionManager,
-	requestedContext: unknown,
-	options: ForkContextResolverOptions = {},
-): ForkContextResolver {
-	if (resolveSubagentContext(requestedContext) !== "fork") {
-		return {
-			sessionFileForIndex: () => undefined,
-			thinkingOverrideForIndex: () => undefined,
-		};
-	}
-
-	const parentSessionFile = sessionManager.getSessionFile();
-	if (!parentSessionFile) {
-		throw new Error("Forked subagent context requires a persisted parent session.");
-	}
-
-	const leafId = sessionManager.getLeafId();
-	if (!leafId) {
-		throw new Error("Forked subagent context requires a current leaf to fork from.");
-	}
-
-	const explicitOpenSession = options.openSession ?? sessionManager.openSession;
-	const liveSessionManager = typeof sessionManager.createBranchedSession === "function"
-		? sessionManager as BranchSessionManager
-		: undefined;
-	const openSession = explicitOpenSession ?? ((file: string, dir?: string) => SessionManager.open(file, dir));
-	const sessionDir = sessionManager.getSessionDir?.();
-	const cachedResolutions = new Map<number, ForkContextResolution>();
-
-	const resolveFork = (index = 0): ForkContextResolution => {
-		const cached = cachedResolutions.get(index);
-		if (cached) return cached;
-		try {
-			if (!fs.existsSync(parentSessionFile)) {
-				throw new Error(`Parent session file does not exist: ${parentSessionFile}. DM has not persisted enough history to fork yet.`);
-			}
-			const sourceManager = typeof sessionManager.createBranchedSession === "function"
-				? sessionManager as BranchSessionManager
-				: openSession(parentSessionFile, sessionDir);
-			const sessionFile = sourceManager.createBranchedSession(leafId);
-			if (!sessionFile) {
-				throw new Error("Session manager did not return a forked session file.");
-			}
-			let thinkingOverride: "off" | undefined;
-			if (!fs.existsSync(sessionFile)) {
-				const header = sourceManager.getHeader?.();
-				const entries = sourceManager.getEntries?.();
-				if (!header || !entries) {
-					throw new Error(`Session manager returned a forked session file that does not exist and cannot be persisted by fallback: ${sessionFile}`);
-				}
-				if (sanitizeUnsafeThinkingBlocks(entries)) thinkingOverride = "off";
-				fs.mkdirSync(path.dirname(sessionFile), { recursive: true });
-				fs.writeFileSync(sessionFile, `${[header, ...entries].map((entry) => JSON.stringify(entry)).join("\n")}\n`, "utf-8");
-			} else {
-				const entries = readSessionEntries(sessionFile);
-				if (sanitizeUnsafeThinkingBlocks(entries)) {
-					thinkingOverride = "off";
-					fs.writeFileSync(sessionFile, `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`, "utf-8");
-				}
-			}
-			const resolution = { sessionFile, ...(thinkingOverride ? { thinkingOverride } : {}) };
-			cachedResolutions.set(index, resolution);
-			return resolution;
-		} catch (error) {
-			const cause = error instanceof Error ? error : new Error(String(error));
-			throw new Error(`Failed to create forked subagent session: ${cause.message}`, { cause });
-		}
-	};
-
-	return {
-		sessionFileForIndex(index = 0): string | undefined {
-			return resolveFork(index).sessionFile;
-		},
-		thinkingOverrideForIndex(index = 0): "off" | undefined {
-			return resolveFork(index).thinkingOverride;
-		},
-	};
-}

package/extensions/dm-subagents/src/shared/formatters.ts

@@ -1,133 +0,0 @@
-/**
- * Formatting utilities for display output
- */
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { Usage, SingleResult } from "./types.ts";
-import type { ChainStep } from "./settings.ts";
-import { isDynamicParallelStep, isParallelStep } from "./settings.ts";
-import { splitKnownThinkingSuffix, THINKING_LEVELS } from "./model-info.ts";
-
-/**
- * Format token count with k suffix for large numbers
- */
-export function formatTokens(n: number): string {
-	return n < 1000 ? String(n) : n < 10000 ? `${(n / 1000).toFixed(1)}k` : `${Math.round(n / 1000)}k`;
-}
-
-export function formatModelThinking(model?: string, thinking?: string): string {
-	const parsed = model ? splitKnownThinkingSuffix(model) : undefined;
-	let displayModel = parsed?.baseModel ?? model;
-	const explicitThinking = THINKING_LEVELS.find((level) => level === thinking?.trim());
-	const displayThinking = parsed?.thinkingSuffix ? parsed.thinkingSuffix.slice(1) : explicitThinking;
-	if (displayModel) {
-		const slashIdx = displayModel.lastIndexOf("/");
-		if (slashIdx !== -1) displayModel = displayModel.slice(slashIdx + 1);
-	}
-	return [displayModel, displayThinking ? `thinking ${displayThinking}` : undefined].filter(Boolean).join(" · ");
-}
-
-/**
- * Format usage statistics into a compact string
- */
-export function formatUsage(u: Usage, model?: string): 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)}`);
-	if (u.output) parts.push(`out:${formatTokens(u.output)}`);
-	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(" ");
-}
-
-/**
- * Format duration in human-readable form
- */
-export function formatDuration(ms: number): string {
-	if (ms < 1000) return `${ms}ms`;
-	if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
-	return `${Math.floor(ms / 60000)}m${Math.floor((ms % 60000) / 1000)}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) r.skills.forEach((s) => allSkills.add(s));
-	}
-	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
- */
-export function formatToolCall(name: string, args: Record<string, unknown>, expanded = false): string {
-	switch (name) {
-		case "bash": {
-			const command = typeof args.command === "string" ? args.command : "";
-			const maxLength = expanded ? 240 : 60;
-			return `$ ${command.slice(0, maxLength)}${command.length > maxLength ? "..." : ""}`;
-		}
-		case "read":
-		case "write":
-		case "edit": {
-			const target = typeof args.path === "string"
-				? args.path
-				: typeof args.file_path === "string"
-					? args.file_path
-					: "";
-			return `${name} ${shortenPath(target)}`;
-		}
-		default: {
-			const s = JSON.stringify(args);
-			const maxLength = expanded ? 160 : 40;
-			return `${name} ${s.slice(0, maxLength)}${s.length > maxLength ? "..." : ""}`;
-		}
-	}
-}
-
-/**
- * Shorten a path by replacing home directory with ~
- */
-export function shortenPath(p: string): string {
-	const home = process.env.HOME;
-	if (home && p.startsWith(home)) {
-		return `~${p.slice(home.length)}`;
-	}
-	return p;
-}