zidane 7.2.5 → 8.0.4

package/dist/headless-C_rNUuYC.js

@@ -0,0 +1,960 @@
+import { At as basic_default, Ft as isSpawnTool, t as createAgent } from "./agent-DSLNmBp0.js";
+import { a as documentBlockMarker, d as toolResultToText, r as assertResolvedMediaBlock, s as isWireTurn } from "./types-Cu0ZGDu9.js";
+import { t as audioFormatFromMediaType } from "./media-sniff-UKijEaiQ.js";
+import { O as parseFrontmatter } from "./skills-DKqZJm4X.js";
+import { t as findGitRoot } from "./project-root-B8zADr4o.js";
+import { t as projectUserPaths } from "./project-user-paths-BSgtrRxl.js";
+import { _ as ensureToolResultPairing, u as toAnthropic } from "./messages-BqiwcD2Q.js";
+import { d as createMemoryStore, t as createSession } from "./session-xh9JXu6i.js";
+import { t as createProcessContext } from "./contexts-d7UolYot.js";
+import { n as DEFAULT_MEDIA_BUDGET, t as DEFAULT_MAX_IMAGE_EDGE } from "./defaults-Cx3zvDOV.js";
+import { t as createRunSummaryCollector } from "./run-summary-CklLiZ4y.js";
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { homedir } from "node:os";
+//#region src/markdown-defs/model-aliases.ts
+/**
+* Claude Code's agent `model:` aliases. Bump alongside `../anthropic-models.ts`
+* when the Anthropic lineup changes.
+*/
+const CLAUDE_MODEL_ALIASES = {
+	haiku: "claude-haiku-4-5-20251001",
+	sonnet: "claude-sonnet-5-5",
+	opus: "claude-opus-5-5",
+	fable: "claude-fable-5-1"
+};
+/**
+* Without a catalog, spawn sends a raw id to the PARENT's provider, so a
+* Claude id under an OpenAI parent would fail mid-run. Unresolvable aliases
+* therefore inherit instead of failing the spawn.
+*/
+function resolveModelAlias(value, ctx, path) {
+	const raw = value?.trim();
+	if (!raw || raw.toLowerCase() === "inherit") return {};
+	const key = raw.toLowerCase();
+	if (!Object.hasOwn(CLAUDE_MODEL_ALIASES, key)) return { model: raw };
+	const target = CLAUDE_MODEL_ALIASES[key];
+	if (ctx.parentProvider === "anthropic" || ctx.catalogIds?.has(target)) return { model: target };
+	return { diagnostic: {
+		path,
+		kind: "agent",
+		message: `model alias "${raw}" needs an Anthropic parent; inheriting the parent model`
+	} };
+}
+//#endregion
+//#region src/markdown-defs/tool-map.ts
+/** Claude Code tool names → zidane `spec.name`. */
+const CLAUDE_TOOL_MAP = {
+	Read: "read_file",
+	Write: "write_file",
+	Edit: "edit",
+	MultiEdit: "multi_edit",
+	Bash: "shell",
+	Grep: "grep",
+	Glob: "glob",
+	LS: "list_files",
+	WebFetch: "fetch_url",
+	WebSearch: "web_search",
+	Task: "spawn",
+	Agent: "spawn"
+};
+const NATIVE_TOOLS = new Set(Object.values(CLAUDE_TOOL_MAP));
+const PATTERNED = /^([A-Z]\w*)\(.*\)$/;
+/**
+* Translate an agent file's `tools:` list. Patterns (`Bash(git:*)`) are not
+* enforced by spawn's allowlist, so they collapse to the bare tool with a
+* diagnostic. Unknown names are dropped loudly instead of narrowing nothing.
+*/
+function mapClaudeTools(names, path) {
+	const tools = /* @__PURE__ */ new Set();
+	const diagnostics = [];
+	for (const raw of names) {
+		const name = raw.trim();
+		if (!name) continue;
+		if (NATIVE_TOOLS.has(name) || name.startsWith("mcp__")) {
+			tools.add(name);
+			continue;
+		}
+		const patterned = PATTERNED.exec(name);
+		const base = patterned ? patterned[1] : name;
+		const mapped = Object.hasOwn(CLAUDE_TOOL_MAP, base) ? CLAUDE_TOOL_MAP[base] : void 0;
+		if (!mapped) {
+			diagnostics.push({
+				path,
+				kind: "agent",
+				message: `unknown tool "${name}" dropped`
+			});
+			continue;
+		}
+		if (patterned) diagnostics.push({
+			path,
+			kind: "agent",
+			message: `tool pattern "${name}" is not enforced; granted ${mapped} unrestricted`
+		});
+		tools.add(mapped);
+	}
+	return {
+		tools: [...tools],
+		diagnostics
+	};
+}
+//#endregion
+//#region src/markdown-defs/agents.ts
+const IGNORED_KEYS$1 = [
+	"color",
+	"isolation",
+	"memory",
+	"hooks"
+];
+/** Keys that narrow a child's tools; a duplicate of any of them drops the agent. */
+const RESTRICTION_KEYS = [
+	"tools",
+	"disallowedTools",
+	"readonly",
+	"permissionMode"
+];
+/**
+* `tools:` arrives as a YAML list, `[a, b]`, `a, b`, or `a b`. Comma input
+* splits on commas only; otherwise it splits on whitespace outside parens, so
+* `Bash(git log:*)` survives intact either way.
+*/
+function toStringList(value) {
+	if (value === void 0 || value === null) return void 0;
+	if (Array.isArray(value)) return value.filter((v) => typeof v === "string").map((v) => v.trim()).filter(Boolean);
+	if (typeof value !== "string") return void 0;
+	const inner = value.trim().replace(/^\[(.*)\]$/, "$1");
+	return (inner.includes(",") ? inner.split(",") : splitOutsideParens(inner)).map((p) => p.trim()).filter(Boolean);
+}
+function splitOutsideParens(input) {
+	const parts = [];
+	let depth = 0;
+	let current = "";
+	for (const ch of input) {
+		if (ch === "(") depth++;
+		else if (ch === ")") depth = Math.max(0, depth - 1);
+		if (depth === 0 && /\s/.test(ch)) {
+			parts.push(current);
+			current = "";
+		} else current += ch;
+	}
+	parts.push(current);
+	return parts;
+}
+/** `true`/`false` as a boolean or the strings `'true'`/`'false'`; `undefined` for anything else. */
+function toBool(value) {
+	if (typeof value === "boolean") return value;
+	if (typeof value === "string") {
+		const v = value.trim().toLowerCase();
+		if (v === "true") return true;
+		if (v === "false") return false;
+	}
+}
+function isListShaped(value) {
+	return typeof value === "string" || Array.isArray(value);
+}
+/**
+* `explicitReadonlyFalse` reports a file that wrote `readonly: false`, so the
+* loader can tell "unset" from "opted out" when a file overrides a builtin.
+*/
+function parseAgentFile(file, content, modelContext) {
+	const diagnostics = [];
+	const note = (message) => diagnostics.push({
+		path: file.path,
+		kind: "agent",
+		message
+	});
+	const parsed = parseFrontmatter(content);
+	for (const d of parsed.diagnostics) note(d.message);
+	const fm = parsed.frontmatter;
+	const name = typeof fm.name === "string" && fm.name.trim() ? fm.name.trim() : file.name;
+	if (!parsed.body) {
+		note("empty agent body; skipped");
+		return { diagnostics };
+	}
+	if (typeof fm.description !== "string" || !fm.description.trim()) {
+		note("missing description; skipped");
+		return { diagnostics };
+	}
+	const def = {
+		system: parsed.body,
+		description: fm.description.trim()
+	};
+	const duplicated = RESTRICTION_KEYS.filter((key) => parsed.diagnostics.some((d) => d.code === "duplicate-key" && d.field === key));
+	if (duplicated.length > 0) {
+		note(`duplicate restriction keys: ${duplicated.join(", ")}; skipped`);
+		return { diagnostics };
+	}
+	let explicitReadonlyFalse = false;
+	if (fm.readonly !== void 0 && fm.readonly !== null) {
+		const ro = toBool(fm.readonly);
+		if (ro === void 0) {
+			note("unreadable readonly value; skipped");
+			return { diagnostics };
+		}
+		if (ro) def.readonly = true;
+		else explicitReadonlyFalse = true;
+	}
+	if (fm.tools !== void 0 && fm.tools !== null && !isListShaped(fm.tools)) {
+		note("unreadable tools value; skipped");
+		return { diagnostics };
+	}
+	if (fm.disallowedTools !== void 0 && fm.disallowedTools !== null && !isListShaped(fm.disallowedTools)) {
+		note("unreadable disallowedTools value; skipped");
+		return { diagnostics };
+	}
+	const rawTools = toStringList(fm.tools);
+	if (rawTools !== void 0) {
+		if (rawTools.length === 0) {
+			note("empty tools list; skipped (an empty list would inherit every tool)");
+			return { diagnostics };
+		}
+		const mapped = mapClaudeTools(rawTools, file.path);
+		diagnostics.push(...mapped.diagnostics);
+		if (mapped.tools.length === 0) {
+			note("no usable tools after mapping; skipped");
+			return { diagnostics };
+		}
+		def.tools = mapped.tools;
+	}
+	const rawDisallowed = toStringList(fm.disallowedTools);
+	if (rawDisallowed !== void 0) {
+		if (rawDisallowed.length === 0) {
+			note("empty disallowedTools list; skipped");
+			return { diagnostics };
+		}
+		const mapped = mapClaudeTools(rawDisallowed, file.path);
+		diagnostics.push(...mapped.diagnostics);
+		const blocked = new Set(mapped.tools);
+		if (def.tools) def.tools = def.tools.filter((t) => !blocked.has(t));
+		else {
+			note("disallowedTools without tools restricts to native tools; MCP and extension tools are excluded");
+			def.tools = [...new Set(Object.values(CLAUDE_TOOL_MAP))].filter((t) => !blocked.has(t));
+		}
+		if (def.tools.length === 0) {
+			note("no tools left after disallowedTools; skipped");
+			return { diagnostics };
+		}
+	}
+	const model = resolveModelAlias(typeof fm.model === "string" ? fm.model : void 0, modelContext, file.path);
+	if (model.diagnostic) diagnostics.push(model.diagnostic);
+	if (model.model) def.model = model.model;
+	const permissionMode = typeof fm.permissionMode === "string" ? fm.permissionMode.trim() : void 0;
+	if (permissionMode === "plan") def.readonly = true;
+	const ignored = IGNORED_KEYS$1.filter((key) => fm[key] !== void 0);
+	if (fm.permissionMode !== void 0 && permissionMode !== "plan") ignored.push("permissionMode");
+	if (ignored.length > 0) note(`ignored frontmatter keys: ${ignored.join(", ")}`);
+	return {
+		entry: [name, def],
+		diagnostics,
+		explicitReadonlyFalse
+	};
+}
+//#endregion
+//#region src/markdown-defs/builtin-agents.ts
+/**
+* Claude-trained models emit `subagent_type: 'Explore'` / `'Plan'`. Shipping
+* both gives those calls a target. No `model`: the `subagentModels` setting
+* or the parent model applies. A file agent with the same name overrides.
+*/
+const BUILTIN_SUBAGENTS = {
+	Explore: {
+		readonly: true,
+		description: "Read-only codebase search. Use for broad fan-out searches; returns conclusions, not file dumps.",
+		system: "You are a read-only search agent. Search with the available read-only tools, read only the excerpts you need, and report findings concisely with file:line references. Do not paste whole files."
+	},
+	Plan: {
+		readonly: true,
+		description: "Read-only planning. Returns a step-by-step implementation plan with the critical files.",
+		system: "You are a read-only planning agent. Explore the code you need, then return a numbered implementation plan: the files to change, what changes in each, and the risks. Do not edit files."
+	}
+};
+//#endregion
+//#region src/markdown-defs/commands.ts
+const TOKEN = /\\\$|\$ARGUMENTS|\$([1-9])(?!\d)/g;
+const IGNORED_KEYS = ["model", "allowed-tools"];
+const DESCRIPTION_MAX = 120;
+/**
+* Claude Code command templating. Replacers are functions so `$&` / `$1`
+* typed by the user land verbatim instead of being re-expanded by
+* `String.replace`'s replacement-pattern syntax.
+*/
+function expandCommandTemplate(body, args, argv) {
+	let hasPlaceholder = false;
+	const out = body.replace(TOKEN, (match, n) => {
+		if (match === "\\$") return "$";
+		hasPlaceholder = true;
+		return n ? argv[Number(n) - 1] ?? "" : args;
+	});
+	if (!hasPlaceholder) return args.trim() ? `${out}\n\n${args}` : out;
+	return out;
+}
+function parseCommandFile(file, content) {
+	const diagnostics = [];
+	const note = (message) => diagnostics.push({
+		path: file.path,
+		kind: "command",
+		message
+	});
+	const parsed = parseFrontmatter(content);
+	for (const d of parsed.diagnostics) note(d.message);
+	if (!file.name || /\s/.test(file.name) || file.name.startsWith("/")) {
+		note(`invalid command name "${file.name}"; skipped`);
+		return { diagnostics };
+	}
+	const body = parsed.body;
+	if (!body) {
+		note("empty command body; skipped");
+		return { diagnostics };
+	}
+	for (const key of IGNORED_KEYS) if (parsed.frontmatter[key] !== void 0) note(`frontmatter "${key}" is ignored for commands`);
+	const fm = parsed.frontmatter;
+	const firstLine = body.split("\n").find((line) => line.trim())?.trim().replace(/^#+\s*/, "") || file.name;
+	let description = typeof fm.description === "string" && fm.description.trim() ? fm.description.trim() : firstLine.slice(0, DESCRIPTION_MAX);
+	if (typeof fm["argument-hint"] === "string" && fm["argument-hint"].trim()) description = `${description} (args: ${fm["argument-hint"].trim()})`;
+	return {
+		command: {
+			name: file.name,
+			description,
+			run: async (ctx) => {
+				await ctx.runAgent(expandCommandTemplate(body, ctx.args, ctx.argv));
+			}
+		},
+		diagnostics
+	};
+}
+//#endregion
+//#region src/markdown-defs/roots.ts
+/**
+* Claude Code's markdown command / agent dirs, project first. Claude only:
+* Codex and pi have no equivalent format. Project root is the git root, as
+* for the other foreign configs.
+*/
+function foreignMarkdownScanPaths(kind, opts = {}) {
+	const cwd = opts.cwd ?? process.cwd();
+	const projectRoot = findGitRoot(cwd) ?? cwd;
+	const home = opts.home ?? homedir();
+	return [{
+		path: resolve(projectRoot, `.claude/${kind}`),
+		source: "project"
+	}, {
+		path: resolve(home, `.claude/${kind}`),
+		source: "user"
+	}];
+}
+/** Native project, native user, then (opt-in) foreign project, foreign user. Same order as skills. */
+function markdownDefRoots(opts) {
+	const native = projectUserPaths({
+		subPath: opts.kind,
+		cwd: opts.cwd,
+		home: opts.home,
+		prefix: opts.prefix
+	}).map((p) => ({
+		path: p.path,
+		source: p.source,
+		foreign: false
+	}));
+	const foreign = opts.includeForeign ? foreignMarkdownScanPaths(opts.kind, {
+		cwd: opts.cwd,
+		home: opts.home
+	}).map((p) => ({
+		path: p.path,
+		source: p.source,
+		foreign: true
+	})) : [];
+	const all = [...native, ...foreign];
+	return opts.includeProject === false ? all.filter((r) => r.source !== "project") : all;
+}
+//#endregion
+//#region src/markdown-defs/scan.ts
+const MAX_DEPTH = 3;
+/** Dot entries (dirs and dotfiles) are skipped separately. Not the skills skip set: `build/` and `dist/` are legitimate command namespaces. */
+const SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules"]);
+/**
+* Every `*.md` under each root, in root order. No dedupe here: agent files
+* can rename themselves via frontmatter, so first-wins runs after parsing.
+*/
+function listMarkdownDefFiles(roots) {
+	const files = [];
+	for (const root of roots) walk(root, root.path, [], files);
+	return files;
+}
+function walk(root, dir, segments, out) {
+	let entries;
+	try {
+		entries = readdirSync(dir).sort();
+	} catch {
+		return;
+	}
+	for (const entry of entries) {
+		if (entry.startsWith(".") || SKIP_DIRS.has(entry)) continue;
+		const path = join(dir, entry);
+		let isDir;
+		try {
+			isDir = statSync(path).isDirectory();
+		} catch {
+			continue;
+		}
+		if (isDir) {
+			if (segments.length < MAX_DEPTH) walk(root, path, [...segments, entry], out);
+			continue;
+		}
+		if (!entry.endsWith(".md")) continue;
+		const name = [...segments, entry.slice(0, -3)].join(":").toLowerCase();
+		out.push({
+			path,
+			name,
+			source: root.source,
+			foreign: root.foreign
+		});
+	}
+}
+//#endregion
+//#region src/markdown-defs/index.ts
+/** Names that would collide with `Object.prototype` keys in a plain registry. */
+const RESERVED_NAMES = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+function filesFor(kind, opts) {
+	return listMarkdownDefFiles(markdownDefRoots({
+		kind,
+		...opts
+	}));
+}
+function read(path) {
+	try {
+		return readFileSync(path, "utf8");
+	} catch {
+		return;
+	}
+}
+/** Markdown slash commands, first-wins by name in root order. Never throws. */
+function loadMarkdownCommands(opts) {
+	const commands = [];
+	const diagnostics = [];
+	const winners = /* @__PURE__ */ new Map();
+	for (const file of filesFor("commands", opts)) {
+		const content = read(file.path);
+		if (content === void 0) continue;
+		const parsed = parseCommandFile(file, content);
+		diagnostics.push(...parsed.diagnostics);
+		if (!parsed.command) continue;
+		const key = parsed.command.name.toLowerCase();
+		if (RESERVED_NAMES.has(key)) {
+			diagnostics.push({
+				path: file.path,
+				kind: "command",
+				message: "reserved command name"
+			});
+			continue;
+		}
+		if (opts.isSkillName?.(key)) {
+			diagnostics.push({
+				path: file.path,
+				kind: "command",
+				message: `skill "${key}" has the same name and wins; rename the command or the skill`
+			});
+			continue;
+		}
+		const winner = winners.get(key);
+		if (winner) {
+			diagnostics.push({
+				path: file.path,
+				kind: "command",
+				message: `shadowed by ${winner}`
+			});
+			continue;
+		}
+		winners.set(key, file.path);
+		commands.push(parsed.command);
+	}
+	return {
+		commands,
+		diagnostics
+	};
+}
+/**
+* Builtin Explore/Plan plus markdown agents. Files override builtins;
+* among files, first-wins by name in root order. Never throws.
+*/
+function loadMarkdownAgents(opts) {
+	const fromFiles = Object.create(null);
+	const winners = /* @__PURE__ */ new Map();
+	const diagnostics = [];
+	for (const file of filesFor("agents", opts)) {
+		const content = read(file.path);
+		if (content === void 0) continue;
+		const parsed = parseAgentFile(file, content, opts.modelContext);
+		diagnostics.push(...parsed.diagnostics);
+		if (!parsed.entry) continue;
+		const [name, def] = parsed.entry;
+		if (RESERVED_NAMES.has(name)) {
+			diagnostics.push({
+				path: file.path,
+				kind: "agent",
+				message: "reserved agent name"
+			});
+			continue;
+		}
+		if (Object.hasOwn(BUILTIN_SUBAGENTS, name)) {
+			if (file.source === "project") {
+				diagnostics.push({
+					path: file.path,
+					kind: "agent",
+					message: `project files cannot replace builtin ${name}; rename the agent or move it to the user folder`
+				});
+				continue;
+			}
+			if (!def.tools && !parsed.explicitReadonlyFalse) def.readonly = true;
+		}
+		const winner = winners.get(name);
+		if (winner) {
+			diagnostics.push({
+				path: file.path,
+				kind: "agent",
+				message: `shadowed by ${winner}`
+			});
+			continue;
+		}
+		winners.set(name, file.path);
+		fromFiles[name] = def;
+	}
+	const subagents = {};
+	for (const [name, def] of Object.entries(BUILTIN_SUBAGENTS)) subagents[name] = { ...def };
+	for (const [name, def] of Object.entries(fromFiles)) subagents[name] = def;
+	return {
+		subagents,
+		diagnostics
+	};
+}
+/**
+* Fold markdown/builtin agents into the preset's spawn tool, filling gaps
+* only: an agent the profile or an extension already registered keeps its
+* definition. Runs after `composeExtensionPreset`, so precedence is
+* builtin < file < extension without threading files through composition.
+*/
+function applyMarkdownSubagents(preset, subagents) {
+	const spawn = preset.tools?.spawn;
+	const entries = Object.entries(subagents);
+	if (!spawn || !isSpawnTool(spawn) || entries.length === 0) return preset;
+	const overrides = Object.create(null);
+	for (const [name, def] of entries) overrides[name] = (current) => current ?? def;
+	return {
+		...preset,
+		tools: {
+			...preset.tools,
+			spawn: spawn.withSubagents({}, overrides)
+		}
+	};
+}
+//#endregion
+//#region src/headless.ts
+function exitCodeForHeadlessResult(result) {
+	switch (result.status) {
+		case "completed": return 0;
+		case "timeout": return 124;
+		case "aborted": return 130;
+		default: return 1;
+	}
+}
+/** Serialize one event as a newline-terminated JSON line (stream-json). */
+function headlessEventToJsonl(event) {
+	return `${JSON.stringify(event)}\n`;
+}
+function formattedHeadlessTurnEventToJsonl(event) {
+	return `${JSON.stringify(event)}\n`;
+}
+function providerTranscriptFormatForProvider(providerName) {
+	return providerName === "anthropic" ? "anthropic" : "openai";
+}
+function transcriptToProviderMessages(turns, providerName) {
+	if (providerTranscriptFormatForProvider(providerName) === "anthropic") return turns.filter(isWireTurn).map((turn) => toAnthropic({
+		role: turn.role,
+		content: turn.content
+	}));
+	return transcriptToOpenAIMessages(turns, { strictToolPairing: false });
+}
+function formatHeadlessResult(result, options) {
+	if (options.format === "zidane") return result;
+	return transcriptToProviderMessages(result.transcript, options.providerName);
+}
+function formatHeadlessTurnEvent(event, options) {
+	if (options.format === "zidane") return event;
+	return transcriptToProviderMessages([event.turn], options.providerName);
+}
+/**
+* Run a prompt to completion, headless, and return a single serializable
+* {@link HeadlessResult}. Safe to call concurrently for parallel rollouts —
+* each call builds its own agent + session and tears them down in `finally`.
+*/
+async function runHeadless(opts) {
+	const startedAt = Date.now();
+	const execution = opts.execution ?? createProcessContext({ cwd: opts.cwd });
+	const session = opts.session ?? await createSession({ store: opts.store ?? createMemoryStore() });
+	const basePreset = opts.subagents ? applyMarkdownSubagents(opts.preset ?? basic_default, opts.subagents) : opts.preset ?? basic_default;
+	const behavior = {
+		mediaBudget: DEFAULT_MEDIA_BUDGET,
+		maxImageEdge: DEFAULT_MAX_IMAGE_EDGE,
+		...basePreset.behavior,
+		...opts.behavior ?? {}
+	};
+	if (opts.maxTurns !== void 0) behavior.maxTurns = opts.maxTurns;
+	if (opts.maxTokens !== void 0) behavior.maxTokens = opts.maxTokens;
+	if (opts.schema !== void 0) behavior.schema = opts.schema;
+	const agent = createAgent({
+		...basePreset,
+		provider: opts.provider,
+		execution,
+		session,
+		behavior,
+		...opts.tools !== void 0 ? { tools: opts.tools } : {},
+		...opts.mcpServers !== void 0 ? { mcpServers: opts.mcpServers } : {},
+		...opts.skills !== void 0 ? { skills: opts.skills } : {},
+		...opts.extensions !== void 0 ? { extensions: opts.extensions } : {}
+	});
+	const collector = createRunSummaryCollector();
+	const uninstallSummary = collector.install(agent.hooks);
+	const uninstallEvents = opts.onEvent ? installHeadlessEventAdapter(agent.hooks, opts.onEvent) : noop;
+	const runStartIndex = session.turns.length;
+	const controller = new AbortController();
+	const onExternalAbort = () => controller.abort(opts.signal.reason);
+	if (opts.signal) {
+		if (opts.signal.aborted) controller.abort(opts.signal.reason);
+		else opts.signal.addEventListener("abort", onExternalAbort, { once: true });
+	}
+	let timedOut = false;
+	const timer = opts.timeoutMs && opts.timeoutMs > 0 ? setTimeout(() => {
+		timedOut = true;
+		controller.abort(/* @__PURE__ */ new Error(`Headless run timed out after ${opts.timeoutMs}ms`));
+	}, opts.timeoutMs) : void 0;
+	let stats;
+	let error;
+	try {
+		stats = await agent.run({
+			prompt: opts.prompt,
+			signal: controller.signal,
+			...opts.model !== void 0 ? { model: opts.model } : {},
+			...opts.system !== void 0 ? { system: opts.system } : {},
+			...opts.thinking !== void 0 ? { thinking: opts.thinking } : {}
+		});
+	} catch (err) {
+		const e = err instanceof Error ? err : new Error(String(err));
+		error = {
+			message: e.message,
+			type: e.name
+		};
+	} finally {
+		if (timer) clearTimeout(timer);
+		opts.signal?.removeEventListener("abort", onExternalAbort);
+		uninstallEvents();
+		uninstallSummary();
+		await agent.destroy();
+	}
+	let status;
+	if (error) status = timedOut ? "timeout" : controller.signal.aborted ? "aborted" : "error";
+	else if (controller.signal.aborted) status = timedOut ? "timeout" : "aborted";
+	else status = "completed";
+	const rawTranscript = session.turns.slice(runStartIndex);
+	const transcript = opts.includeThinking === false ? stripThinking(rawTranscript) : rawTranscript;
+	const summary = collector.latest();
+	const result = {
+		status,
+		finalText: extractFinalText(rawTranscript),
+		...stats?.output ? { output: stats.output } : {},
+		usage: {
+			input: stats?.totalIn ?? 0,
+			output: stats?.totalOut ?? 0,
+			cacheRead: stats?.totalCacheRead ?? 0,
+			cacheCreation: stats?.totalCacheCreation ?? 0,
+			...typeof stats?.cost === "number" ? { cost: stats.cost } : {}
+		},
+		turns: stats?.turns ?? 0,
+		durationMs: stats?.elapsed ?? Date.now() - startedAt,
+		numToolCalls: countToolCalls(rawTranscript),
+		...status !== "aborted" && status !== "timeout" && lastFinishReason(stats) ? { finishReason: lastFinishReason(stats) } : {},
+		...error ? { error } : {},
+		sessionId: session.id,
+		...summary ? { summary } : {},
+		transcript
+	};
+	opts.onEvent?.({
+		type: "result",
+		result
+	});
+	return result;
+}
+/**
+* Convert raw `session.turns` into standard OpenAI chat-completion messages:
+* assistant turns carry `tool_calls`, and each `tool_result` becomes its own
+* `role: 'tool'` message. This is the drop-in shape for an SFT renderer —
+* unlike `toOpenAI` (session/messages.ts), which emits an internal `_tag`
+* envelope meant for re-sending to a provider, not for training data.
+*
+* Fails closed on corrupt raw turns instead of fabricating tool results; silent
+* placeholders would create structurally-valid but semantically-poisoned SFT
+* examples.
+*/
+function transcriptToOpenAIMessages(turns, options = {}) {
+	const { strictToolPairing = true } = options;
+	const messages = [];
+	let chunk = [];
+	const flushChunk = () => {
+		if (chunk.length === 0) return;
+		let paired = chunk;
+		if (strictToolPairing) {
+			const repairs = [];
+			paired = ensureToolResultPairing(chunk, { onRepair: (repair) => repairs.push(repair) });
+			if (repairs.length > 0) throw new Error(`Cannot convert transcript to OpenAI messages: tool pairing repair required (${repairs.map((r) => r.mode).join(", ")})`);
+		}
+		for (const msg of paired) pushOpenAIChatMessage(messages, msg);
+		chunk = [];
+	};
+	for (const turn of turns) {
+		if (turn.role === "system") {
+			flushChunk();
+			messages.push({
+				role: "system",
+				content: textOf(turn.content)
+			});
+			continue;
+		}
+		if (!isWireTurn(turn)) continue;
+		chunk.push({
+			role: turn.role,
+			content: turn.content
+		});
+	}
+	flushChunk();
+	return messages;
+}
+function pushOpenAIChatMessage(messages, msg) {
+	const text = textOf(msg.content);
+	if (msg.role === "assistant") {
+		const toolCalls = msg.content.filter((b) => b.type === "tool_call");
+		const out = {
+			role: "assistant",
+			content: text || null
+		};
+		if (toolCalls.length > 0) out.tool_calls = toolCalls.map((b) => ({
+			id: b.id,
+			type: "function",
+			function: {
+				name: b.name,
+				arguments: JSON.stringify(b.input)
+			}
+		}));
+		messages.push(out);
+		return;
+	}
+	const userParts = contentPartsFromBlocks(msg.content);
+	if (userParts.length > 0) messages.push({
+		role: "user",
+		content: simplifyOpenAIContent(userParts)
+	});
+	for (const tr of msg.content.filter((b) => b.type === "tool_result")) {
+		const { text, images } = summarizeToolResultForOpenAI(tr.output);
+		if (images.length === 0) {
+			messages.push({
+				role: "tool",
+				tool_call_id: tr.callId,
+				content: text
+			});
+			continue;
+		}
+		const noun = images.length === 1 ? "image" : "images";
+		const marker = `[${images.length} ${noun} attached — see next user message]`;
+		messages.push({
+			role: "tool",
+			tool_call_id: tr.callId,
+			content: text.length > 0 ? `${text}\n\n${marker}` : marker
+		});
+		messages.push({
+			role: "user",
+			content: [...images.map(toOpenAIImagePart), {
+				type: "text",
+				text: `(${noun} returned by tool call ${tr.callId})`
+			}]
+		});
+	}
+}
+function noop() {}
+function textOf(content) {
+	return content.filter((b) => b.type === "text").map((b) => b.text).join("");
+}
+function contentPartsFromBlocks(content) {
+	const parts = [];
+	for (const block of content) if (block.type === "image") {
+		assertResolvedMediaBlock(block, "OpenAI transcript messages");
+		parts.push(toOpenAIImagePart(block));
+	} else if (block.type === "audio") parts.push({
+		type: "input_audio",
+		input_audio: {
+			data: block.data,
+			format: audioFormatFromMediaType(block.mediaType)
+		}
+	});
+	else if (block.type === "video") parts.push({
+		type: "video_url",
+		video_url: { url: `data:${block.mediaType};base64,${block.data}` }
+	});
+	else if (block.type === "document") {
+		assertResolvedMediaBlock(block, "OpenAI transcript messages");
+		parts.push({
+			type: "text",
+			text: documentMarker(block)
+		});
+	} else if (block.type === "text" && block.text.length > 0) parts.push({
+		type: "text",
+		text: block.text
+	});
+	return parts;
+}
+function simplifyOpenAIContent(parts) {
+	if (parts.length === 1 && parts[0].type === "text") return parts[0].text;
+	return parts;
+}
+function toOpenAIImagePart(image) {
+	return {
+		type: "image_url",
+		image_url: { url: `data:${image.mediaType};base64,${image.data}` }
+	};
+}
+function summarizeToolResultForOpenAI(output) {
+	if (typeof output === "string") return {
+		text: output,
+		images: []
+	};
+	const texts = [];
+	const images = [];
+	for (const block of output) if (block.type === "text") texts.push(block.text);
+	else if (block.type === "image") {
+		assertResolvedMediaBlock(block, "OpenAI transcript messages");
+		images.push({
+			mediaType: block.mediaType,
+			data: block.data
+		});
+	} else if (block.type === "audio") texts.push(`[audio: ${block.mediaType}]`);
+	else if (block.type === "video") texts.push(`[video: ${block.mediaType}]`);
+	else {
+		assertResolvedMediaBlock(block, "OpenAI transcript messages");
+		texts.push(documentMarker(block));
+	}
+	return {
+		text: texts.join("\n"),
+		images
+	};
+}
+function documentMarker(doc) {
+	return documentBlockMarker(doc, "document omitted");
+}
+function extractFinalText(turns) {
+	for (let i = turns.length - 1; i >= 0; i--) {
+		const turn = turns[i];
+		if (turn.role !== "assistant") continue;
+		const text = textOf(turn.content);
+		if (text) return text;
+	}
+	return "";
+}
+function countToolCalls(turns) {
+	let n = 0;
+	for (const turn of turns) for (const block of turn.content) if (block.type === "tool_call") n++;
+	return n;
+}
+function lastFinishReason(stats) {
+	const usages = stats?.turnUsage;
+	if (!usages) return void 0;
+	for (let i = usages.length - 1; i >= 0; i--) if (usages[i].finishReason) return usages[i].finishReason;
+}
+function stripThinking(turns) {
+	return turns.map((turn) => ({
+		...turn,
+		content: turn.content.filter((b) => b.type !== "thinking" && b.type !== "redacted_thinking")
+	}));
+}
+function installHeadlessEventAdapter(hooks, onEvent) {
+	const unregs = [];
+	const emittedTurnIds = /* @__PURE__ */ new Set();
+	const emit = (event) => {
+		try {
+			onEvent(event);
+		} catch {}
+	};
+	unregs.push(hooks.hook("agent:start", (ctx) => emit({
+		type: "start",
+		runId: ctx.runId,
+		...ctx.providerName ? { provider: ctx.providerName } : {}
+	})));
+	unregs.push(hooks.hook("stream:text", (ctx) => emit({
+		type: "text",
+		delta: ctx.delta
+	})));
+	unregs.push(hooks.hook("stream:thinking", (ctx) => emit({
+		type: "thinking",
+		delta: ctx.delta
+	})));
+	unregs.push(hooks.hook("tool:before", (ctx) => emit({
+		type: "tool_call",
+		callId: ctx.callId,
+		name: ctx.name,
+		input: ctx.input
+	})));
+	unregs.push(hooks.hook("tool:after", (ctx) => emit({
+		type: "tool_result",
+		callId: ctx.callId,
+		name: ctx.name,
+		output: toolResultToText(ctx.result),
+		isError: false
+	})));
+	unregs.push(hooks.hook("tool:error", (ctx) => emit({
+		type: "tool_result",
+		callId: ctx.callId,
+		name: ctx.name,
+		output: ctx.error.message,
+		isError: true
+	})));
+	unregs.push(hooks.hook("session:turns", (ctx) => {
+		const startIndex = ctx.count - ctx.turns.length;
+		ctx.turns.forEach((turn, i) => {
+			if (emittedTurnIds.has(turn.id)) return;
+			emittedTurnIds.add(turn.id);
+			emit({
+				type: "turn",
+				index: startIndex + i,
+				turn
+			});
+		});
+	}));
+	unregs.push(hooks.hook("spawn:before", (ctx) => emit({
+		type: "spawn",
+		event: "before",
+		id: ctx.id
+	})));
+	unregs.push(hooks.hook("spawn:complete", (ctx) => emit({
+		type: "spawn",
+		event: "complete",
+		id: ctx.id,
+		info: { status: ctx.status ?? "completed" }
+	})));
+	unregs.push(hooks.hook("spawn:error", (ctx) => emit({
+		type: "spawn",
+		event: "error",
+		id: ctx.id,
+		info: { message: ctx.error.message }
+	})));
+	unregs.push(hooks.hook("stream:error", (ctx) => emit({
+		type: "error",
+		message: ctx.err instanceof Error ? ctx.err.message : String(ctx.err),
+		...ctx.err instanceof Error ? { errorType: ctx.err.name } : {}
+	})));
+	return () => {
+		for (const un of unregs) try {
+			un();
+		} catch {}
+	};
+}
+//#endregion
+export { headlessEventToJsonl as a, runHeadless as c, applyMarkdownSubagents as d, loadMarkdownAgents as f, BUILTIN_SUBAGENTS as g, markdownDefRoots as h, formattedHeadlessTurnEventToJsonl as i, transcriptToOpenAIMessages as l, listMarkdownDefFiles as m, formatHeadlessResult as n, installHeadlessEventAdapter as o, loadMarkdownCommands as p, formatHeadlessTurnEvent as r, providerTranscriptFormatForProvider as s, exitCodeForHeadlessResult as t, transcriptToProviderMessages as u };
+
+//# sourceMappingURL=headless-C_rNUuYC.js.map