@duckmind/dm-darwin-arm64 0.12.4 → 0.13.2

package/extensions/dm-subagents/chain-serializer.ts

@@ -0,0 +1,124 @@
+import type { ChainConfig, ChainStepConfig } from "./agents.ts";
+import { parseFrontmatter } from "./frontmatter.ts";
+
+function parseStepBody(agent: string, sectionBody: string): ChainStepConfig {
+	const lines = sectionBody.split("\n");
+	const blankIndex = lines.findIndex((line) => line.trim() === "");
+	const configLines = blankIndex === -1 ? lines : lines.slice(0, blankIndex);
+	const task = (blankIndex === -1 ? "" : lines.slice(blankIndex + 1).join("\n")).trim();
+
+	const step: ChainStepConfig = { agent, task };
+	for (const line of configLines) {
+		const match = line.match(/^([\w-]+):\s*(.*)$/);
+		if (!match) continue;
+		const key = match[1].trim().toLowerCase();
+		const rawValue = match[2].trim();
+
+		if (key === "output") {
+			if (rawValue === "false") step.output = false;
+			else if (rawValue) step.output = rawValue;
+			continue;
+		}
+		if (key === "reads") {
+			if (rawValue === "false") {
+				step.reads = false;
+			} else {
+				const reads = rawValue
+					.split(",")
+					.map((v) => v.trim())
+					.filter(Boolean);
+				step.reads = reads.length > 0 ? reads : false;
+			}
+			continue;
+		}
+		if (key === "model") {
+			if (rawValue) step.model = rawValue;
+			continue;
+		}
+		if (key === "skills") {
+			if (rawValue === "false") {
+				step.skills = false;
+			} else {
+				const skills = rawValue
+					.split(",")
+					.map((v) => v.trim())
+					.filter(Boolean);
+				step.skills = skills.length > 0 ? skills : false;
+			}
+			continue;
+		}
+		if (key === "progress") {
+			if (rawValue === "true") step.progress = true;
+			else if (rawValue === "false") step.progress = false;
+		}
+	}
+
+	return step;
+}
+
+export function parseChain(content: string, source: "user" | "project", filePath: string): ChainConfig {
+	const { frontmatter, body } = parseFrontmatter(content);
+	if (!frontmatter.name || !frontmatter.description) {
+		throw new Error("Chain frontmatter must include name and description");
+	}
+
+	const matches = [...body.matchAll(/^##\s+(.+)[^\S\n]*$/gm)];
+	const steps: ChainStepConfig[] = [];
+
+	for (let i = 0; i < matches.length; i++) {
+		const match = matches[i]!;
+		const agent = match[1]!.trim();
+		const lineEndOffset = body[match.index! + match[0].length] === "\n" ? 1 : 0;
+		const sectionStart = match.index! + match[0].length + lineEndOffset;
+		const sectionEnd = i + 1 < matches.length ? matches[i + 1]!.index! : body.length;
+		const sectionBody = body.slice(sectionStart, sectionEnd).trimEnd();
+		steps.push(parseStepBody(agent, sectionBody));
+	}
+
+	const extraFields: Record<string, string> = {};
+	for (const [key, value] of Object.entries(frontmatter)) {
+		if (key === "name" || key === "description") continue;
+		extraFields[key] = value;
+	}
+
+	return {
+		name: frontmatter.name,
+		description: frontmatter.description,
+		source,
+		filePath,
+		steps,
+		extraFields: Object.keys(extraFields).length > 0 ? extraFields : undefined,
+	};
+}
+
+export function serializeChain(config: ChainConfig): string {
+	const lines: string[] = [];
+	lines.push("---");
+	lines.push(`name: ${config.name}`);
+	lines.push(`description: ${config.description}`);
+	if (config.extraFields) {
+		for (const [key, value] of Object.entries(config.extraFields)) {
+			lines.push(`${key}: ${value}`);
+		}
+	}
+	lines.push("---");
+	lines.push("");
+
+	for (let i = 0; i < config.steps.length; i++) {
+		const step = config.steps[i]!;
+		lines.push(`## ${step.agent}`);
+		if (step.output === false) lines.push("output: false");
+		else if (step.output) lines.push(`output: ${step.output}`);
+		if (step.reads === false) lines.push("reads: false");
+		else if (Array.isArray(step.reads) && step.reads.length > 0) lines.push(`reads: ${step.reads.join(", ")}`);
+		if (step.model) lines.push(`model: ${step.model}`);
+		if (step.skills === false) lines.push("skills: false");
+		else if (Array.isArray(step.skills) && step.skills.length > 0) lines.push(`skills: ${step.skills.join(", ")}`);
+		if (step.progress !== undefined) lines.push(`progress: ${step.progress ? "true" : "false"}`);
+		lines.push("");
+		lines.push(step.task ?? "");
+		if (i < config.steps.length - 1) lines.push("");
+	}
+
+	return `${lines.join("\n")}\n`;
+}

package/extensions/dm-subagents/completion-dedupe.ts

@@ -0,0 +1,63 @@
+interface CompletionDataLike {
+	id?: unknown;
+	agent?: unknown;
+	timestamp?: unknown;
+	sessionId?: unknown;
+	taskIndex?: unknown;
+	totalTasks?: unknown;
+	success?: unknown;
+}
+
+function asNonEmptyString(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function asFiniteNumber(value: unknown): number | undefined {
+	if (typeof value !== "number") return undefined;
+	return Number.isFinite(value) ? value : undefined;
+}
+
+export function buildCompletionKey(data: CompletionDataLike, fallback: string): string {
+	const id = asNonEmptyString(data.id);
+	if (id) return `id:${id}`;
+	const sessionId = asNonEmptyString(data.sessionId) ?? "no-session";
+	const agent = asNonEmptyString(data.agent) ?? "unknown";
+	const timestamp = asFiniteNumber(data.timestamp);
+	const taskIndex = asFiniteNumber(data.taskIndex);
+	const totalTasks = asFiniteNumber(data.totalTasks);
+	const success = typeof data.success === "boolean" ? (data.success ? "1" : "0") : "?";
+	return [
+		"meta",
+		sessionId,
+		agent,
+		timestamp !== undefined ? String(timestamp) : "no-ts",
+		taskIndex !== undefined ? String(taskIndex) : "-",
+		totalTasks !== undefined ? String(totalTasks) : "-",
+		success,
+		fallback,
+	].join(":");
+}
+
+export function pruneSeenMap(seen: Map<string, number>, now: number, ttlMs: number): void {
+	for (const [key, ts] of seen.entries()) {
+		if (now - ts > ttlMs) seen.delete(key);
+	}
+}
+
+export function markSeenWithTtl(seen: Map<string, number>, key: string, now: number, ttlMs: number): boolean {
+	pruneSeenMap(seen, now, ttlMs);
+	if (seen.has(key)) return true;
+	seen.set(key, now);
+	return false;
+}
+
+export function getGlobalSeenMap(storeKey: string): Map<string, number> {
+	const globalStore = globalThis as Record<string, unknown>;
+	const existing = globalStore[storeKey];
+	if (existing instanceof Map) return existing as Map<string, number>;
+	const map = new Map<string, number>();
+	globalStore[storeKey] = map;
+	return map;
+}

package/extensions/dm-subagents/execution.ts

@@ -0,0 +1,507 @@
+/**
+ * Core execution logic for running subagents
+ */
+
+import { spawn } from "node:child_process";
+import type { Message } from "@mariozechner/pi-ai";
+import type { AgentConfig } from "./agents.ts";
+import {
+	ensureArtifactsDir,
+	getArtifactPaths,
+	writeArtifact,
+	writeMetadata,
+} from "./artifacts.ts";
+import {
+	type AgentProgress,
+	type ArtifactPaths,
+	type ModelAttempt,
+	type RunSyncOptions,
+	type SingleResult,
+	type Usage,
+	DEFAULT_MAX_OUTPUT,
+	INTERCOM_DETACH_REQUEST_EVENT,
+	INTERCOM_DETACH_RESPONSE_EVENT,
+	truncateOutput,
+	getSubagentDepthEnv,
+} from "./types.ts";
+import {
+	getFinalOutput,
+	findLatestSessionFile,
+	detectSubagentError,
+	extractToolArgsPreview,
+	extractTextFromContent,
+} from "./utils.ts";
+import { buildSkillInjection, resolveSkills } from "./skills.ts";
+import { getPiSpawnCommand } from "./pi-spawn.ts";
+import { createJsonlWriter } from "./jsonl-writer.ts";
+import { applyThinkingSuffix, buildPiArgs, cleanupTempDir } from "./pi-args.ts";
+import { captureSingleOutputSnapshot, resolveSingleOutput, type SingleOutputSnapshot } from "./single-output.ts";
+import {
+	buildModelCandidates,
+	formatModelAttemptNote,
+	isRetryableModelFailure,
+} from "./model-fallback.ts";
+
+function emptyUsage(): Usage {
+	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
+}
+
+function sumUsage(target: Usage, source: Usage): void {
+	target.input += source.input;
+	target.output += source.output;
+	target.cacheRead += source.cacheRead;
+	target.cacheWrite += source.cacheWrite;
+	target.cost += source.cost;
+	target.turns += source.turns;
+}
+
+function appendRecentOutput(progress: AgentProgress, lines: string[]): void {
+	if (lines.length === 0) return;
+	progress.recentOutput.push(...lines.filter((line) => line.trim()));
+	if (progress.recentOutput.length > 50) {
+		progress.recentOutput.splice(0, progress.recentOutput.length - 50);
+	}
+}
+
+async function runSingleAttempt(
+	runtimeCwd: string,
+	agent: AgentConfig,
+	task: string,
+	model: string | undefined,
+	options: RunSyncOptions,
+	shared: {
+		sessionEnabled: boolean;
+		systemPrompt: string;
+		skillNames: string[];
+		resolvedSkillNames?: string[];
+		skillsWarning?: string;
+		jsonlPath?: string;
+		attemptNotes: string[];
+		outputSnapshot?: SingleOutputSnapshot;
+	},
+): Promise<SingleResult> {
+	const modelArg = applyThinkingSuffix(model, agent.thinking);
+	const { args, env: sharedEnv, tempDir } = buildPiArgs({
+		baseArgs: ["--mode", "json", "-p"],
+		task,
+		sessionEnabled: shared.sessionEnabled,
+		sessionDir: options.sessionDir,
+		sessionFile: options.sessionFile,
+		model,
+		thinking: agent.thinking,
+		tools: agent.tools,
+		extensions: agent.extensions,
+		skills: shared.skillNames,
+		systemPrompt: shared.systemPrompt,
+		mcpDirectTools: agent.mcpDirectTools,
+		promptFileStem: agent.name,
+	});
+
+	const result: SingleResult = {
+		agent: agent.name,
+		task,
+		exitCode: 0,
+		messages: [],
+		usage: emptyUsage(),
+		model: modelArg,
+		skills: shared.resolvedSkillNames,
+		skillsWarning: shared.skillsWarning,
+	};
+
+	const progress: AgentProgress = {
+		index: options.index ?? 0,
+		agent: agent.name,
+		status: "running",
+		task,
+		skills: shared.resolvedSkillNames,
+		recentTools: [],
+		recentOutput: [...shared.attemptNotes],
+		toolCount: 0,
+		tokens: 0,
+		durationMs: 0,
+	};
+	result.progress = progress;
+
+	const startTime = Date.now();
+	const spawnEnv = { ...process.env, ...sharedEnv, ...getSubagentDepthEnv(options.maxSubagentDepth) };
+
+	const exitCode = await new Promise<number>((resolve) => {
+		const spawnSpec = getPiSpawnCommand(args);
+		const proc = spawn(spawnSpec.command, spawnSpec.args, {
+			cwd: options.cwd ?? runtimeCwd,
+			env: spawnEnv,
+			stdio: ["ignore", "pipe", "pipe"],
+		});
+		const jsonlWriter = createJsonlWriter(shared.jsonlPath, proc.stdout);
+		let buf = "";
+		let processClosed = false;
+		let settled = false;
+		let detached = false;
+		let intercomStarted = false;
+		let removeAbortListener: (() => void) | undefined;
+
+		const detachForIntercom = () => {
+			detached = true;
+			processClosed = true;
+			result.detached = true;
+			result.detachedReason = "intercom coordination";
+			progress.status = "detached";
+			progress.durationMs = Date.now() - startTime;
+			result.progressSummary = {
+				toolCount: progress.toolCount,
+				tokens: progress.tokens,
+				durationMs: progress.durationMs,
+			};
+			finish(-2);
+		};
+
+		const unsubscribeIntercomDetach = options.intercomEvents?.on(INTERCOM_DETACH_REQUEST_EVENT, (payload) => {
+			if (!options.allowIntercomDetach || detached || processClosed) return;
+			if (!payload || typeof payload !== "object") return;
+			const requestId = (payload as { requestId?: unknown }).requestId;
+			if (typeof requestId !== "string" || requestId.length === 0) return;
+			const accepted = intercomStarted;
+			options.intercomEvents?.emit(INTERCOM_DETACH_RESPONSE_EVENT, { requestId, accepted });
+			if (!accepted) return;
+			detachForIntercom();
+		});
+
+		const finish = (code: number) => {
+			if (settled) return;
+			settled = true;
+			unsubscribeIntercomDetach?.();
+			removeAbortListener?.();
+			resolve(code);
+		};
+
+		const fireUpdate = () => {
+			if (!options.onUpdate || processClosed) return;
+			progress.durationMs = Date.now() - startTime;
+			options.onUpdate({
+				content: [{ type: "text", text: getFinalOutput(result.messages) || "(running...)" }],
+				details: { mode: "single", results: [result], progress: [progress] },
+			});
+		};
+
+		const processLine = (line: string) => {
+			if (!line.trim()) return;
+			jsonlWriter.writeLine(line);
+			try {
+				const evt = JSON.parse(line) as { type?: string; message?: Message; toolName?: string; args?: unknown };
+				const now = Date.now();
+				progress.durationMs = now - startTime;
+
+				if (evt.type === "tool_execution_start") {
+					if (options.allowIntercomDetach && evt.toolName === "intercom") {
+						intercomStarted = true;
+					}
+					progress.toolCount++;
+					progress.currentTool = evt.toolName;
+					progress.currentToolArgs = extractToolArgsPreview((evt.args || {}) as Record<string, unknown>);
+					fireUpdate();
+				}
+
+				if (evt.type === "tool_execution_end") {
+					if (progress.currentTool) {
+						progress.recentTools.push({
+							tool: progress.currentTool,
+							args: progress.currentToolArgs || "",
+							endMs: now,
+						});
+					}
+					progress.currentTool = undefined;
+					progress.currentToolArgs = undefined;
+					fireUpdate();
+				}
+
+				if (evt.type === "message_end" && evt.message) {
+					result.messages.push(evt.message);
+					if (evt.message.role === "assistant") {
+						result.usage.turns++;
+						const u = evt.message.usage;
+						if (u) {
+							result.usage.input += u.input || 0;
+							result.usage.output += u.output || 0;
+							result.usage.cacheRead += u.cacheRead || 0;
+							result.usage.cacheWrite += u.cacheWrite || 0;
+							result.usage.cost += u.cost?.total || 0;
+							progress.tokens = result.usage.input + result.usage.output;
+						}
+						if (!result.model && evt.message.model) result.model = evt.message.model;
+						if (evt.message.errorMessage) result.error = evt.message.errorMessage;
+						appendRecentOutput(progress, extractTextFromContent(evt.message.content).split("\n").slice(-10));
+					}
+					fireUpdate();
+				}
+
+				if (evt.type === "tool_result_end" && evt.message) {
+					result.messages.push(evt.message);
+					appendRecentOutput(progress, extractTextFromContent(evt.message.content).split("\n").slice(-10));
+					fireUpdate();
+				}
+			} catch {
+				// Non-JSON stdout lines are expected; only structured events are parsed.
+			}
+		};
+
+		let stderrBuf = "";
+
+		proc.stdout.on("data", (d) => {
+			buf += d.toString();
+			const lines = buf.split("\n");
+			buf = lines.pop() || "";
+			lines.forEach(processLine);
+		});
+		proc.stderr.on("data", (d) => {
+			stderrBuf += d.toString();
+		});
+		proc.on("close", (code) => {
+			void jsonlWriter.close().catch(() => {
+				// JSONL artifact flush is best effort.
+			});
+			cleanupTempDir(tempDir);
+			if (detached) {
+				finish(-2);
+				return;
+			}
+			processClosed = true;
+			if (buf.trim()) processLine(buf);
+			if (code !== 0 && stderrBuf.trim() && !result.error) {
+				result.error = stderrBuf.trim();
+			}
+			finish(code ?? 0);
+		});
+		proc.on("error", (error) => {
+			void jsonlWriter.close().catch(() => {
+				// JSONL artifact flush is best effort.
+			});
+			cleanupTempDir(tempDir);
+			if (!result.error) {
+				result.error = error instanceof Error ? error.message : String(error);
+			}
+			finish(1);
+		});
+
+		if (options.signal) {
+			const kill = () => {
+				if (processClosed || detached) return;
+				if (options.allowIntercomDetach && intercomStarted && !detached) {
+					detachForIntercom();
+					return;
+				}
+				proc.kill("SIGTERM");
+				setTimeout(() => !proc.killed && proc.kill("SIGKILL"), 3000);
+			};
+			if (options.signal.aborted) kill();
+			else {
+				options.signal.addEventListener("abort", kill, { once: true });
+				removeAbortListener = () => options.signal?.removeEventListener("abort", kill);
+			}
+		}
+	});
+	result.exitCode = exitCode;
+	if (result.detached) {
+		result.exitCode = 0;
+		result.finalOutput = "Detached for intercom coordination.";
+		return result;
+	}
+
+	if (exitCode === 0 && !result.error) {
+		const errInfo = detectSubagentError(result.messages);
+		if (errInfo.hasError) {
+			result.exitCode = errInfo.exitCode ?? 1;
+			result.error = errInfo.details
+				? `${errInfo.errorType} failed (exit ${errInfo.exitCode}): ${errInfo.details}`
+				: `${errInfo.errorType} failed with exit code ${errInfo.exitCode}`;
+		}
+	}
+
+	progress.status = result.exitCode === 0 ? "completed" : "failed";
+	progress.durationMs = Date.now() - startTime;
+	if (result.error) {
+		progress.error = result.error;
+		if (progress.currentTool) {
+			progress.failedTool = progress.currentTool;
+		}
+	}
+
+	result.progressSummary = {
+		toolCount: progress.toolCount,
+		tokens: progress.tokens,
+		durationMs: progress.durationMs,
+	};
+
+	let fullOutput = getFinalOutput(result.messages);
+	if (options.outputPath && result.exitCode === 0) {
+		const resolvedOutput = resolveSingleOutput(options.outputPath, fullOutput, shared.outputSnapshot);
+		fullOutput = resolvedOutput.fullOutput;
+		result.savedOutputPath = resolvedOutput.savedPath;
+		result.outputSaveError = resolvedOutput.saveError;
+	}
+	result.finalOutput = fullOutput;
+	return result;
+}
+
+/**
+ * Run a subagent synchronously (blocking until complete)
+ */
+export async function runSync(
+	runtimeCwd: string,
+	agents: AgentConfig[],
+	agentName: string,
+	task: string,
+	options: RunSyncOptions,
+): Promise<SingleResult> {
+	const agent = agents.find((a) => a.name === agentName);
+	if (!agent) {
+		return {
+			agent: agentName,
+			task,
+			exitCode: 1,
+			messages: [],
+			usage: emptyUsage(),
+			error: `Unknown agent: ${agentName}`,
+		};
+	}
+
+	const shareEnabled = options.share === true;
+	const sessionEnabled = Boolean(options.sessionFile || options.sessionDir) || shareEnabled;
+	const outputSnapshot = captureSingleOutputSnapshot(options.outputPath);
+	const skillNames = options.skills ?? agent.skills ?? [];
+	const { resolved: resolvedSkills, missing: missingSkills } = resolveSkills(skillNames, runtimeCwd);
+	let systemPrompt = agent.systemPrompt?.trim() || "";
+	if (resolvedSkills.length > 0) {
+		const skillInjection = buildSkillInjection(resolvedSkills);
+		systemPrompt = systemPrompt ? `${systemPrompt}\n\n${skillInjection}` : skillInjection;
+	}
+
+	const candidates = buildModelCandidates(
+		options.modelOverride ?? agent.model,
+		agent.fallbackModels,
+		options.availableModels,
+	);
+	const attemptedModels: string[] = [];
+	const modelAttempts: ModelAttempt[] = [];
+	const aggregateUsage = emptyUsage();
+	const attemptNotes: string[] = [];
+	let totalToolCount = 0;
+	let totalDurationMs = 0;
+
+	let artifactPathsResult: ArtifactPaths | undefined;
+	let jsonlPath: string | undefined;
+	if (options.artifactsDir && options.artifactConfig?.enabled !== false) {
+		artifactPathsResult = getArtifactPaths(options.artifactsDir, options.runId, agentName, options.index);
+		ensureArtifactsDir(options.artifactsDir);
+		if (options.artifactConfig?.includeInput !== false) {
+			writeArtifact(artifactPathsResult.inputPath, `# Task for ${agentName}\n\n${task}`);
+		}
+		if (options.artifactConfig?.includeJsonl !== false) {
+			jsonlPath = artifactPathsResult.jsonlPath;
+		}
+	}
+
+	let lastResult: SingleResult | undefined;
+	const modelsToTry = candidates.length > 0 ? candidates : [undefined];
+	for (let i = 0; i < modelsToTry.length; i++) {
+		const candidate = modelsToTry[i];
+		if (candidate) attemptedModels.push(candidate);
+		const result = await runSingleAttempt(runtimeCwd, agent, task, candidate, options, {
+			sessionEnabled,
+			systemPrompt,
+			skillNames,
+			resolvedSkillNames: resolvedSkills.length > 0 ? resolvedSkills.map((skill) => skill.name) : undefined,
+			skillsWarning: missingSkills.length > 0 ? `Skills not found: ${missingSkills.join(", ")}` : undefined,
+			jsonlPath,
+			attemptNotes,
+			outputSnapshot,
+		});
+		lastResult = result;
+		sumUsage(aggregateUsage, result.usage);
+		totalToolCount += result.progressSummary?.toolCount ?? 0;
+		totalDurationMs += result.progressSummary?.durationMs ?? 0;
+		const attempt: ModelAttempt = {
+			model: candidate ?? result.model ?? agent.model ?? "default",
+			success: result.exitCode === 0,
+			exitCode: result.exitCode,
+			error: result.error,
+			usage: { ...result.usage },
+		};
+		modelAttempts.push(attempt);
+		if (result.exitCode === 0) {
+			break;
+		}
+		if (!isRetryableModelFailure(result.error) || i === modelsToTry.length - 1) {
+			break;
+		}
+		attemptNotes.push(formatModelAttemptNote(attempt, modelsToTry[i + 1]));
+	}
+
+	const result = lastResult ?? {
+		agent: agentName,
+		task,
+		exitCode: 1,
+		messages: [],
+		usage: emptyUsage(),
+		error: "Subagent did not produce a result.",
+	} satisfies SingleResult;
+
+	result.usage = aggregateUsage;
+	result.attemptedModels = attemptedModels.length > 0 ? attemptedModels : undefined;
+	result.modelAttempts = modelAttempts.length > 0 ? modelAttempts : undefined;
+	result.progressSummary = {
+		toolCount: totalToolCount,
+		tokens: aggregateUsage.input + aggregateUsage.output,
+		durationMs: totalDurationMs,
+	};
+	if (attemptNotes.length > 0 && result.progress) {
+		result.progress.recentOutput = [...attemptNotes, ...result.progress.recentOutput];
+		if (result.progress.recentOutput.length > 50) {
+			result.progress.recentOutput.splice(50);
+		}
+	}
+
+	if (artifactPathsResult && options.artifactConfig?.enabled !== false) {
+		result.artifactPaths = artifactPathsResult;
+		if (options.artifactConfig?.includeOutput !== false) {
+			writeArtifact(artifactPathsResult.outputPath, result.finalOutput ?? "");
+		}
+		if (options.artifactConfig?.includeMetadata !== false) {
+			writeMetadata(artifactPathsResult.metadataPath, {
+				runId: options.runId,
+				agent: agentName,
+				task,
+				exitCode: result.exitCode,
+				usage: result.usage,
+				model: result.model,
+				attemptedModels: result.attemptedModels,
+				modelAttempts: result.modelAttempts,
+				durationMs: result.progressSummary?.durationMs,
+				toolCount: result.progressSummary?.toolCount,
+				error: result.error,
+				skills: result.skills,
+				skillsWarning: result.skillsWarning,
+				timestamp: Date.now(),
+			});
+		}
+
+		if (options.maxOutput) {
+			const config = { ...DEFAULT_MAX_OUTPUT, ...options.maxOutput };
+			const truncationResult = truncateOutput(result.finalOutput ?? "", config, artifactPathsResult.outputPath);
+			if (truncationResult.truncated) result.truncation = truncationResult;
+		}
+	} else if (options.maxOutput) {
+		const config = { ...DEFAULT_MAX_OUTPUT, ...options.maxOutput };
+		const truncationResult = truncateOutput(result.finalOutput ?? "", config);
+		if (truncationResult.truncated) result.truncation = truncationResult;
+	}
+
+	if (shareEnabled) {
+		const sessionFile = options.sessionFile
+			?? (options.sessionDir ? findLatestSessionFile(options.sessionDir) : null);
+		if (sessionFile) {
+			result.sessionFile = sessionFile;
+		}
+	}
+
+	return result;
+}