@duckmind/dm-darwin-x64 0.43.2 → 0.43.8

package/extensions/dm-subagents/src/runs/shared/nested-path.ts

@@ -1,52 +0,0 @@
-import * as path from "node:path";
-
-const MAX_NESTED_ID_LENGTH = 128;
-export const MAX_NESTED_PATH_ENTRIES = 4;
-
-export type NestedPathEntry = { runId: string; stepIndex?: number; agent?: string };
-
-export function isSafeNestedPathId(value: unknown): value is string {
-	return typeof value === "string"
-		&& value.length > 0
-		&& value.length <= MAX_NESTED_ID_LENGTH
-		&& !path.isAbsolute(value)
-		&& !value.includes("/")
-		&& !value.includes("\\")
-		&& !value.includes("..");
-}
-
-function finiteNumber(value: unknown): number | undefined {
-	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-
-function nonEmptyString(value: unknown, max: number): string | undefined {
-	return typeof value === "string" && value.length > 0 ? value.slice(0, max) : undefined;
-}
-
-export function sanitizeNestedPath(value: unknown): NestedPathEntry[] {
-	if (!Array.isArray(value)) return [];
-	return value.map((part) => {
-		if (!part || typeof part !== "object") return undefined;
-		const record = part as Record<string, unknown>;
-		if (!isSafeNestedPathId(record.runId)) return undefined;
-		return {
-			runId: record.runId,
-			...(finiteNumber(record.stepIndex) !== undefined ? { stepIndex: finiteNumber(record.stepIndex) } : {}),
-			...(nonEmptyString(record.agent, 128) ? { agent: nonEmptyString(record.agent, 128) } : {}),
-		};
-	}).filter((part): part is NestedPathEntry => Boolean(part)).slice(0, MAX_NESTED_PATH_ENTRIES);
-}
-
-export function parseNestedPathEnv(value: string | undefined): NestedPathEntry[] {
-	if (!value) return [];
-	try {
-		return sanitizeNestedPath(JSON.parse(value) as unknown);
-	} catch {
-		return [];
-	}
-}
-
-export function encodeNestedPathEnv(value: NestedPathEntry[]): string {
-	const sanitized = sanitizeNestedPath(value);
-	return sanitized.length ? JSON.stringify(sanitized) : "";
-}

package/extensions/dm-subagents/src/runs/shared/nested-render.ts

@@ -1,115 +0,0 @@
-import { formatDuration, formatTokens, shortenPath } from "../../shared/formatters.ts";
-import { formatActivityLabel } from "../../shared/status-format.ts";
-import type { ActivityState, NestedRunSummary, NestedStepSummary } from "../../shared/types.ts";
-
-export interface NestedRunCounts {
-	total: number;
-	running: number;
-	paused: number;
-	complete: number;
-	failed: number;
-	queued: number;
-}
-
-export function countNestedRuns(children: NestedRunSummary[] | undefined): NestedRunCounts {
-	const counts: NestedRunCounts = { total: 0, running: 0, paused: 0, complete: 0, failed: 0, queued: 0 };
-	for (const child of children ?? []) {
-		counts.total++;
-		counts[child.state]++;
-		const nested = countNestedRuns([...(child.children ?? []), ...(child.steps?.flatMap((step) => step.children ?? []) ?? [])]);
-		counts.total += nested.total;
-		counts.running += nested.running;
-		counts.paused += nested.paused;
-		counts.complete += nested.complete;
-		counts.failed += nested.failed;
-		counts.queued += nested.queued;
-	}
-	return counts;
-}
-
-export function formatNestedAggregate(children: NestedRunSummary[] | undefined): string | undefined {
-	const counts = countNestedRuns(children);
-	if (counts.total === 0) return undefined;
-	const parts = [
-		counts.running > 0 ? `${counts.running} running` : "",
-		counts.paused > 0 ? `${counts.paused} paused` : "",
-		counts.failed > 0 ? `${counts.failed} failed` : "",
-		counts.complete > 0 ? `${counts.complete} complete` : "",
-		counts.queued > 0 ? `${counts.queued} queued` : "",
-	].filter(Boolean);
-	return `+${counts.total} nested run${counts.total === 1 ? "" : "s"}${parts.length ? ` (${parts.join(", ")})` : ""}`;
-}
-
-function nestedRunLabel(run: NestedRunSummary): string {
-	if (run.agent) return run.agent;
-	if (run.agents?.length) return run.agents.length === 1 ? run.agents[0]! : `${run.agents.slice(0, 2).join(", ")}${run.agents.length > 2 ? ` +${run.agents.length - 2}` : ""}`;
-	return run.id;
-}
-
-function formatNestedActivity(input: {
-	activityState?: ActivityState;
-	lastActivityAt?: number;
-	currentTool?: string;
-	currentToolStartedAt?: number;
-	currentPath?: string;
-	turnCount?: number;
-	toolCount?: number;
-	totalTokens?: NestedRunSummary["totalTokens"];
-}): string | undefined {
-	const facts: string[] = [];
-	if (input.currentTool && input.currentToolStartedAt !== undefined) facts.push(`tool ${input.currentTool} ${formatDuration(Math.max(0, Date.now() - input.currentToolStartedAt))}`);
-	else if (input.currentTool) facts.push(`tool ${input.currentTool}`);
-	if (input.currentPath) facts.push(shortenPath(input.currentPath));
-	if (input.turnCount !== undefined) facts.push(`${input.turnCount} turns`);
-	if (input.toolCount !== undefined) facts.push(`${input.toolCount} tools`);
-	if (input.totalTokens) facts.push(`${formatTokens(input.totalTokens.total)} tok`);
-	const activity = formatActivityLabel(input.lastActivityAt, input.activityState as ActivityState | undefined);
-	return activity || facts.length ? [activity, ...facts].filter(Boolean).join(" | ") : undefined;
-}
-
-function formatNestedRunLines(children: NestedRunSummary[] | undefined, options: { indent: string; maxDepth: number; maxLines: number; commandHints?: boolean }): string[] {
-	const lines: string[] = [];
-	const append = (items: NestedRunSummary[] | undefined, depth: number, indent: string): void => {
-		if (!items?.length || lines.length >= options.maxLines) return;
-		if (depth > options.maxDepth) {
-			const aggregate = formatNestedAggregate(items);
-			if (aggregate && lines.length < options.maxLines) lines.push(`${indent}↳ ${aggregate}`);
-			return;
-		}
-		for (let index = 0; index < items.length; index++) {
-			const child = items[index]!;
-			if (lines.length >= options.maxLines) {
-				const aggregate = formatNestedAggregate(items.slice(index));
-				if (aggregate) lines[lines.length - 1] = `${indent}↳ ${aggregate}`;
-				return;
-			}
-			const activity = child.state === "running" ? formatNestedActivity(child) : undefined;
-			const error = child.error ? ` | error: ${child.error}` : "";
-			lines.push(`${indent}↳ ${nestedRunLabel(child)} [${child.id}] ${child.state}${activity ? ` | ${activity}` : ""}${error}`);
-			if (options.commandHints && lines.length < options.maxLines) lines.push(`${indent}  Status: subagent({ action: "status", id: "${child.id}" })`);
-			if (depth === options.maxDepth) {
-				const aggregate = formatNestedAggregate([...(child.steps?.flatMap((step) => step.children ?? []) ?? []), ...(child.children ?? [])]);
-				if (aggregate && lines.length < options.maxLines) lines.push(`${indent}  ↳ ${aggregate}`);
-				continue;
-			}
-			for (const [stepIndex, step] of (child.steps ?? []).entries()) {
-				if (lines.length >= options.maxLines) return;
-				const stepActivity = step.status === "running" ? formatNestedActivity(step) : undefined;
-				lines.push(`${indent}  ${stepIndex + 1}. ${step.agent} ${step.status}${stepActivity ? ` | ${stepActivity}` : ""}${step.error ? ` | error: ${step.error}` : ""}`);
-				append(step.children, depth + 1, `${indent}    `);
-			}
-			append(child.children, depth + 1, `${indent}  `);
-		}
-	};
-	append(children, 0, options.indent);
-	return lines;
-}
-
-export function formatNestedRunStatusLines(children: NestedRunSummary[] | undefined, options: { indent?: string; maxDepth?: number; maxLines?: number; commandHints?: boolean } = {}): string[] {
-	return formatNestedRunLines(children, {
-		indent: options.indent ?? "  ",
-		maxDepth: options.maxDepth ?? 2,
-		maxLines: options.maxLines ?? 40,
-		commandHints: options.commandHints ?? false,
-	});
-}

package/extensions/dm-subagents/src/runs/shared/parallel-utils.ts

@@ -1,198 +0,0 @@
-export interface RunnerSubagentStep {
-	/** Session id of the direct parent session for permission-system ask forwarding. */
-	parentSessionId?: string;
-	agent: string;
-	task: string;
-	importAsyncRoot?: {
-		runId: string;
-		asyncDir: string;
-		resultPath: string;
-		index: number;
-	};
-	phase?: string;
-	label?: string;
-	outputName?: string;
-	structured?: boolean;
-	cwd?: string;
-	model?: string;
-	thinking?: string;
-	modelCandidates?: string[];
-	tools?: string[];
-	extensions?: string[];
-	subagentOnlyExtensions?: string[];
-	mcpDirectTools?: string[];
-	completionGuard?: boolean;
-	systemPrompt?: string | null;
-	systemPromptMode?: "append" | "replace";
-	inheritProjectContext: boolean;
-	inheritSkills: boolean;
-	skills?: string[];
-	outputPath?: string;
-	outputMode?: "inline" | "file-only";
-	sessionFile?: string;
-	maxSubagentDepth?: number;
-	structuredOutput?: {
-		schema: import("../../shared/types.ts").JsonSchemaObject;
-		schemaPath: string;
-		outputPath: string;
-	};
-	structuredOutputSchema?: import("../../shared/types.ts").JsonSchemaObject;
-	effectiveAcceptance?: import("../../shared/types.ts").ResolvedAcceptanceConfig;
-	toolBudget?: import("../../shared/types.ts").ResolvedToolBudget;
-}
-
-export interface ParallelStepGroup {
-	parallel: RunnerSubagentStep[];
-	concurrency?: number;
-	failFast?: boolean;
-	worktree?: boolean;
-}
-
-export interface DynamicRunnerGroup {
-	expand: import("../../shared/settings.ts").DynamicExpandSpec;
-	parallel: RunnerSubagentStep;
-	collect: import("../../shared/settings.ts").DynamicCollectSpec;
-	concurrency?: number;
-	failFast?: boolean;
-	phase?: string;
-	label?: string;
-	sessionFiles?: (string | undefined)[];
-	thinkingOverrides?: (string | undefined)[];
-	effectiveAcceptance?: import("../../shared/types.ts").ResolvedAcceptanceConfig;
-}
-
-export type RunnerStep = RunnerSubagentStep | ParallelStepGroup | DynamicRunnerGroup;
-
-export function isParallelGroup(step: RunnerStep): step is ParallelStepGroup {
-	return "parallel" in step && Array.isArray(step.parallel);
-}
-
-export function isDynamicRunnerGroup(step: RunnerStep): step is DynamicRunnerGroup {
-	return "expand" in step && "collect" in step && "parallel" in step && !Array.isArray((step as { parallel?: unknown }).parallel);
-}
-
-export function flattenSteps(steps: RunnerStep[]): RunnerSubagentStep[] {
-	const flat: RunnerSubagentStep[] = [];
-	for (const step of steps) {
-		if (isParallelGroup(step)) {
-			for (const task of step.parallel) flat.push(task);
-		} else if (isDynamicRunnerGroup(step)) {
-			continue;
-		} else {
-			flat.push(step);
-		}
-	}
-	return flat;
-}
-
-export const DEFAULT_GLOBAL_CONCURRENCY_LIMIT = 20;
-
-/**
- * A promise-based semaphore for limiting concurrent access across multiple
- * mapConcurrent calls within a single run. Enforces a global cap on the total
- * number of subagent tasks executing simultaneously, regardless of each step's
- * per-step concurrency limit.
- */
-export class Semaphore {
-	private available: number;
-	private readonly queue: Array<() => void> = [];
-
-	constructor(limit: number) {
-		this.available = Math.max(1, Math.floor(limit) || 1);
-	}
-
-	acquire(): Promise<void> {
-		if (this.available > 0) {
-			this.available--;
-			return Promise.resolve();
-		}
-		return new Promise<void>((resolve) => {
-			this.queue.push(resolve);
-		});
-	}
-
-	release(): void {
-		const next = this.queue.shift();
-		if (next) {
-			next();
-		} else {
-			this.available++;
-		}
-	}
-}
-
-export async function mapConcurrent<T, R>(
-	items: T[],
-	limit: number,
-	fn: (item: T, i: number) => Promise<R>,
-	globalSemaphore?: Semaphore,
-): Promise<R[]> {
-	const safeLimit = Math.max(1, Math.floor(limit) || 1);
-	const results: R[] = new Array(items.length);
-	let next = 0;
-
-	async function worker(_workerIndex: number): Promise<void> {
-		while (next < items.length) {
-			const i = next++;
-			if (globalSemaphore) {
-				await globalSemaphore.acquire();
-				try {
-					results[i] = await fn(items[i], i);
-				} finally {
-					globalSemaphore.release();
-				}
-			} else {
-				results[i] = await fn(items[i], i);
-			}
-		}
-	}
-
-	await Promise.all(
-		Array.from({ length: Math.min(safeLimit, items.length) }, (_, wi) => worker(wi)),
-	);
-	return results;
-}
-
-export interface ParallelTaskResult {
-	agent: string;
-	taskIndex?: number;
-	output: string;
-	exitCode: number | null;
-	error?: string;
-	timedOut?: boolean;
-	model?: string;
-	attemptedModels?: string[];
-	outputTargetPath?: string;
-	outputTargetExists?: boolean;
-}
-
-export function aggregateParallelOutputs(
-	results: ParallelTaskResult[],
-	headerFormat: (index: number, agent: string) => string = (i, agent) =>
-		`=== Parallel Task ${i + 1} (${agent}) ===`,
-): string {
-	return results
-		.map((r, i) => {
-			const header = headerFormat(r.taskIndex ?? i, r.agent);
-			const hasOutput = Boolean(r.output?.trim());
-			const status =
-				r.timedOut
-					? `TIMED OUT${r.error ? `: ${r.error}` : ""}`
-					: r.exitCode === -1
-					? "SKIPPED"
-					: r.exitCode !== 0 && r.exitCode !== null
-						? `FAILED (exit code ${r.exitCode})${r.error ? `: ${r.error}` : ""}`
-						: r.error
-							? `WARNING: ${r.error}`
-							: !hasOutput && r.outputTargetPath && r.outputTargetExists === false
-								? `EMPTY OUTPUT (expected output file missing: ${r.outputTargetPath})`
-								: !hasOutput && !r.outputTargetPath
-									? "EMPTY OUTPUT (no textual response returned)"
-							: "";
-			const body = status ? (hasOutput ? `${status}\n${r.output}` : status) : r.output;
-			return `${header}\n${body}`;
-		})
-		.join("\n\n");
-}
-
-export const MAX_PARALLEL_CONCURRENCY = 4;

package/extensions/dm-subagents/src/runs/shared/run-history.ts

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

package/extensions/dm-subagents/src/runs/shared/single-output.ts

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

package/extensions/dm-subagents/src/runs/shared/structured-output.ts

@@ -1,77 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { Compile } from "typebox/compile";
-import type { JsonSchemaObject } from "../../shared/types.ts";
-
-export const STRUCTURED_OUTPUT_SCHEMA_ENV = "DM_SUBAGENT_STRUCTURED_OUTPUT_SCHEMA";
-export const STRUCTURED_OUTPUT_CAPTURE_ENV = "DM_SUBAGENT_STRUCTURED_OUTPUT_CAPTURE";
-
-export interface StructuredOutputRuntime {
-	schema: JsonSchemaObject;
-	schemaPath: string;
-	outputPath: string;
-}
-
-interface CompiledJsonSchema {
-	Check(value: unknown): boolean;
-	Errors(value: unknown): Iterable<{ instancePath?: string; message?: string }>;
-}
-
-export function assertJsonSchemaObject(schema: unknown, label = "outputSchema"): asserts schema is JsonSchemaObject {
-	if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
-		throw new Error(`${label} must be a JSON Schema object.`);
-	}
-}
-
-export function createStructuredOutputRuntime(schema: JsonSchemaObject, baseDir?: string): StructuredOutputRuntime {
-	assertJsonSchemaObject(schema);
-	const rootDir = baseDir ?? os.tmpdir();
-	fs.mkdirSync(rootDir, { recursive: true });
-	const dir = fs.mkdtempSync(path.join(rootDir, "dm-subagent-structured-"));
-	const schemaPath = path.join(dir, "schema.json");
-	const outputPath = path.join(dir, "output.json");
-	fs.writeFileSync(schemaPath, JSON.stringify(schema), { mode: 0o600 });
-	return { schema, schemaPath, outputPath };
-}
-
-export function validateStructuredOutputValue(schema: JsonSchemaObject, value: unknown): { status: "valid" } | { status: "invalid"; message: string } {
-	let validator: CompiledJsonSchema;
-	try {
-		validator = (Compile as (schema: unknown) => CompiledJsonSchema)(schema);
-	} catch (error) {
-		return { status: "invalid", message: `invalid outputSchema: ${error instanceof Error ? error.message : String(error)}` };
-	}
-	if (validator.Check(value)) return { status: "valid" };
-	const errors = [...validator.Errors(value)]
-		.slice(0, 8)
-		.map((error) => {
-			const pathText = error.instancePath ? error.instancePath.replace(/^\//, "").replace(/\//g, ".") : "root";
-			return `${pathText}: ${error.message}`;
-		});
-	return { status: "invalid", message: errors.join("; ") || "schema validation failed" };
-}
-
-export function readStructuredOutput(runtime: StructuredOutputRuntime): { value?: unknown; error?: string } {
-	if (!fs.existsSync(runtime.outputPath)) {
-		return { error: "Missing structured_output call; this step has outputSchema and must finish by calling structured_output." };
-	}
-	let value: unknown;
-	try {
-		value = JSON.parse(fs.readFileSync(runtime.outputPath, "utf-8"));
-	} catch (error) {
-		return { error: `Failed to read structured output: ${error instanceof Error ? error.message : String(error)}` };
-	}
-	const validation = validateStructuredOutputValue(runtime.schema, value);
-	if (validation.status === "invalid") return { error: `Structured output validation failed: ${validation.message}` };
-	return { value };
-}
-
-export function cleanupStructuredOutputRuntime(runtime: StructuredOutputRuntime | undefined): void {
-	if (!runtime) return;
-	try {
-		fs.rmSync(path.dirname(runtime.schemaPath), { recursive: true, force: true });
-	} catch {
-		// Best-effort temp cleanup.
-	}
-}