@flue/sdk 0.3.0 → 0.3.2

package/dist/session-DukL3zwF.mjs

@@ -0,0 +1,1303 @@
+import { i as loadSkillByPath, n as createTools, t as BUILTIN_TOOL_NAMES } from "./agent-BB4lwAd5.mjs";
+import { completeSimple, isContextOverflow } from "@mariozechner/pi-ai";
+import { Agent } from "@mariozechner/pi-agent-core";
+import { toJsonSchema } from "@valibot/to-json-schema";
+import * as v from "valibot";
+
+//#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
+		}
+	};
+}
+
+//#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/env-utils.ts
+async function createScopedEnv(env, commands) {
+	if (env.scope) return env.scope({ commands });
+	if (commands.length > 0) throw new Error("[flue] Cannot use commands: this environment does not support scoped command execution. Commands are only available in BashFactory sandbox mode. Remote sandboxes handle command execution at the platform level.");
+	return env;
+}
+function mergeCommands(defaults, perCall) {
+	if (!perCall || perCall.length === 0) return defaults;
+	if (defaults.length === 0) return perCall;
+	const byName = /* @__PURE__ */ new Map();
+	for (const cmd of defaults) byName.set(cmd.name, cmd);
+	for (const cmd of perCall) byName.set(cmd.name, cmd);
+	return Array.from(byName.values());
+}
+
+//#endregion
+//#region src/roles.ts
+function assertRoleExists(roles, roleName) {
+	if (!roleName) return;
+	if (roles[roleName]) return;
+	const available = Object.keys(roles);
+	const list = available.length > 0 ? available.join(", ") : "(none defined)";
+	throw new Error(`[flue] Role "${roleName}" not registered. Available roles: ${list}. Define roles as markdown files under \`.flue/roles/\`.`);
+}
+function resolveEffectiveRole(options) {
+	const role = options.callRole ?? options.sessionRole ?? options.agentRole;
+	assertRoleExists(options.roles, role);
+	return role;
+}
+function resolveRoleModel(roles, roleName) {
+	assertRoleExists(roles, roleName);
+	return roleName ? roles[roleName]?.model : void 0;
+}
+
+//#endregion
+//#region src/session-history.ts
+var SessionHistory = class SessionHistory {
+	entries;
+	byId;
+	leafId;
+	constructor(entries, leafId) {
+		this.entries = [...entries];
+		this.leafId = leafId;
+		this.byId = new Map(this.entries.map((entry) => [entry.id, entry]));
+	}
+	static empty() {
+		return new SessionHistory([], null);
+	}
+	static fromData(data) {
+		if (!data) return SessionHistory.empty();
+		return new SessionHistory(data.entries, data.leafId);
+	}
+	getLeafId() {
+		return this.leafId;
+	}
+	getActivePath() {
+		const path = [];
+		let current = this.leafId ? this.byId.get(this.leafId) : void 0;
+		while (current) {
+			path.push(current);
+			current = current.parentId ? this.byId.get(current.parentId) : void 0;
+		}
+		return path.reverse();
+	}
+	buildContextEntries() {
+		const path = this.getActivePath();
+		const latestCompactionIndex = findLatestCompactionIndex(path);
+		if (latestCompactionIndex === -1) return pathToContextEntries(path);
+		const compaction = path[latestCompactionIndex];
+		const firstKeptIndex = path.findIndex((entry) => entry.id === compaction.firstKeptEntryId);
+		const keptStart = firstKeptIndex >= 0 ? firstKeptIndex : latestCompactionIndex + 1;
+		const context = [{
+			message: createContextSummaryMessage(compaction.summary, compaction.timestamp),
+			entry: compaction
+		}];
+		context.push(...pathToContextEntries(path.slice(keptStart, latestCompactionIndex)));
+		context.push(...pathToContextEntries(path.slice(latestCompactionIndex + 1)));
+		return context;
+	}
+	buildContext() {
+		return this.buildContextEntries().map((entry) => entry.message);
+	}
+	getLatestCompaction() {
+		const path = this.getActivePath();
+		for (let i = path.length - 1; i >= 0; i--) {
+			const entry = path[i];
+			if (entry.type === "compaction") return entry;
+		}
+	}
+	appendMessage(message, source) {
+		const entry = {
+			type: "message",
+			id: generateEntryId(this.byId),
+			parentId: this.leafId,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			message,
+			source
+		};
+		this.appendEntry(entry);
+		return entry.id;
+	}
+	appendMessages(messages, source) {
+		return messages.map((message) => this.appendMessage(message, source));
+	}
+	appendCompaction(input) {
+		if (!this.byId.has(input.firstKeptEntryId)) throw new Error(`[flue] Cannot compact: entry "${input.firstKeptEntryId}" does not exist.`);
+		const entry = {
+			type: "compaction",
+			id: generateEntryId(this.byId),
+			parentId: this.leafId,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			summary: input.summary,
+			firstKeptEntryId: input.firstKeptEntryId,
+			tokensBefore: input.tokensBefore,
+			details: input.details
+		};
+		this.appendEntry(entry);
+		return entry.id;
+	}
+	appendBranchSummary(summary, fromId, details) {
+		const entry = {
+			type: "branch_summary",
+			id: generateEntryId(this.byId),
+			parentId: this.leafId,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			fromId,
+			summary,
+			details
+		};
+		this.appendEntry(entry);
+		return entry.id;
+	}
+	removeLeafMessage(message) {
+		if (!this.leafId) return false;
+		const leaf = this.byId.get(this.leafId);
+		if (!leaf || leaf.type !== "message" || leaf.message !== message) return false;
+		this.byId.delete(leaf.id);
+		this.entries = this.entries.filter((entry) => entry.id !== leaf.id);
+		this.leafId = leaf.parentId;
+		return true;
+	}
+	toData(metadata, createdAt, updatedAt) {
+		return {
+			version: 2,
+			entries: [...this.entries],
+			leafId: this.leafId,
+			metadata,
+			createdAt,
+			updatedAt
+		};
+	}
+	appendEntry(entry) {
+		this.entries.push(entry);
+		this.byId.set(entry.id, entry);
+		this.leafId = entry.id;
+	}
+};
+function pathToContextEntries(path) {
+	const context = [];
+	for (const entry of path) if (entry.type === "message") context.push({
+		message: entry.message,
+		entry
+	});
+	else if (entry.type === "branch_summary") context.push({
+		message: createUserContextMessage(`[Branch Summary]\n\n${entry.summary}`, entry.timestamp),
+		entry
+	});
+	return context;
+}
+function findLatestCompactionIndex(path) {
+	for (let i = path.length - 1; i >= 0; i--) if (path[i].type === "compaction") return i;
+	return -1;
+}
+function createContextSummaryMessage(summary, timestamp) {
+	return createUserContextMessage(summary.startsWith("[Context Summary]") ? summary : `[Context Summary]\n\n${summary}`, timestamp);
+}
+function createUserContextMessage(text, timestamp) {
+	return {
+		role: "user",
+		content: [{
+			type: "text",
+			text
+		}],
+		timestamp: new Date(timestamp).getTime()
+	};
+}
+function generateEntryId(byId) {
+	for (let i = 0; i < 100; i++) {
+		const id = crypto.randomUUID().slice(0, 8);
+		if (!byId.has(id)) return id;
+	}
+	return crypto.randomUUID();
+}
+
+//#endregion
+//#region src/session.ts
+/** Internal session implementation. Not exported publicly — wrapped by FlueSession. */
+const MAX_SHELL_HISTORY_CHARS = 50 * 1024;
+const MAX_TASK_DEPTH = 4;
+/** 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 {
+	id;
+	metadata;
+	get role() {
+		return this.sessionRole;
+	}
+	harness;
+	storageKey;
+	config;
+	env;
+	store;
+	history;
+	createdAt;
+	compactionSettings;
+	overflowRecoveryAttempted = false;
+	compactionAbortController;
+	eventCallback;
+	agentCommands;
+	agentTools;
+	deleted = false;
+	activeOperation;
+	activeTasks = /* @__PURE__ */ new Set();
+	sessionRole;
+	taskDepth;
+	createTaskSession;
+	onDelete;
+	constructor(options) {
+		this.id = options.id;
+		this.storageKey = options.storageKey;
+		this.config = options.config;
+		this.env = options.env;
+		this.store = options.store;
+		this.agentCommands = options.agentCommands ?? [];
+		this.agentTools = options.agentTools ?? [];
+		this.sessionRole = options.sessionRole;
+		this.taskDepth = options.taskDepth ?? 0;
+		this.createTaskSession = options.createTaskSession;
+		this.onDelete = options.onDelete;
+		this.metadata = options.existingData?.metadata ?? {};
+		this.createdAt = options.existingData?.createdAt;
+		this.history = SessionHistory.fromData(options.existingData);
+		const cc = this.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 = this.config.systemPrompt;
+		assertRoleExists(this.config.roles, this.config.role);
+		assertRoleExists(this.config.roles, this.sessionRole);
+		const tools = [...this.createBuiltinTools(this.env, this.agentCommands, []), ...this.createCustomTools(this.agentTools)];
+		const previousMessages = this.history.buildContext();
+		this.harness = new Agent({
+			initialState: {
+				systemPrompt,
+				model: this.config.model,
+				tools,
+				messages: previousMessages
+			},
+			toolExecution: "parallel"
+		});
+		this.eventCallback = options.onAgentEvent;
+		this.harness.subscribe(async (event) => {
+			switch (event.type) {
+				case "agent_start":
+					this.emit({ type: "agent_start" });
+					break;
+				case "message_update": {
+					const aEvent = event.assistantMessageEvent;
+					if (aEvent.type === "text_delta") this.emit({
+						type: "text_delta",
+						text: aEvent.delta
+					});
+					break;
+				}
+				case "tool_execution_start":
+					this.emit({
+						type: "tool_start",
+						toolName: event.toolName,
+						toolCallId: event.toolCallId,
+						args: event.args
+					});
+					break;
+				case "tool_execution_end":
+					this.emit({
+						type: "tool_end",
+						toolName: event.toolName,
+						toolCallId: event.toolCallId,
+						isError: event.isError,
+						result: event.result
+					});
+					break;
+				case "turn_end":
+					this.emit({ type: "turn_end" });
+					break;
+				case "agent_end": break;
+			}
+		});
+	}
+	async prompt(text, options) {
+		return this.runOperation("prompt", async () => {
+			const role = this.resolveEffectiveRole(options?.role);
+			const schema = options?.result;
+			const fullPrompt = buildPromptText(text, schema);
+			const effectiveCommands = mergeCommands(this.agentCommands, options?.commands);
+			return this.withScopedRuntime({
+				commands: effectiveCommands,
+				tools: options?.tools ?? [],
+				role,
+				model: options?.model,
+				callSite: "this prompt() call"
+			}, async () => {
+				const beforeLength = this.harness.state.messages.length;
+				await this.harness.prompt(fullPrompt);
+				await this.harness.waitForIdle();
+				await this.syncHarnessMessagesSince(beforeLength, "prompt");
+				await this.checkLatestAssistantForCompaction();
+				this.throwIfError("prompt");
+				if (schema) return this.extractResultWithRetry(schema);
+				return { text: this.getAssistantText() };
+			});
+		});
+	}
+	async skill(name, options) {
+		return this.runOperation("skill", async () => {
+			const role = this.resolveEffectiveRole(options?.role);
+			let registeredSkill = this.config.skills[name];
+			if (!registeredSkill && (name.includes("/") || /\.(md|markdown)$/i.test(name))) {
+				const loaded = await loadSkillByPath(this.env, this.env.cwd, name);
+				if (loaded) registeredSkill = loaded;
+			}
+			if (!registeredSkill) {
+				const available = Object.keys(this.config.skills).join(", ") || "(none)";
+				throw new Error(`Skill "${name}" not registered. Available: ${available}. Skills can also be referenced by relative path under .agents/skills/ (e.g. "triage/reproduce.md").`);
+			}
+			const schema = options?.result;
+			const skillPrompt = buildSkillPrompt(registeredSkill.instructions, options?.args, schema);
+			const effectiveCommands = mergeCommands(this.agentCommands, options?.commands);
+			return this.withScopedRuntime({
+				commands: effectiveCommands,
+				tools: options?.tools ?? [],
+				role,
+				model: options?.model,
+				callSite: `this skill("${name}") call`
+			}, async () => {
+				const beforeLength = this.harness.state.messages.length;
+				await this.harness.prompt(skillPrompt);
+				await this.harness.waitForIdle();
+				await this.syncHarnessMessagesSince(beforeLength, "skill");
+				await this.checkLatestAssistantForCompaction();
+				this.throwIfError(`skill("${name}")`);
+				if (schema) return this.extractResultWithRetry(schema);
+				return { text: this.getAssistantText() };
+			});
+		});
+	}
+	async task(text, options) {
+		return (await this.runTask(text, options, void 0)).output;
+	}
+	async shell(command, options) {
+		return this.runOperation("shell", async () => {
+			const effectiveCommands = mergeCommands(this.agentCommands, options?.commands);
+			const result = await (await createScopedEnv(this.env, effectiveCommands)).exec(command, {
+				env: options?.env,
+				cwd: options?.cwd
+			});
+			const shellResult = {
+				stdout: result.stdout,
+				stderr: result.stderr,
+				exitCode: result.exitCode
+			};
+			const message = this.createShellMessage(command, shellResult, options);
+			this.history.appendMessage(message, "shell");
+			this.harness.state.messages = this.history.buildContext();
+			await this.save();
+			return shellResult;
+		});
+	}
+	abort() {
+		this.harness.abort();
+		this.compactionAbortController?.abort();
+		for (const task of this.activeTasks) task.abort();
+	}
+	close() {
+		if (this.deleted) return;
+		this.deleted = true;
+		this.abort();
+		this.onDelete?.();
+	}
+	async delete() {
+		if (this.deleted) return;
+		this.deleted = true;
+		this.abort();
+		await deleteSessionTree(this.store, this.storageKey);
+		this.onDelete?.();
+	}
+	resolveEffectiveRole(callRole) {
+		return resolveEffectiveRole({
+			roles: this.config.roles,
+			agentRole: this.config.role,
+			sessionRole: this.sessionRole,
+			callRole
+		});
+	}
+	/** Precedence: call-level > role-level > agent-level default. */
+	resolveModelForCall(promptModel, roleName, callSite) {
+		let model = this.config.model;
+		const roleModel = resolveRoleModel(this.config.roles, roleName);
+		if (roleModel && this.config.resolveModel) model = this.config.resolveModel(roleModel);
+		if (promptModel && this.config.resolveModel) model = this.config.resolveModel(promptModel);
+		return this.requireModel(model, callSite);
+	}
+	/**
+	* Throws a clear, actionable error when no model is configured for a call.
+	* Use with the resolved model (post-precedence) to guarantee we never hand
+	* `undefined` to the underlying agent.
+	*/
+	requireModel(model, callSite) {
+		if (model) return model;
+		throw new Error(`[flue] No model configured for ${callSite}. Pass \`{ model: "provider/model-id" }\` to \`init()\` for an agent-wide default, or to this prompt()/skill() call for a one-off override.`);
+	}
+	buildSystemPrompt(roleName) {
+		const parts = [this.config.systemPrompt];
+		if (!roleName) return parts.join("\n\n");
+		const role = this.config.roles[roleName];
+		if (!role) return parts.join("\n\n");
+		parts.push(`<role name="${role.name}">\n${role.instructions}\n</role>`);
+		return parts.filter(Boolean).join("\n\n");
+	}
+	createCustomTools(tools) {
+		this.validateCustomToolNames(tools);
+		return 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, signal)
+					}],
+					details: { customTool: toolDef.name }
+				};
+			}
+		}));
+	}
+	validateCustomToolNames(tools) {
+		const names = /* @__PURE__ */ new Set();
+		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.has(toolDef.name)) throw new Error(`[flue] Duplicate custom tool name "${toolDef.name}". Tool names must be unique.`);
+			names.add(toolDef.name);
+		}
+	}
+	createBuiltinTools(env, commands, tools, role, model) {
+		return createTools(env, {
+			roles: this.config.roles,
+			task: (params, signal) => this.runTaskForTool(params, commands, tools, role, model, signal)
+		});
+	}
+	async withScopedRuntime(options, fn) {
+		const customTools = this.createCustomTools([...this.agentTools, ...options.tools]);
+		const scopedEnv = await createScopedEnv(this.env, options.commands);
+		const previousTools = this.harness.state.tools;
+		const previousModel = this.harness.state.model;
+		const previousSystemPrompt = this.harness.state.systemPrompt;
+		this.harness.state.model = this.resolveModelForCall(options.model, options.role, options.callSite);
+		this.harness.state.systemPrompt = this.buildSystemPrompt(options.role);
+		this.harness.state.tools = [...this.createBuiltinTools(scopedEnv, options.commands, options.tools, options.role, options.model), ...customTools];
+		try {
+			return await fn();
+		} finally {
+			this.harness.state.tools = previousTools;
+			this.harness.state.model = previousModel;
+			this.harness.state.systemPrompt = previousSystemPrompt;
+		}
+	}
+	async runTaskForTool(params, commands, tools, inheritedRole, inheritedModel, signal) {
+		const result = await this.runTask(params.prompt, {
+			role: params.role ?? inheritedRole,
+			inheritedModel,
+			cwd: params.cwd,
+			commands,
+			tools
+		}, signal);
+		return {
+			content: [{
+				type: "text",
+				text: result.text || "(task completed with no text)"
+			}],
+			details: {
+				taskId: result.taskId,
+				sessionId: result.sessionId,
+				messageId: result.messageId,
+				role: result.role,
+				cwd: result.cwd
+			}
+		};
+	}
+	async runTask(text, options, signal) {
+		this.assertActive();
+		if (!this.createTaskSession) throw new Error("[flue] This session cannot create task sessions.");
+		if (this.taskDepth >= MAX_TASK_DEPTH) throw new Error(`[flue] Maximum task depth (${MAX_TASK_DEPTH}) exceeded.`);
+		if (signal?.aborted) throw new Error("Operation aborted");
+		const taskId = crypto.randomUUID();
+		const requestedRole = options?.role ?? this.sessionRole ?? this.config.role;
+		let child;
+		let abortListener;
+		this.emit({
+			type: "task_start",
+			taskId,
+			prompt: text,
+			role: requestedRole,
+			cwd: options?.cwd,
+			parentSessionId: this.id
+		});
+		try {
+			const role = this.resolveEffectiveRole(options?.role);
+			const commands = mergeCommands(this.agentCommands, options?.commands);
+			child = await this.createTaskSession({
+				parentSessionId: this.id,
+				taskId,
+				parentEnv: this.env,
+				cwd: options?.cwd,
+				role,
+				commands,
+				depth: this.taskDepth + 1
+			});
+			await this.recordTaskSession(child.id, child.storageKey, taskId);
+			this.activeTasks.add(child);
+			if (signal) {
+				abortListener = () => child?.abort();
+				signal.addEventListener("abort", abortListener, { once: true });
+				if (signal.aborted) throw new Error("Operation aborted");
+			}
+			const schema = options?.result;
+			const roleModel = resolveRoleModel(this.config.roles, role);
+			const childOptions = {
+				model: options?.model ?? (roleModel ? void 0 : options?.inheritedModel),
+				tools: options?.tools
+			};
+			if (schema) childOptions.result = schema;
+			const output = await child.prompt(text, childOptions);
+			const taskResult = {
+				output,
+				text: typeof output?.text === "string" ? output.text : child.getAssistantText(),
+				taskId,
+				sessionId: child.id,
+				messageId: child.getLatestAssistantMessageId(),
+				role,
+				cwd: options?.cwd
+			};
+			this.emit({
+				type: "task_end",
+				taskId,
+				isError: false,
+				result: taskResult.text,
+				parentSessionId: this.id
+			});
+			return taskResult;
+		} catch (error) {
+			this.emit({
+				type: "task_end",
+				taskId,
+				isError: true,
+				result: getErrorMessage(error),
+				parentSessionId: this.id
+			});
+			this.emit({
+				type: "error",
+				error: getErrorMessage(error)
+			});
+			throw error;
+		} finally {
+			if (signal && abortListener) signal.removeEventListener("abort", abortListener);
+			if (child) {
+				this.activeTasks.delete(child);
+				child.close();
+			}
+		}
+	}
+	async runOperation(operation, fn) {
+		return this.runExclusive(operation, async () => {
+			try {
+				return await fn();
+			} catch (error) {
+				this.emit({
+					type: "error",
+					error: getErrorMessage(error)
+				});
+				throw error;
+			} finally {
+				this.emit({ type: "idle" });
+			}
+		});
+	}
+	async runExclusive(operation, fn) {
+		this.assertActive();
+		if (this.activeOperation) throw new Error(`[flue] Session "${this.id}" is already running ${this.activeOperation}. Start another session for parallel conversation branches.`);
+		this.activeOperation = operation;
+		try {
+			return await fn();
+		} finally {
+			this.activeOperation = void 0;
+		}
+	}
+	emit(event) {
+		this.eventCallback?.({
+			...event,
+			sessionId: this.id
+		});
+	}
+	assertActive() {
+		if (this.deleted) throw new Error(`[flue] Session "${this.id}" has been deleted.`);
+	}
+	createShellMessage(command, result, options) {
+		return {
+			role: "user",
+			content: [{
+				type: "text",
+				text: formatShellHistory(command, result, options?.cwd ? `\ncwd: ${options.cwd}` : "", options?.env ? `\nenv: ${Object.keys(options.env).sort().join(", ")}` : "")
+			}],
+			timestamp: Date.now()
+		};
+	}
+	async syncHarnessMessagesSince(index, source) {
+		const messages = this.harness.state.messages.slice(index);
+		if (messages.length === 0) return;
+		this.history.appendMessages(messages, source);
+		await this.save();
+	}
+	async save() {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const data = this.history.toData(this.metadata, this.createdAt ?? now, now);
+		if (!this.createdAt) this.createdAt = now;
+		await this.store.save(this.storageKey, data);
+	}
+	async recordTaskSession(sessionId, storageKey, taskId) {
+		const taskSessions = Array.isArray(this.metadata.taskSessions) ? this.metadata.taskSessions : [];
+		if (!taskSessions.some((task) => task?.sessionId === sessionId)) {
+			taskSessions.push({
+				sessionId,
+				taskId,
+				storageKey
+			});
+			this.metadata.taskSessions = taskSessions;
+			await this.save();
+		}
+	}
+	async checkLatestAssistantForCompaction() {
+		const messages = this.harness.state.messages;
+		const lastMsg = messages[messages.length - 1];
+		if (lastMsg?.role === "assistant") await this.checkCompaction(lastMsg);
+	}
+	async checkCompaction(assistantMessage) {
+		if (!this.compactionSettings.enabled) return;
+		if (assistantMessage.stopReason === "aborted") return;
+		const contextWindow = this.harness.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.harness.state.messages;
+			const lastMsg = messages[messages.length - 1];
+			if (lastMsg && lastMsg.role === "assistant") {
+				this.harness.state.messages = messages.slice(0, -1);
+				this.history.removeLeafMessage(lastMsg);
+				await this.save();
+			}
+			await this.runCompaction("overflow", true);
+			return;
+		}
+		if (assistantMessage.stopReason === "error") return;
+		const 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.harness.state.messages.length;
+		try {
+			const model = this.harness.state.model;
+			const contextEntries = this.history.buildContextEntries();
+			const messages = contextEntries.map((entry) => entry.message);
+			const latestCompaction = this.history.getLatestCompaction();
+			const preparation = prepareCompaction(messages, this.compactionSettings, latestCompaction ? {
+				summary: latestCompaction.summary,
+				firstKeptIndex: 1,
+				details: latestCompaction.details
+			} : void 0);
+			if (!preparation) {
+				console.error(`[flue:compaction] Nothing to compact (no valid cut point found)`);
+				return;
+			}
+			const firstKeptEntry = contextEntries[preparation.firstKeptIndex]?.entry;
+			if (!firstKeptEntry || firstKeptEntry.type !== "message") {
+				console.error(`[flue:compaction] Nothing to compact (first kept message has no entry)`);
+				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.emit({
+				type: "compaction_start",
+				reason,
+				estimatedTokens
+			});
+			const result = await compact(preparation, model, void 0, this.compactionAbortController.signal);
+			if (this.compactionAbortController.signal.aborted) return;
+			this.history.appendCompaction({
+				summary: result.summary,
+				firstKeptEntryId: firstKeptEntry.id,
+				tokensBefore: result.tokensBefore,
+				details: result.details
+			});
+			this.harness.state.messages = this.history.buildContext();
+			const messagesAfter = this.harness.state.messages.length;
+			console.error(`[flue:compaction] Complete — messages: ${messagesBefore} → ${messagesAfter}, tokens before: ${result.tokensBefore}`);
+			this.emit({
+				type: "compaction_end",
+				messagesBefore,
+				messagesAfter
+			});
+			await this.save();
+			if (willRetry) {
+				const msgs = this.harness.state.messages;
+				const lastMsg = msgs[msgs.length - 1];
+				if (lastMsg?.role === "assistant" && lastMsg.stopReason === "error") this.harness.state.messages = msgs.slice(0, -1);
+				console.error(`[flue:compaction] Retrying after overflow recovery...`);
+				const beforeRetry = this.harness.state.messages.length;
+				await this.harness.continue();
+				await this.harness.waitForIdle();
+				await this.syncHarnessMessagesSince(beforeRetry, "retry");
+			}
+		} 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.harness.state.errorMessage;
+		if (errorMsg) throw new Error(`[flue] ${context} failed: ${errorMsg}`);
+	}
+	getAssistantText() {
+		const messages = this.harness.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 "";
+	}
+	getLatestAssistantMessageId() {
+		const path = this.history.getActivePath();
+		for (let i = path.length - 1; i >= 0; i--) {
+			const entry = path[i];
+			if (entry.type === "message" && entry.message.role === "assistant") return entry.id;
+		}
+	}
+	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);
+			const beforeRetry = this.harness.state.messages.length;
+			await this.harness.prompt(followUpPrompt);
+			await this.harness.waitForIdle();
+			await this.syncHarnessMessagesSince(beforeRetry, "retry");
+			await this.checkLatestAssistantForCompaction();
+			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("/");
+}
+async function deleteSessionTree(store, storageKey, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(storageKey)) return;
+	seen.add(storageKey);
+	const data = await store.load(storageKey);
+	const taskSessions = Array.isArray(data?.metadata?.taskSessions) ? data.metadata.taskSessions : [];
+	for (const task of taskSessions) if (typeof task?.storageKey === "string") await deleteSessionTree(store, task.storageKey, seen);
+	await store.delete(storageKey);
+}
+function formatShellHistory(command, result, cwdLine, envLine) {
+	const sections = [`<shell_command>\n$ ${command}${cwdLine}${envLine}\n</shell_command>`, `<shell_result exitCode="${result.exitCode}">`];
+	if (result.stdout) sections.push(`<stdout>\n${result.stdout}\n</stdout>`);
+	if (result.stderr) sections.push(`<stderr>\n${result.stderr}\n</stderr>`);
+	sections.push("</shell_result>");
+	return truncateShellHistory(sections.join("\n"));
+}
+function truncateShellHistory(text) {
+	if (text.length <= MAX_SHELL_HISTORY_CHARS) return text;
+	return `[Shell output truncated: ${text.length - MAX_SHELL_HISTORY_CHARS} leading characters omitted]\n` + text.slice(text.length - MAX_SHELL_HISTORY_CHARS);
+}
+function getErrorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+
+//#endregion
+export { assertRoleExists as a, normalizePath as i, Session as n, createScopedEnv as o, deleteSessionTree as r, mergeCommands as s, InMemorySessionStore as t };