@flue/sdk 0.1.0

package/dist/session-BD0MEuO3.mjs

@@ -0,0 +1,1300 @@
+import { Agent } from "@mariozechner/pi-agent-core";
+import { Type, completeSimple, isContextOverflow } from "@mariozechner/pi-ai";
+import { toJsonSchema } from "@valibot/to-json-schema";
+import * as v from "valibot";
+
+//#region src/context.ts
+/** Parse optional YAML frontmatter (--- delimited). Basic `key: value` only. */
+function parseFrontmatterFile(content, defaultName) {
+	const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+	if (!frontmatterMatch) return {
+		name: defaultName,
+		description: "",
+		body: content.trim(),
+		frontmatter: {}
+	};
+	const rawFrontmatter = frontmatterMatch[1] ?? "";
+	const body = frontmatterMatch[2] ?? "";
+	const frontmatter = {};
+	for (const line of rawFrontmatter.split("\n")) {
+		const match = line.match(/^(\w+):\s*(.+)$/);
+		if (match?.[1] && match[2]) frontmatter[match[1]] = match[2].trim();
+	}
+	return {
+		name: frontmatter.name || defaultName,
+		description: frontmatter.description || "",
+		body: body.trim(),
+		frontmatter
+	};
+}
+/** Read AGENTS.md (and CLAUDE.md if present) from a directory. Returns concatenated contents. */
+async function readAgentsMd(env, basePath) {
+	const parts = [];
+	for (const filename of ["AGENTS.md", "CLAUDE.md"]) {
+		const filePath = basePath.endsWith("/") ? basePath + filename : `${basePath}/${filename}`;
+		if (await env.exists(filePath)) {
+			const content = await env.readFile(filePath);
+			parts.push(content.trim());
+		}
+	}
+	return parts.join("\n\n");
+}
+/** Discover skills from .agents/skills/<name>/SKILL.md under basePath. */
+async function discoverLocalSkills(env, basePath) {
+	const skillsDir = basePath.endsWith("/") ? `${basePath}.agents/skills` : `${basePath}/.agents/skills`;
+	if (!await env.exists(skillsDir)) return {};
+	const skills = {};
+	const entries = await env.readdir(skillsDir);
+	for (const entry of entries) {
+		const skillDir = `${skillsDir}/${entry}`;
+		try {
+			if (!(await env.stat(skillDir)).isDirectory) continue;
+		} catch {
+			continue;
+		}
+		const skillMdPath = `${skillDir}/SKILL.md`;
+		if (!await env.exists(skillMdPath)) continue;
+		const parsed = parseFrontmatterFile(await env.readFile(skillMdPath), entry);
+		skills[parsed.name] = {
+			name: parsed.name,
+			description: parsed.description,
+			instructions: parsed.body
+		};
+	}
+	return skills;
+}
+function composeSystemPrompt(agentsMd, skills, env) {
+	const parts = [];
+	if (agentsMd) parts.push(agentsMd);
+	const skillEntries = Object.values(skills);
+	if (skillEntries.length > 0) {
+		parts.push("", "## Available Skills", "");
+		for (const skill of skillEntries) {
+			const desc = skill.description ? ` - ${skill.description}` : "";
+			parts.push(`- **${skill.name}**${desc}`);
+		}
+	}
+	if (env) {
+		const date = (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", {
+			weekday: "short",
+			year: "numeric",
+			month: "short",
+			day: "numeric"
+		});
+		parts.push("", `Date: ${date}`);
+		parts.push(`Working directory: ${env.cwd}`);
+		if (env.directoryListing && env.directoryListing.length > 0) parts.push("", "Directory structure:", env.directoryListing.join("\n"));
+	}
+	return parts.join("\n");
+}
+/** Discover AGENTS.md, local skills, and directory listing from the session's cwd. */
+async function discoverSessionContext(env) {
+	const cwd = env.cwd;
+	const agentsMd = await readAgentsMd(env, cwd);
+	const skills = await discoverLocalSkills(env, cwd);
+	let directoryListing;
+	try {
+		directoryListing = await env.readdir(cwd);
+	} catch {}
+	return {
+		systemPrompt: composeSystemPrompt(agentsMd, skills, {
+			cwd,
+			directoryListing
+		}),
+		skills
+	};
+}
+
+//#endregion
+//#region src/agent.ts
+const MAX_READ_LINES = 2e3;
+const MAX_READ_BYTES = 50 * 1024;
+const MAX_GREP_MATCHES = 100;
+const MAX_GREP_LINE_LENGTH = 500;
+const MAX_GLOB_RESULTS = 1e3;
+const BUILTIN_TOOL_NAMES = new Set([
+	"read",
+	"write",
+	"edit",
+	"bash",
+	"grep",
+	"glob"
+]);
+function createTools(env) {
+	return [
+		createReadTool(env),
+		createWriteTool(env),
+		createEditTool(env),
+		createBashTool(env),
+		createGrepTool(env),
+		createGlobTool(env)
+	];
+}
+function createReadTool(env) {
+	return {
+		name: "read",
+		label: "Read File",
+		description: "Read a file or list a directory. For files, output is truncated to 2000 lines or 50KB — use offset/limit for large files. For directories, returns the list of entries.",
+		parameters: Type.Object({
+			path: Type.String({ description: "Path to the file to read" }),
+			offset: Type.Optional(Type.Number({ description: "Line number to start from (1-indexed)" })),
+			limit: Type.Optional(Type.Number({ description: "Maximum number of lines to read" }))
+		}),
+		async execute(_toolCallId, params, signal) {
+			throwIfAborted(signal);
+			try {
+				if ((await env.stat(params.path)).isDirectory) {
+					const entries = await env.readdir(params.path);
+					return {
+						content: [{
+							type: "text",
+							text: entries.join("\n") || "(empty directory)"
+						}],
+						details: {
+							path: params.path,
+							isDirectory: true,
+							entries: entries.length
+						}
+					};
+				}
+			} catch {}
+			const allLines = (await env.readFile(params.path)).split("\n");
+			const startLine = params.offset ? Math.max(0, params.offset - 1) : 0;
+			if (startLine >= allLines.length) throw new Error(`Offset ${params.offset} is beyond end of file (${allLines.length} lines total)`);
+			const endLine = params.limit ? startLine + params.limit : allLines.length;
+			const { text: truncatedText, wasTruncated } = truncateHead(allLines.slice(startLine, endLine), MAX_READ_LINES, MAX_READ_BYTES);
+			let output = truncatedText;
+			if (wasTruncated) {
+				const shownEnd = startLine + truncatedText.split("\n").length;
+				output += `\n\n[Showing lines ${startLine + 1}-${shownEnd} of ${allLines.length}. Use offset=${shownEnd + 1} to continue.]`;
+			}
+			return {
+				content: [{
+					type: "text",
+					text: output
+				}],
+				details: {
+					path: params.path,
+					lines: allLines.length
+				}
+			};
+		}
+	};
+}
+function createWriteTool(env) {
+	return {
+		name: "write",
+		label: "Write File",
+		description: "Write content to a file. Creates the file and parent directories if they do not exist.",
+		parameters: Type.Object({
+			path: Type.String({ description: "Path to the file to write" }),
+			content: Type.String({ description: "Content to write to the file" })
+		}),
+		async execute(_toolCallId, params, signal) {
+			throwIfAborted(signal);
+			const resolved = env.resolvePath(params.path);
+			const dir = resolved.replace(/\/[^/]*$/, "");
+			if (dir && dir !== resolved) await env.mkdir(dir, { recursive: true });
+			await env.writeFile(resolved, params.content);
+			return {
+				content: [{
+					type: "text",
+					text: `Successfully wrote ${params.content.length} bytes to ${params.path}`
+				}],
+				details: {
+					path: params.path,
+					size: params.content.length
+				}
+			};
+		}
+	};
+}
+function createEditTool(env) {
+	return {
+		name: "edit",
+		label: "Edit File",
+		description: "Edit a file using exact text replacement. The oldText must match a unique region of the file. Use replaceAll to replace all occurrences.",
+		parameters: Type.Object({
+			path: Type.String({ description: "Path to the file to edit" }),
+			oldText: Type.String({ description: "Exact text to find (must be unique)" }),
+			newText: Type.String({ description: "Replacement text" }),
+			replaceAll: Type.Optional(Type.Boolean({ description: "Replace all occurrences" }))
+		}),
+		async execute(_toolCallId, params, signal) {
+			throwIfAborted(signal);
+			const content = await env.readFile(params.path);
+			if (params.replaceAll) {
+				const newContent = content.replaceAll(params.oldText, params.newText);
+				if (newContent === content) throw new Error(`Could not find the text in ${params.path}. No changes made.`);
+				await env.writeFile(params.path, newContent);
+				const count = content.split(params.oldText).length - 1;
+				return {
+					content: [{
+						type: "text",
+						text: `Replaced ${count} occurrences in ${params.path}`
+					}],
+					details: {
+						path: params.path,
+						replacements: count
+					}
+				};
+			}
+			const occurrences = countOccurrences(content, params.oldText);
+			if (occurrences === 0) throw new Error(`Could not find the exact text in ${params.path}. Make sure your oldText matches exactly, including whitespace and indentation.`);
+			if (occurrences > 1) throw new Error(`Found ${occurrences} occurrences of the text in ${params.path}. Provide more surrounding context to make the match unique, or use replaceAll.`);
+			const newContent = content.replace(params.oldText, params.newText);
+			await env.writeFile(params.path, newContent);
+			return {
+				content: [{
+					type: "text",
+					text: `Successfully edited ${params.path}`
+				}],
+				details: { path: params.path }
+			};
+		}
+	};
+}
+function createBashTool(env) {
+	return {
+		name: "bash",
+		label: "Run Command",
+		description: "Execute a bash command. Returns stdout and stderr. Output is truncated to the last 2000 lines or 50KB.",
+		parameters: Type.Object({
+			command: Type.String({ description: "Bash command to execute" }),
+			timeout: Type.Optional(Type.Number({ description: "Timeout in seconds" }))
+		}),
+		async execute(_toolCallId, params, signal) {
+			throwIfAborted(signal);
+			return formatBashResult(await env.exec(params.command), params.command);
+		}
+	};
+}
+function formatBashResult(result, command) {
+	const { text: output } = truncateTail((result.stdout + (result.stderr ? "\n" + result.stderr : "")).trim(), MAX_READ_LINES, MAX_READ_BYTES);
+	if (result.exitCode !== 0) throw new Error(`${output}\n\nCommand exited with code ${result.exitCode}`);
+	return {
+		content: [{
+			type: "text",
+			text: output || "(no output)"
+		}],
+		details: {
+			command,
+			exitCode: result.exitCode
+		}
+	};
+}
+function createGrepTool(env) {
+	return {
+		name: "grep",
+		label: "Search Files",
+		description: "Search file contents for a regex pattern. Returns matching lines with file paths and line numbers.",
+		parameters: Type.Object({
+			pattern: Type.String({ description: "Search pattern (regex)" }),
+			path: Type.Optional(Type.String({ description: "Directory or file to search (default: .)" })),
+			include: Type.Optional(Type.String({ description: "Glob filter, e.g. \"*.ts\"" }))
+		}),
+		async execute(_toolCallId, params, signal) {
+			throwIfAborted(signal);
+			const searchPath = params.path || ".";
+			let cmd = `grep -rn "${escapeShellArg(params.pattern)}" ${escapeShellArg(searchPath)}`;
+			if (params.include) cmd = `grep -rn --include="${escapeShellArg(params.include)}" "${escapeShellArg(params.pattern)}" ${escapeShellArg(searchPath)}`;
+			const result = await env.exec(cmd);
+			if (result.exitCode === 1 && !result.stdout.trim()) return {
+				content: [{
+					type: "text",
+					text: "No matches found."
+				}],
+				details: { matchCount: 0 }
+			};
+			if (result.exitCode > 1) throw new Error(`grep failed: ${result.stderr}`);
+			const lines = result.stdout.trim().split("\n");
+			let finalOutput = lines.slice(0, MAX_GREP_MATCHES).map((line) => line.length > MAX_GREP_LINE_LENGTH ? line.slice(0, MAX_GREP_LINE_LENGTH) + "..." : line).join("\n");
+			if (lines.length > MAX_GREP_MATCHES) finalOutput += `\n\n[Showing ${MAX_GREP_MATCHES} of ${lines.length} matches. Narrow your search.]`;
+			return {
+				content: [{
+					type: "text",
+					text: finalOutput
+				}],
+				details: { matchCount: Math.min(lines.length, MAX_GREP_MATCHES) }
+			};
+		}
+	};
+}
+function createGlobTool(env) {
+	return {
+		name: "glob",
+		label: "Find Files",
+		description: "Find files by glob pattern. Returns matching file paths.",
+		parameters: Type.Object({
+			pattern: Type.String({ description: "Glob pattern, e.g. \"**/*.ts\"" }),
+			path: Type.Optional(Type.String({ description: "Directory to search in (default: .)" }))
+		}),
+		async execute(_toolCallId, params, signal) {
+			throwIfAborted(signal);
+			const cmd = `find ${escapeShellArg(params.path || ".")} -type f -name "${escapeShellArg(params.pattern)}" 2>/dev/null | head -${MAX_GLOB_RESULTS}`;
+			const result = await env.exec(cmd);
+			if (result.exitCode !== 0 && !result.stdout.trim()) return {
+				content: [{
+					type: "text",
+					text: "No files found matching pattern."
+				}],
+				details: { matchCount: 0 }
+			};
+			const paths = result.stdout.trim().split("\n").filter(Boolean);
+			if (paths.length === 0) return {
+				content: [{
+					type: "text",
+					text: "No files found matching pattern."
+				}],
+				details: { matchCount: 0 }
+			};
+			return {
+				content: [{
+					type: "text",
+					text: paths.join("\n")
+				}],
+				details: { matchCount: paths.length }
+			};
+		}
+	};
+}
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw new Error("Operation aborted");
+}
+function countOccurrences(str, substr) {
+	let count = 0;
+	let pos = str.indexOf(substr, 0);
+	while (pos !== -1) {
+		count++;
+		pos = str.indexOf(substr, pos + substr.length);
+	}
+	return count;
+}
+function escapeShellArg(arg) {
+	return arg.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\$/g, "\\$").replace(/`/g, "\\`");
+}
+function truncateHead(lines, maxLines, maxBytes) {
+	let result = "";
+	let lineCount = 0;
+	let wasTruncated = false;
+	for (const line of lines) {
+		if (lineCount >= maxLines) {
+			wasTruncated = true;
+			break;
+		}
+		const next = lineCount === 0 ? line : "\n" + line;
+		if (result.length + next.length > maxBytes) {
+			wasTruncated = true;
+			break;
+		}
+		result += next;
+		lineCount++;
+	}
+	return {
+		text: result,
+		wasTruncated
+	};
+}
+function truncateTail(text, maxLines, maxBytes) {
+	const lines = text.split("\n");
+	if (lines.length <= maxLines && text.length <= maxBytes) return {
+		text,
+		wasTruncated: false
+	};
+	let result = lines.slice(-maxLines).join("\n");
+	if (result.length > maxBytes) result = result.slice(-maxBytes);
+	return {
+		text: result,
+		wasTruncated: true
+	};
+}
+
+//#endregion
+//#region src/compaction.ts
+const DEFAULT_COMPACTION_SETTINGS = {
+	enabled: true,
+	reserveTokens: 16384,
+	keepRecentTokens: 2e4
+};
+function calculateContextTokens(usage) {
+	return usage.totalTokens || usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+}
+function getAssistantUsage(msg) {
+	if (msg.role === "assistant" && "usage" in msg) {
+		const assistantMsg = msg;
+		if (assistantMsg.stopReason !== "aborted" && assistantMsg.stopReason !== "error" && assistantMsg.usage) return assistantMsg.usage;
+	}
+}
+function getLastAssistantUsageInfo(messages) {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const msg = messages[i];
+		const usage = getAssistantUsage(msg);
+		if (usage) return {
+			usage,
+			index: i
+		};
+	}
+}
+/** chars/4 heuristic. Conservative (overestimates). */
+function estimateTokens(message) {
+	let chars = 0;
+	switch (message.role) {
+		case "user": {
+			const { content } = message;
+			if (typeof content === "string") chars = content.length;
+			else if (Array.isArray(content)) {
+				for (const block of content) if (block.type === "text") chars += block.text.length;
+			}
+			return Math.ceil(chars / 4);
+		}
+		case "assistant": {
+			const { content } = message;
+			for (const block of content) if (block.type === "text") chars += block.text.length;
+			else if (block.type === "thinking") chars += block.thinking.length;
+			else if (block.type === "toolCall") chars += block.name.length + JSON.stringify(block.arguments).length;
+			return Math.ceil(chars / 4);
+		}
+		case "toolResult": {
+			const { content } = message;
+			for (const block of content) if (block.type === "text") chars += block.text.length;
+			else if (block.type === "image") chars += 4800;
+			return Math.ceil(chars / 4);
+		}
+	}
+	return 0;
+}
+function estimateContextTokens(messages) {
+	const usageInfo = getLastAssistantUsageInfo(messages);
+	if (!usageInfo) {
+		let estimated = 0;
+		for (const message of messages) estimated += estimateTokens(message);
+		return {
+			tokens: estimated,
+			usageTokens: 0,
+			trailingTokens: estimated,
+			lastUsageIndex: null
+		};
+	}
+	const usageTokens = calculateContextTokens(usageInfo.usage);
+	let trailingTokens = 0;
+	for (let i = usageInfo.index + 1; i < messages.length; i++) trailingTokens += estimateTokens(messages[i]);
+	return {
+		tokens: usageTokens + trailingTokens,
+		usageTokens,
+		trailingTokens,
+		lastUsageIndex: usageInfo.index
+	};
+}
+function shouldCompact(contextTokens, contextWindow, settings) {
+	if (!settings.enabled) return false;
+	return contextTokens > contextWindow - settings.reserveTokens;
+}
+function createFileOps() {
+	return {
+		read: /* @__PURE__ */ new Set(),
+		written: /* @__PURE__ */ new Set(),
+		edited: /* @__PURE__ */ new Set()
+	};
+}
+function extractFileOpsFromMessage(message, fileOps) {
+	if (message.role !== "assistant") return;
+	const assistant = message;
+	if (!Array.isArray(assistant.content)) return;
+	for (const block of assistant.content) {
+		if (block.type !== "toolCall") continue;
+		const args = block.arguments;
+		if (!args) continue;
+		const path = typeof args.path === "string" ? args.path : void 0;
+		if (!path) continue;
+		switch (block.name) {
+			case "read":
+				fileOps.read.add(path);
+				break;
+			case "write":
+				fileOps.written.add(path);
+				break;
+			case "edit":
+				fileOps.edited.add(path);
+				break;
+		}
+	}
+}
+function computeFileLists(fileOps) {
+	const modified = new Set([...fileOps.edited, ...fileOps.written]);
+	return {
+		readFiles: [...fileOps.read].filter((f) => !modified.has(f)).sort(),
+		modifiedFiles: [...modified].sort()
+	};
+}
+function formatFileOperations(readFiles, modifiedFiles) {
+	const sections = [];
+	if (readFiles.length > 0) sections.push(`<read-files>\n${readFiles.join("\n")}\n</read-files>`);
+	if (modifiedFiles.length > 0) sections.push(`<modified-files>\n${modifiedFiles.join("\n")}\n</modified-files>`);
+	if (sections.length === 0) return "";
+	return `\n\n${sections.join("\n\n")}`;
+}
+const TOOL_RESULT_MAX_CHARS = 2e3;
+function truncateForSummary(text, maxChars) {
+	if (text.length <= maxChars) return text;
+	const truncatedChars = text.length - maxChars;
+	return `${text.slice(0, maxChars)}\n\n[... ${truncatedChars} more characters truncated]`;
+}
+/** Serialize messages to text so the summarization model doesn't treat it as a conversation to continue. */
+function serializeConversation(messages) {
+	const parts = [];
+	for (const msg of messages) if (msg.role === "user") {
+		const { content } = msg;
+		const text = typeof content === "string" ? content : content.filter((c) => c.type === "text").map((c) => c.text).join("");
+		if (text) parts.push(`[User]: ${text}`);
+	} else if (msg.role === "assistant") {
+		const { content } = msg;
+		const textParts = [];
+		const thinkingParts = [];
+		const toolCalls = [];
+		for (const block of content) if (block.type === "text") textParts.push(block.text);
+		else if (block.type === "thinking") thinkingParts.push(block.thinking);
+		else if (block.type === "toolCall") {
+			const argsStr = Object.entries(block.arguments).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(", ");
+			toolCalls.push(`${block.name}(${argsStr})`);
+		}
+		if (thinkingParts.length > 0) parts.push(`[Assistant thinking]: ${thinkingParts.join("\n")}`);
+		if (textParts.length > 0) parts.push(`[Assistant]: ${textParts.join("\n")}`);
+		if (toolCalls.length > 0) parts.push(`[Assistant tool calls]: ${toolCalls.join("; ")}`);
+	} else if (msg.role === "toolResult") {
+		const { content } = msg;
+		const text = content.filter((c) => c.type === "text").map((c) => c.text).join("");
+		if (text) parts.push(`[Tool result]: ${truncateForSummary(text, TOOL_RESULT_MAX_CHARS)}`);
+	}
+	return parts.join("\n\n");
+}
+const SUMMARIZATION_SYSTEM_PROMPT = "You are a context summarization assistant. Your task is to read a conversation between a user and an AI coding assistant, then produce a structured summary following the exact format specified.\n\nDo NOT continue the conversation. Do NOT respond to any questions in the conversation. ONLY output the structured summary.";
+const SUMMARIZATION_PROMPT = `The messages above are a conversation to summarize. Create a structured context checkpoint summary that another LLM will use to continue the work.
+
+Use this EXACT format:
+
+## Goal
+[What is the user trying to accomplish? Can be multiple items if the session covers different tasks.]
+
+## Constraints & Preferences
+- [Any constraints, preferences, or requirements mentioned by user]
+- [Or "(none)" if none were mentioned]
+
+## Progress
+### Done
+- [x] [Completed tasks/changes]
+
+### In Progress
+- [ ] [Current work]
+
+### Blocked
+- [Issues preventing progress, if any]
+
+## Key Decisions
+- **[Decision]**: [Brief rationale]
+
+## Next Steps
+1. [Ordered list of what should happen next]
+
+## Critical Context
+- [Any data, examples, or references needed to continue]
+- [Or "(none)" if not applicable]
+
+Keep each section concise. Preserve exact file paths, function names, and error messages.`;
+const UPDATE_SUMMARIZATION_PROMPT = `The messages above are NEW conversation messages to incorporate into the existing summary provided in <previous-summary> tags.
+
+Update the existing structured summary with new information. RULES:
+- PRESERVE all existing information from the previous summary
+- ADD new progress, decisions, and context from the new messages
+- UPDATE the Progress section: move items from "In Progress" to "Done" when completed
+- UPDATE "Next Steps" based on what was accomplished
+- PRESERVE exact file paths, function names, and error messages
+- If something is no longer relevant, you may remove it
+
+Use this EXACT format:
+
+## Goal
+[Preserve existing goals, add new ones if the task expanded]
+
+## Constraints & Preferences
+- [Preserve existing, add new ones discovered]
+
+## Progress
+### Done
+- [x] [Include previously done items AND newly completed items]
+
+### In Progress
+- [ ] [Current work - update based on progress]
+
+### Blocked
+- [Current blockers - remove if resolved]
+
+## Key Decisions
+- **[Decision]**: [Brief rationale] (preserve all previous, add new)
+
+## Next Steps
+1. [Update based on current state]
+
+## Critical Context
+- [Preserve important context, add new if needed]
+
+Keep each section concise. Preserve exact file paths, function names, and error messages.`;
+const TURN_PREFIX_SUMMARIZATION_PROMPT = `This is the PREFIX of a turn that was too large to keep. The SUFFIX (recent work) is retained.
+
+Summarize the prefix to provide context for the retained suffix:
+
+## Original Request
+[What did the user ask for in this turn?]
+
+## Early Progress
+- [Key decisions and work done in the prefix]
+
+## Context for Suffix
+- [Information needed to understand the retained recent work]
+
+Be concise. Focus on what's needed to understand the kept suffix.`;
+/** Valid cut points: user or assistant messages. Never cut at toolResult. */
+function findValidCutPoints(messages, start, end) {
+	const cutPoints = [];
+	for (let i = start; i < end; i++) {
+		const role = messages[i].role;
+		if (role === "user" || role === "assistant") cutPoints.push(i);
+	}
+	return cutPoints;
+}
+function findTurnStartIndex(messages, index, start) {
+	for (let i = index; i >= start; i--) if (messages[i].role === "user") return i;
+	return -1;
+}
+function findCutPoint(messages, start, end, keepRecentTokens) {
+	const cutPoints = findValidCutPoints(messages, start, end);
+	if (cutPoints.length === 0) return {
+		firstKeptIndex: start,
+		turnStartIndex: -1,
+		isSplitTurn: false
+	};
+	let accumulatedTokens = 0;
+	let cutIndex = cutPoints[0];
+	for (let i = end - 1; i >= start; i--) {
+		const messageTokens = estimateTokens(messages[i]);
+		accumulatedTokens += messageTokens;
+		if (accumulatedTokens >= keepRecentTokens) {
+			for (let c = 0; c < cutPoints.length; c++) if (cutPoints[c] >= i) {
+				cutIndex = cutPoints[c];
+				break;
+			}
+			break;
+		}
+	}
+	const isUserMessage = messages[cutIndex].role === "user";
+	const turnStartIndex = isUserMessage ? -1 : findTurnStartIndex(messages, cutIndex, start);
+	return {
+		firstKeptIndex: cutIndex,
+		turnStartIndex,
+		isSplitTurn: !isUserMessage && turnStartIndex !== -1
+	};
+}
+/** Pure function — no I/O. Finds cut point, extracts messages to summarize, tracks file ops. */
+function prepareCompaction(messages, settings, previousCompaction) {
+	if (messages.length === 0) return void 0;
+	const boundaryStart = previousCompaction ? previousCompaction.firstKeptIndex : 0;
+	const boundaryEnd = messages.length;
+	const tokensBefore = estimateContextTokens(messages).tokens;
+	const cutPoint = findCutPoint(messages, boundaryStart, boundaryEnd, settings.keepRecentTokens);
+	if (cutPoint.firstKeptIndex <= boundaryStart) return void 0;
+	const historyEnd = cutPoint.isSplitTurn ? cutPoint.turnStartIndex : cutPoint.firstKeptIndex;
+	const messagesToSummarize = messages.slice(boundaryStart, historyEnd);
+	const turnPrefixMessages = cutPoint.isSplitTurn ? messages.slice(cutPoint.turnStartIndex, cutPoint.firstKeptIndex) : [];
+	const fileOps = createFileOps();
+	if (previousCompaction?.details) {
+		for (const f of previousCompaction.details.readFiles ?? []) fileOps.read.add(f);
+		for (const f of previousCompaction.details.modifiedFiles ?? []) fileOps.edited.add(f);
+	}
+	for (const msg of messagesToSummarize) extractFileOpsFromMessage(msg, fileOps);
+	for (const msg of turnPrefixMessages) extractFileOpsFromMessage(msg, fileOps);
+	return {
+		firstKeptIndex: cutPoint.firstKeptIndex,
+		messagesToSummarize,
+		turnPrefixMessages,
+		isSplitTurn: cutPoint.isSplitTurn,
+		tokensBefore,
+		previousSummary: previousCompaction?.summary,
+		fileOps,
+		settings
+	};
+}
+async function generateSummary(currentMessages, model, reserveTokens, apiKey, signal, previousSummary) {
+	const maxTokens = Math.min(Math.floor(.8 * reserveTokens), 16e3);
+	const basePrompt = previousSummary ? UPDATE_SUMMARIZATION_PROMPT : SUMMARIZATION_PROMPT;
+	let promptText = `<conversation>\n${serializeConversation(currentMessages)}\n</conversation>\n\n`;
+	if (previousSummary) promptText += `<previous-summary>\n${previousSummary}\n</previous-summary>\n\n`;
+	promptText += basePrompt;
+	const summarizationMessages = [{
+		role: "user",
+		content: [{
+			type: "text",
+			text: promptText
+		}],
+		timestamp: Date.now()
+	}];
+	const completionOptions = {
+		maxTokens,
+		signal
+	};
+	if (apiKey) completionOptions.apiKey = apiKey;
+	if (model.reasoning) completionOptions.reasoning = "high";
+	const response = await completeSimple(model, {
+		systemPrompt: SUMMARIZATION_SYSTEM_PROMPT,
+		messages: summarizationMessages
+	}, completionOptions);
+	if (response.stopReason === "error") throw new Error(`Summarization failed: ${response.errorMessage || "Unknown error"}`);
+	return response.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+}
+async function generateTurnPrefixSummary(messages, model, reserveTokens, apiKey, signal) {
+	const maxTokens = Math.min(Math.floor(.5 * reserveTokens), 16e3);
+	const summarizationMessages = [{
+		role: "user",
+		content: [{
+			type: "text",
+			text: `<conversation>\n${serializeConversation(messages)}\n</conversation>\n\n${TURN_PREFIX_SUMMARIZATION_PROMPT}`
+		}],
+		timestamp: Date.now()
+	}];
+	const completionOptions = {
+		maxTokens,
+		signal
+	};
+	if (apiKey) completionOptions.apiKey = apiKey;
+	const response = await completeSimple(model, {
+		systemPrompt: SUMMARIZATION_SYSTEM_PROMPT,
+		messages: summarizationMessages
+	}, completionOptions);
+	if (response.stopReason === "error") throw new Error(`Turn prefix summarization failed: ${response.errorMessage || "Unknown error"}`);
+	return response.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+}
+async function compact(preparation, model, apiKey, signal) {
+	const { firstKeptIndex, messagesToSummarize, turnPrefixMessages, isSplitTurn, tokensBefore, previousSummary, fileOps, settings } = preparation;
+	let summary;
+	if (isSplitTurn && turnPrefixMessages.length > 0) {
+		const [historyResult, turnPrefixResult] = await Promise.all([messagesToSummarize.length > 0 ? generateSummary(messagesToSummarize, model, settings.reserveTokens, apiKey, signal, previousSummary) : Promise.resolve("No prior history."), generateTurnPrefixSummary(turnPrefixMessages, model, settings.reserveTokens, apiKey, signal)]);
+		summary = `${historyResult}\n\n---\n\n**Turn Context (split turn):**\n\n${turnPrefixResult}`;
+	} else summary = await generateSummary(messagesToSummarize, model, settings.reserveTokens, apiKey, signal, previousSummary);
+	const { readFiles, modifiedFiles } = computeFileLists(fileOps);
+	summary += formatFileOperations(readFiles, modifiedFiles);
+	return {
+		summary,
+		firstKeptIndex,
+		tokensBefore,
+		details: {
+			readFiles,
+			modifiedFiles
+		}
+	};
+}
+function buildCompactedMessages(messages, result) {
+	return [{
+		role: "user",
+		content: [{
+			type: "text",
+			text: `[Context Summary]\n\n${result.summary}`
+		}],
+		timestamp: Date.now()
+	}, ...messages.slice(result.firstKeptIndex)];
+}
+
+//#endregion
+//#region src/result.ts
+const HEADLESS_PREAMBLE = "You are running in headless mode with no human operator. Work autonomously — never ask questions, never wait for user input. Make your best judgment and proceed independently.";
+function buildResultInstructions(schema) {
+	const { $schema: _, ...schemaWithoutMeta } = toJsonSchema(schema, { errorMode: "ignore" });
+	return [
+		"",
+		"```json",
+		JSON.stringify(schemaWithoutMeta, null, 2),
+		"```",
+		"",
+		"Example: (Object)",
+		"---RESULT_START---",
+		"{\"key\": \"value\"}",
+		"---RESULT_END---",
+		"",
+		"Example: (String)",
+		"---RESULT_START---",
+		"Hello, world!",
+		"---RESULT_END---"
+	].join("\n");
+}
+/** Follow-up prompt used when the LLM forgets to include RESULT_START/RESULT_END delimiters. */
+function buildResultExtractionPrompt(schema) {
+	return [
+		"Your task is complete. Now respond with ONLY your final result.",
+		"No explanation, no preamble — just the result in the following format, conforming to this schema:",
+		buildResultInstructions(schema)
+	].join("\n");
+}
+function buildSkillPrompt(skillInstructions, args, schema) {
+	const parts = [
+		HEADLESS_PREAMBLE,
+		"",
+		skillInstructions
+	];
+	if (args && Object.keys(args).length > 0) parts.push(`\nArguments:\n${JSON.stringify(args, null, 2)}`);
+	if (schema) {
+		parts.push("When complete, you MUST output your result between these exact delimiters conforming to this schema:");
+		parts.push(buildResultInstructions(schema));
+	}
+	return parts.join("\n");
+}
+function buildPromptText(text, schema) {
+	const parts = [
+		HEADLESS_PREAMBLE,
+		"",
+		text
+	];
+	if (schema) {
+		parts.push("When complete, you MUST output your result between these exact delimiters conforming to this schema:");
+		parts.push(buildResultInstructions(schema));
+	}
+	return parts.join("\n");
+}
+/** Extract the last ---RESULT_START---/---RESULT_END--- block from agent text and validate against schema. */
+function extractResult(text, schema) {
+	const resultBlock = extractLastResultBlock(text);
+	if (resultBlock === null) throw new ResultExtractionError("No ---RESULT_START--- / ---RESULT_END--- block found in the assistant response.", text);
+	let result = resultBlock;
+	if (schema.type === "object" || schema.type === "array") try {
+		result = JSON.parse(resultBlock);
+	} catch {
+		throw new ResultExtractionError("Result block contains invalid JSON for the expected schema.", resultBlock);
+	}
+	const parsed = v.safeParse(schema, result);
+	if (!parsed.success) throw new ResultExtractionError(`Result does not match the expected schema: ${parsed.issues.map((i) => i.message).join(", ")}`, resultBlock);
+	return parsed.output;
+}
+function extractLastResultBlock(text) {
+	const matches = text.matchAll(/---RESULT_START---\s*\n([\s\S]*?)---RESULT_END---/g);
+	let lastMatch = null;
+	for (const match of matches) lastMatch = match[1]?.trim() ?? null;
+	return lastMatch;
+}
+var ResultExtractionError = class extends Error {
+	constructor(message, rawOutput) {
+		super(message);
+		this.rawOutput = rawOutput;
+		this.name = "ResultExtractionError";
+	}
+};
+
+//#endregion
+//#region src/session.ts
+/** Internal session implementation. Not exported publicly — wrapped by FlueSession. */
+/** In-memory session store. Sessions persist for the lifetime of the process. */
+var InMemorySessionStore = class {
+	store = /* @__PURE__ */ new Map();
+	async save(id, data) {
+		this.store.set(id, data);
+	}
+	async load(id) {
+		return this.store.get(id) ?? null;
+	}
+	async delete(id) {
+		this.store.delete(id);
+	}
+};
+var Session = class Session {
+	id;
+	metadata;
+	agent;
+	config;
+	env;
+	store;
+	createdAt;
+	compactionSettings;
+	lastCompaction;
+	overflowRecoveryAttempted = false;
+	compactionAbortController;
+	eventCallback;
+	builtinTools;
+	constructor(id, config, env, store, existingData, onAgentEvent) {
+		this.id = id;
+		this.config = config;
+		this.env = env;
+		this.store = store;
+		this.metadata = existingData?.metadata ?? {};
+		this.createdAt = existingData?.createdAt;
+		this.lastCompaction = existingData?.lastCompaction;
+		const cc = config.compaction;
+		this.compactionSettings = {
+			enabled: cc?.enabled ?? DEFAULT_COMPACTION_SETTINGS.enabled,
+			reserveTokens: cc?.reserveTokens ?? DEFAULT_COMPACTION_SETTINGS.reserveTokens,
+			keepRecentTokens: cc?.keepRecentTokens ?? DEFAULT_COMPACTION_SETTINGS.keepRecentTokens
+		};
+		const systemPrompt = config.systemPrompt;
+		const tools = createTools(env);
+		this.builtinTools = tools;
+		const previousMessages = existingData?.messages ?? [];
+		this.agent = new Agent({
+			initialState: {
+				systemPrompt,
+				model: config.model,
+				tools,
+				messages: previousMessages
+			},
+			toolExecution: "parallel"
+		});
+		this.eventCallback = onAgentEvent;
+		const emit = onAgentEvent;
+		this.agent.subscribe(async (event) => {
+			switch (event.type) {
+				case "agent_start":
+					emit?.({ type: "agent_start" });
+					break;
+				case "message_update": {
+					const aEvent = event.assistantMessageEvent;
+					if (aEvent.type === "text_delta") emit?.({
+						type: "text_delta",
+						text: aEvent.delta
+					});
+					break;
+				}
+				case "tool_execution_start":
+					emit?.({
+						type: "tool_start",
+						toolName: event.toolName,
+						toolCallId: event.toolCallId,
+						args: event.args
+					});
+					break;
+				case "tool_execution_end":
+					emit?.({
+						type: "tool_end",
+						toolName: event.toolName,
+						toolCallId: event.toolCallId,
+						isError: event.isError,
+						result: event.result
+					});
+					break;
+				case "turn_end":
+					emit?.({ type: "turn_end" });
+					break;
+				case "agent_end": {
+					const messages = this.agent.state.messages;
+					const lastMsg = messages[messages.length - 1];
+					if (lastMsg?.role === "assistant") await this.checkCompaction(lastMsg);
+					emit?.({ type: "done" });
+					break;
+				}
+			}
+		});
+	}
+	async prompt(text, options) {
+		this.resolveModelForCall(options?.model, options?.role);
+		const promptWithRole = this.injectRoleInstructions(text, options?.role);
+		const schema = options?.result;
+		const fullPrompt = buildPromptText(promptWithRole, schema);
+		if (options?.commands) this.assertCommandSupport(options.commands);
+		const registeredCommandNames = options?.commands ? this.registerCommands(options.commands) : [];
+		const registeredToolNames = options?.tools ? this.registerCustomTools(options.tools) : [];
+		try {
+			await this.agent.prompt(fullPrompt);
+			await this.agent.waitForIdle();
+			this.throwIfError("prompt");
+			await this.save();
+			if (schema) return this.extractResultWithRetry(schema);
+			return { text: this.getAssistantText() };
+		} finally {
+			this.unregisterCommands(registeredCommandNames);
+			if (registeredToolNames.length > 0) this.unregisterCustomTools();
+		}
+	}
+	async skill(name, options) {
+		const registeredSkill = this.config.skills[name];
+		if (!registeredSkill) throw new Error(`Skill "${name}" not registered. Available: ${Object.keys(this.config.skills).join(", ") || "(none)"}`);
+		this.resolveModelForCall(options?.model, options?.role);
+		const schema = options?.result;
+		const skillPrompt = buildSkillPrompt(registeredSkill.instructions, options?.args, schema);
+		const promptWithRole = this.injectRoleInstructions(skillPrompt, options?.role);
+		if (options?.commands) this.assertCommandSupport(options.commands);
+		const registeredCommandNames = options?.commands ? this.registerCommands(options.commands) : [];
+		const registeredToolNames = options?.tools ? this.registerCustomTools(options.tools) : [];
+		try {
+			await this.agent.prompt(promptWithRole);
+			await this.agent.waitForIdle();
+			this.throwIfError(`skill("${name}")`);
+			await this.save();
+			if (schema) return this.extractResultWithRetry(schema);
+			return { text: this.getAssistantText() };
+		} finally {
+			this.unregisterCommands(registeredCommandNames);
+			if (registeredToolNames.length > 0) this.unregisterCustomTools();
+		}
+	}
+	async shell(command, options) {
+		if (options?.commands) this.assertCommandSupport(options.commands);
+		const registeredNames = options?.commands ? this.registerCommands(options.commands) : [];
+		try {
+			const result = await this.env.exec(command, {
+				env: options?.env,
+				cwd: options?.cwd
+			});
+			return {
+				stdout: result.stdout,
+				stderr: result.stderr,
+				exitCode: result.exitCode
+			};
+		} finally {
+			this.unregisterCommands(registeredNames);
+		}
+	}
+	async task(prompt, options) {
+		if (!options?.workspace) throw new Error("[flue] task() requires a workspace option.");
+		const taskCwd = options.workspace.startsWith("/") ? options.workspace : normalizePath(this.env.cwd + "/" + options.workspace);
+		function taskResolvePath(p) {
+			if (p.startsWith("/")) return normalizePath(p);
+			if (taskCwd === "/") return normalizePath("/" + p);
+			return normalizePath(taskCwd + "/" + p);
+		}
+		const parentEnv = this.env;
+		const taskEnv = {
+			exec: (cmd, opts) => parentEnv.exec(cmd, {
+				cwd: opts?.cwd ?? taskCwd,
+				env: opts?.env
+			}),
+			readFile: (p) => parentEnv.readFile(taskResolvePath(p)),
+			readFileBuffer: (p) => parentEnv.readFileBuffer(taskResolvePath(p)),
+			writeFile: (p, c) => parentEnv.writeFile(taskResolvePath(p), c),
+			stat: (p) => parentEnv.stat(taskResolvePath(p)),
+			readdir: (p) => parentEnv.readdir(taskResolvePath(p)),
+			exists: (p) => parentEnv.exists(taskResolvePath(p)),
+			mkdir: (p, o) => parentEnv.mkdir(taskResolvePath(p), o),
+			rm: (p, o) => parentEnv.rm(taskResolvePath(p), o),
+			cwd: taskCwd,
+			resolvePath: taskResolvePath,
+			commandSupport: parentEnv.commandSupport,
+			cleanup: async () => {}
+		};
+		const localContext = await discoverSessionContext(taskEnv);
+		let taskModel = this.config.model;
+		const taskRole = options?.role ? this.config.roles[options.role] : void 0;
+		if (taskRole?.model && this.config.resolveModel) taskModel = this.config.resolveModel(taskRole.model);
+		if (options?.model && this.config.resolveModel) taskModel = this.config.resolveModel(options.model);
+		const taskConfig = {
+			systemPrompt: localContext.systemPrompt,
+			skills: localContext.skills,
+			roles: this.config.roles,
+			model: taskModel,
+			resolveModel: this.config.resolveModel,
+			compaction: this.config.compaction
+		};
+		this.eventCallback?.({
+			type: "task_start",
+			workspace: taskCwd
+		});
+		const taskStore = new InMemorySessionStore();
+		const taskSession = new Session(`${this.id}:task:${Date.now()}`, taskConfig, taskEnv, taskStore, null, this.eventCallback);
+		try {
+			const promptOpts = { role: options?.role };
+			if (options?.result) promptOpts.result = options.result;
+			return await taskSession.prompt(prompt, promptOpts);
+		} finally {
+			this.eventCallback?.({ type: "task_end" });
+			await taskSession.destroy();
+		}
+	}
+	abort() {
+		this.agent.abort();
+	}
+	async destroy() {
+		this.agent.abort();
+		await this.store.delete(this.id);
+		await this.env.cleanup();
+	}
+	/** Precedence: prompt-level > role-level > agent-level default. */
+	resolveModelForCall(promptModel, roleName) {
+		let model = this.config.model;
+		if (roleName && this.config.roles[roleName]?.model && this.config.resolveModel) model = this.config.resolveModel(this.config.roles[roleName].model);
+		if (promptModel && this.config.resolveModel) model = this.config.resolveModel(promptModel);
+		this.agent.state.model = model;
+	}
+	injectRoleInstructions(text, roleName) {
+		if (!roleName) return text;
+		const role = this.config.roles[roleName];
+		if (!role) return text;
+		return `<role>\n${role.instructions}\n</role>\n\n${text}`;
+	}
+	assertCommandSupport(commands) {
+		if (commands.length === 0) return;
+		if (!this.env.commandSupport) throw new Error("[flue] Cannot use commands: this environment does not support command registration. Commands are only available in isolate sandbox mode. Remote sandboxes handle command execution at the platform level.");
+	}
+	registerCommands(commands) {
+		if (!this.env.commandSupport || commands.length === 0) return [];
+		const names = [];
+		for (const cmd of commands) {
+			this.env.commandSupport.register(cmd);
+			names.push(cmd.name);
+		}
+		return names;
+	}
+	unregisterCommands(names) {
+		if (!this.env.commandSupport || names.length === 0) return;
+		for (const name of names) this.env.commandSupport.unregister(name);
+	}
+	registerCustomTools(tools) {
+		const names = [];
+		for (const toolDef of tools) {
+			if (BUILTIN_TOOL_NAMES.has(toolDef.name)) throw new Error(`[flue] Custom tool "${toolDef.name}" conflicts with a built-in tool. Built-in tools: ${[...BUILTIN_TOOL_NAMES].join(", ")}`);
+			if (names.includes(toolDef.name)) throw new Error(`[flue] Duplicate custom tool name "${toolDef.name}". Tool names must be unique.`);
+			names.push(toolDef.name);
+		}
+		const agentTools = tools.map((toolDef) => ({
+			name: toolDef.name,
+			label: toolDef.name,
+			description: toolDef.description,
+			parameters: toolDef.parameters,
+			async execute(_toolCallId, params, signal) {
+				if (signal?.aborted) throw new Error("Operation aborted");
+				return {
+					content: [{
+						type: "text",
+						text: await toolDef.execute(params)
+					}],
+					details: { customTool: toolDef.name }
+				};
+			}
+		}));
+		this.agent.state.tools = [...this.agent.state.tools, ...agentTools];
+		return names;
+	}
+	unregisterCustomTools() {
+		this.agent.state.tools = [...this.builtinTools];
+	}
+	async save() {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const data = {
+			messages: this.agent.state.messages,
+			metadata: this.metadata,
+			createdAt: this.createdAt ?? now,
+			updatedAt: now,
+			lastCompaction: this.lastCompaction
+		};
+		if (!this.createdAt) this.createdAt = now;
+		await this.store.save(this.id, data);
+	}
+	async checkCompaction(assistantMessage) {
+		if (!this.compactionSettings.enabled) return;
+		if (assistantMessage.stopReason === "aborted") return;
+		const contextWindow = this.agent.state.model.contextWindow ?? 0;
+		if (isContextOverflow(assistantMessage, contextWindow)) {
+			if (this.overflowRecoveryAttempted) return;
+			this.overflowRecoveryAttempted = true;
+			console.error(`[flue:compaction] Overflow detected, compacting and retrying...`);
+			const messages = this.agent.state.messages;
+			const lastMsg = messages[messages.length - 1];
+			if (lastMsg && lastMsg.role === "assistant") this.agent.state.messages = messages.slice(0, -1);
+			await this.runCompaction("overflow", true);
+			return;
+		}
+		let contextTokens;
+		if (assistantMessage.stopReason === "error") {
+			const estimate = estimateContextTokens(this.agent.state.messages);
+			if (estimate.lastUsageIndex === null) return;
+			contextTokens = estimate.tokens;
+		} else contextTokens = calculateContextTokens(assistantMessage.usage);
+		if (shouldCompact(contextTokens, contextWindow, this.compactionSettings)) {
+			console.error(`[flue:compaction] Threshold reached — ${contextTokens} tokens used, window ${contextWindow}, reserve ${this.compactionSettings.reserveTokens}, triggering compaction`);
+			await this.runCompaction("threshold", false);
+		}
+	}
+	async runCompaction(reason, willRetry) {
+		this.compactionAbortController = new AbortController();
+		const messagesBefore = this.agent.state.messages.length;
+		try {
+			const model = this.agent.state.model;
+			const messages = this.agent.state.messages;
+			const preparation = prepareCompaction(messages, this.compactionSettings, this.lastCompaction);
+			if (!preparation) {
+				console.error(`[flue:compaction] Nothing to compact (no valid cut point found)`);
+				return;
+			}
+			console.error(`[flue:compaction] Summarizing ${preparation.messagesToSummarize.length} messages` + (preparation.isSplitTurn ? ` (split turn: ${preparation.turnPrefixMessages.length} prefix messages)` : "") + `, keeping messages from index ${preparation.firstKeptIndex}`);
+			const estimatedTokens = preparation.tokensBefore;
+			this.eventCallback?.({
+				type: "compaction_start",
+				reason,
+				estimatedTokens
+			});
+			const result = await compact(preparation, model, void 0, this.compactionAbortController.signal);
+			if (this.compactionAbortController.signal.aborted) return;
+			const newMessages = buildCompactedMessages(messages, result);
+			this.agent.state.messages = newMessages;
+			const messagesAfter = newMessages.length;
+			console.error(`[flue:compaction] Complete — messages: ${messagesBefore} → ${messagesAfter}, tokens before: ${result.tokensBefore}`);
+			this.eventCallback?.({
+				type: "compaction_end",
+				messagesBefore,
+				messagesAfter
+			});
+			this.lastCompaction = {
+				summary: result.summary,
+				firstKeptIndex: 1,
+				details: result.details
+			};
+			await this.save();
+			if (willRetry) {
+				const msgs = this.agent.state.messages;
+				const lastMsg = msgs[msgs.length - 1];
+				if (lastMsg?.role === "assistant" && lastMsg.stopReason === "error") this.agent.state.messages = msgs.slice(0, -1);
+				console.error(`[flue:compaction] Retrying after overflow recovery...`);
+				await this.agent.continue();
+			}
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			console.error(`[flue:compaction] Failed: ${errorMessage}`);
+		} finally {
+			this.compactionAbortController = void 0;
+		}
+	}
+	throwIfError(context) {
+		const errorMsg = this.agent.state.errorMessage;
+		if (errorMsg) throw new Error(`[flue] ${context} failed: ${errorMsg}`);
+	}
+	getAssistantText() {
+		const messages = this.agent.state.messages;
+		for (let i = messages.length - 1; i >= 0; i--) {
+			const msg = messages[i];
+			if (msg.role !== "assistant") continue;
+			const content = msg.content;
+			if (!Array.isArray(content)) continue;
+			const textParts = [];
+			for (const block of content) if (block.type === "text") textParts.push(block.text);
+			return textParts.join("\n");
+		}
+		return "";
+	}
+	async extractResultWithRetry(schema) {
+		const text = this.getAssistantText();
+		try {
+			return extractResult(text, schema);
+		} catch (err) {
+			if (!(err instanceof ResultExtractionError)) throw err;
+			if (!err.message.includes("RESULT_START")) throw err;
+			const followUpPrompt = buildResultExtractionPrompt(schema);
+			await this.agent.prompt(followUpPrompt);
+			await this.agent.waitForIdle();
+			await this.save();
+			return extractResult(this.getAssistantText(), schema);
+		}
+	}
+};
+function normalizePath(p) {
+	const parts = p.split("/");
+	const result = [];
+	for (const part of parts) {
+		if (part === "." || part === "") continue;
+		if (part === "..") result.pop();
+		else result.push(part);
+	}
+	return "/" + result.join("/");
+}
+
+//#endregion
+export { createTools as a, BUILTIN_TOOL_NAMES as i, Session as n, discoverSessionContext as o, normalizePath as r, parseFrontmatterFile as s, InMemorySessionStore as t };