@kywk/open-slide-core 2.3.1 → 2.3.3

package/dist/{config-B5LArqpp.js → config-KyYvWqq-.js}

@@ -1,18 +1,1987 @@
 import { n as defaultDesign } from "./design-CoZ0cWDN.js";
-import { C as reorderDefaultExportPagesInSource, D as updateMetaTitleInSource, E as rmSlideDir, O as validateSlideName, S as removePageFromDefaultExportInSource, T as resolveSlideEntry, _ as SLIDE_ID_RE, a as readBody, b as duplicateSlideDir, c as FOLDER_ID_RE, d as readManifest, f as validateIcon, g as shortId, h as writeManifest, i as makeContext, j as ownPackageName, k as validateMutationRequest, l as foldersManifestPath, m as validateReorder, n as registerUpdateRoutes, o as readSlideSource, p as validateName, r as json, s as resolveSlideEntryPath, u as newFolderId, v as duplicateNotesElementInSource, w as reorderNotesArrayInSource, x as removeNotesElementInSource, y as duplicatePageInDefaultExportInSource } from "./update-C_RlnKu4.js";
+import { A as reorderNotesArrayInSource, C as duplicatePageInDefaultExportInSource, D as removePageFromDefaultExportInSource, E as removeNotesElementInSource, F as validateSlideName, I as isLoopbackRequest, L as validateMutationRequest, M as rmSlideDir, N as slugifyTitle, O as renameSlideDir, P as updateMetaTitleInSource, S as duplicateNotesElementInSource, T as readMetaTitleInSource, _ as writeManifest, a as json, b as SLIDE_ID_RE, c as readSlideSource, d as foldersManifestPath, f as newFolderId, g as validateReorder, h as validateName, i as BodyTooLargeError, j as resolveSlideEntry, k as reorderDefaultExportPagesInSource, l as resolveSlideEntryPath, m as validateIcon, n as registerUpdateRoutes, o as makeContext, p as readManifest, r as runCommand, s as readBody, t as detectPackageManager, u as FOLDER_ID_RE, v as shortId, w as duplicateSlideDir, x as createBlankSlideDir, z as ownPackageName } from "./update-CqZqQRQk.js";
 import { createRequire } from "node:module";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { existsSync, readFileSync, rmSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { existsSync, readFileSync, rmSync, statSync } from "node:fs";
+import { spawn } from "node:child_process";
 import fs from "node:fs/promises";
 import { parse } from "@babel/parser";
-import { randomUUID } from "node:crypto";
+import { randomBytes, randomUUID } from "node:crypto";
 import tailwindcss from "@tailwindcss/vite";
 import react from "@vitejs/plugin-react";
-import * as t from "@babel/types";
-import { isJSXElement, isJSXFragment } from "@babel/types";
+import os from "node:os";
 import fg from "fast-glob";
 import { loadConfigFromFile, normalizePath } from "vite";
+import * as t from "@babel/types";
+import { isJSXElement, isJSXFragment } from "@babel/types";
+//#region src/editing/placeholder-id.ts
+const UNTITLED_SLIDE_ID_RE = /^untitled(-\d+)?$/;
+//#endregion
+//#region src/agent/provider.ts
+var ProviderUnavailableError = class extends Error {
+	constructor(provider) {
+		super(`${provider.name} is not connected: install ${provider.sdkPackage} in this workspace to use it from the agent panel.`);
+		this.name = "ProviderUnavailableError";
+	}
+};
+const DETAIL_MAX = 400;
+function clipDetail(value) {
+	if (value === void 0 || value === null) return null;
+	const text = typeof value === "string" ? value : safeJson(value);
+	if (!text) return null;
+	const oneLine = text.replace(/\s+/g, " ").trim();
+	return oneLine.length > DETAIL_MAX ? `${oneLine.slice(0, 399)}…` : oneLine;
+}
+function safeJson(value) {
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
+	}
+}
+function isInsideRoots(cwd, file, roots) {
+	if (typeof file !== "string" || !file) return false;
+	const resolved = path.resolve(cwd, file);
+	return roots.some((root) => {
+		const rel = path.relative(root, resolved);
+		return rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel);
+	});
+}
+function relativeToCwd(cwd, file) {
+	if (typeof file !== "string" || !file) return null;
+	const normalizedCwd = cwd.replace(/[\\/]+$/, "");
+	if (file.startsWith(normalizedCwd)) return file.slice(normalizedCwd.length).replace(/^[\\/]+/, "") || ".";
+	return file;
+}
+function parseQuestions(input) {
+	const raw = Array.isArray(input.questions) ? input.questions : [];
+	const questions = [];
+	for (const q of raw) {
+		if (!q || typeof q !== "object") continue;
+		const r = q;
+		const options = Array.isArray(r.options) ? r.options.map((o) => {
+			if (!o || typeof o !== "object") return null;
+			const opt = o;
+			if (typeof opt.label !== "string") return null;
+			return {
+				label: opt.label,
+				description: typeof opt.description === "string" ? opt.description : void 0
+			};
+		}).filter((o) => o !== null) : [];
+		if (typeof r.question !== "string") continue;
+		questions.push({
+			header: typeof r.header === "string" ? r.header : "",
+			question: r.question,
+			options,
+			multiSelect: r.multiSelect === true
+		});
+	}
+	return questions;
+}
+//#endregion
+//#region src/agent/prompt.ts
+const PAGE_BY_PAGE = "Write a new deck page by page so the user can follow along on the canvas: first replace the file with the imports, meta (keeping its existing createdAt), design and the cover page only, then add each remaining page with its own separate edit, keeping the file compiling after every write.";
+const DECK_SLUG = "This deck's folder still has a placeholder name. Never rename or move the folder yourself: once the deck has content, end your final reply with a slug for it on a line of its own as <deck-slug>short-kebab-case-english-slug</deck-slug>, and open-slide renames the folder from it.";
+function systemPromptAppend(askInstruction) {
+	return [
+		"You are running inside the open-slide dev server, driven from its in-app agent panel in the browser rather than a terminal.",
+		"The workspace is an open-slide project: decks live under slides/<id>/index.tsx and the dev server hot-reloads every edit, so the user sees changes immediately.",
+		"Use the project skills: create-slide to draft a new deck, apply-comments to resolve @slide-comment markers left by the inspector, create-theme for themes, and slide-authoring as the technical reference before writing a page.",
+		PAGE_BY_PAGE,
+		"Keep replies short and concrete: the panel is narrow. Prefer doing the work over describing it, and finish with a one-line summary of what changed.",
+		askInstruction
+	].join(" ");
+}
+function buildTurnPrompt(text, context) {
+	const lines = contextLines(context);
+	if (lines.length === 0) return text;
+	return `${text}\n\n<open-slide-context>\n${lines.join("\n")}\n</open-slide-context>`;
+}
+const escapeTag = (s) => s.replace(/</g, "&lt;");
+function contextLines(context) {
+	if (!context?.slideId) return [];
+	const file = `slides/${context.slideId}/index.tsx`;
+	const lines = [];
+	if (context.newDeck) {
+		lines.push(`${file} is a blank deck created for this request. Draft the deck the user describes into it with the create-slide skill: replace the placeholder page, keep the slide id, and do not create another folder.`, "Ask the create-slide scoping questions in a single round, only for what the request leaves unclear; skip any it already answers.", PAGE_BY_PAGE, DECK_SLUG);
+		return lines;
+	}
+	lines.push(`The user is viewing slide "${context.slideId}": ${file}.`);
+	if (UNTITLED_SLIDE_ID_RE.test(context.slideId)) lines.push(DECK_SLUG);
+	if (context.slideTitle) lines.push(`<slide-title>${escapeTag(context.slideTitle)}</slide-title>`);
+	if (context.pageNumber && context.totalPages) lines.push(`They are on page ${context.pageNumber} of ${context.totalPages} (0-based index ${context.pageNumber - 1} in the default export array).`);
+	if (context.selection) {
+		const { line, column, tagName, text } = context.selection;
+		lines.push(`They have selected a <${escapeTag(tagName)}> element at ${file}:${line}:${column}.${text ? " Its text is in <selected-text>." : ""} "This element" refers to it.`);
+		if (text) lines.push(`<selected-text>${escapeTag(text)}</selected-text>`);
+	}
+	if (context.pendingComments) lines.push(`There are ${context.pendingComments} pending @slide-comment markers in this slide's source.`);
+	return lines;
+}
+const DECK_SLUG_RE = /\s*<deck-slug>\s*([^<]*?)\s*<\/deck-slug>\s*/gi;
+function extractDeckSlug(text) {
+	let slug = null;
+	for (const match of text.matchAll(DECK_SLUG_RE)) slug = match[1] || slug;
+	return slug;
+}
+function stripDeckSlug(text) {
+	return text.replace(DECK_SLUG_RE, "\n").replace(/\s*<deck-slug>[^<]*$/i, "").trimEnd();
+}
+const QUESTIONS_RE = /<open-slide-questions>([\s\S]*?)<\/open-slide-questions>/i;
+const TEXT_QUESTIONS_INSTRUCTION = "You cannot ask the user anything interactively here, and nothing you print in the middle of a turn can be answered. When you need answers before continuing, stop working and end your turn with a final message holding only an <open-slide-questions> block: a JSON array of at most 4 questions shaped like [{\"header\":\"Pages\",\"question\":\"How many pages?\",\"multiSelect\":false,\"options\":[{\"label\":\"6-10 (Recommended)\",\"description\":\"Standard length\"}]}], each with 2 to 4 options, written in the user's language. The panel shows them as a form and sends the answers back as your next message. Write nothing after the block and do not continue the task in the same turn.";
+function extractQuestionBlock(text) {
+	const match = QUESTIONS_RE.exec(text);
+	if (!match) return null;
+	const body = match[1].trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "");
+	let raw;
+	try {
+		raw = JSON.parse(body);
+	} catch {
+		return null;
+	}
+	const questions = parseQuestions({ questions: Array.isArray(raw) ? raw : raw?.questions });
+	if (questions.length === 0) return null;
+	return {
+		text: text.replace(QUESTIONS_RE, "").trim(),
+		questions
+	};
+}
+function answersPrompt(questions, answers) {
+	if (!answers) return "I skipped your questions. Continue the task with your best judgement and sensible defaults.";
+	return `My answers:\n${questions.map((q) => `- ${q.question} ${answers[q.question] || "(no answer)"}`).join("\n")}\n\nContinue the task with these answers.`;
+}
+function editedPrompt(original, text) {
+	return `I went back and edited an earlier message of mine. Treat everything after it in this conversation, including your replies, as discarded, and respond to the edited version instead. Files keep whatever changes were already made.\n\n<original-message>\n${escapeTag(original)}\n</original-message>\n\n${text}`;
+}
+function rewoundPrompt(text) {
+	return `${text}\n\n<open-slide-note>I went back and edited this message. Files keep the changes made after it in the discarded part of this conversation, so read the current files before editing them.</open-slide-note>`;
+}
+//#endregion
+//#region src/agent/detect.ts
+const IS_WINDOWS = process.platform === "win32";
+const VERSION_TIMEOUT_MS = 5e3;
+function findOnPath(command, env = process.env) {
+	const dirs = (env.PATH ?? env.Path ?? "").split(path.delimiter).filter(Boolean);
+	const exts = IS_WINDOWS ? (env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";") : [""];
+	for (const dir of dirs) for (const ext of exts) {
+		const candidate = path.join(dir, command + ext.toLowerCase());
+		try {
+			if (statSync(candidate, { throwIfNoEntry: false })?.isFile()) return candidate;
+		} catch {}
+	}
+	return null;
+}
+function findSpawnableCli(command, env = process.env) {
+	const found = findOnPath(command, env);
+	if (!found || !IS_WINDOWS) return found;
+	return found.toLowerCase().endsWith(".exe") ? found : null;
+}
+const versionCache = /* @__PURE__ */ new Map();
+function commandVersion(file) {
+	let cached = versionCache.get(file);
+	if (!cached) {
+		cached = readVersion(file);
+		versionCache.set(file, cached);
+	}
+	return cached;
+}
+function readVersion(file) {
+	return new Promise((resolve) => {
+		let out = "";
+		let child;
+		try {
+			child = spawn(file, ["--version"], {
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				],
+				shell: IS_WINDOWS,
+				windowsHide: true
+			});
+		} catch {
+			resolve(null);
+			return;
+		}
+		const timer = setTimeout(() => {
+			child.kill();
+			resolve(null);
+		}, VERSION_TIMEOUT_MS);
+		child.stdout?.on("data", (c) => {
+			out += c.toString("utf8");
+		});
+		child.stderr?.on("data", (c) => {
+			out += c.toString("utf8");
+		});
+		child.on("error", () => {
+			clearTimeout(timer);
+			resolve(null);
+		});
+		child.on("close", () => {
+			clearTimeout(timer);
+			resolve(parseVersion(out));
+		});
+	});
+}
+function parseVersion(output) {
+	const m = /(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)/.exec(output);
+	return m ? m[1] : null;
+}
+function entryFromPackageJson(pkg) {
+	const root = pickExport(pkg.exports);
+	if (root) return root;
+	return pkg.module ?? pkg.main ?? null;
+}
+function pickExport(exportsField) {
+	if (!exportsField) return null;
+	if (typeof exportsField === "string") return exportsField;
+	if (typeof exportsField !== "object") return null;
+	const record = exportsField;
+	return pickCondition(Object.keys(record).some((k) => k.startsWith(".")) ? record["."] : exportsField);
+}
+function pickCondition(target) {
+	if (!target) return null;
+	if (typeof target === "string") return target;
+	if (Array.isArray(target)) {
+		for (const t of target) {
+			const hit = pickCondition(t);
+			if (hit) return hit;
+		}
+		return null;
+	}
+	if (typeof target !== "object") return null;
+	const record = target;
+	for (const key of [
+		"import",
+		"node",
+		"default",
+		"require"
+	]) if (key in record) {
+		const hit = pickCondition(record[key]);
+		if (hit) return hit;
+	}
+	return null;
+}
+function resolveWorkspacePackage(userCwd, name) {
+	let dir = path.resolve(userCwd);
+	while (true) {
+		const pkgJsonPath = path.join(dir, "node_modules", name, "package.json");
+		if (existsSync(pkgJsonPath)) {
+			let pkg;
+			try {
+				pkg = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
+			} catch {
+				return null;
+			}
+			const entry = entryFromPackageJson(pkg);
+			if (!entry) return null;
+			const pkgDir = path.dirname(pkgJsonPath);
+			return {
+				dir: pkgDir,
+				version: pkg.version ?? "0.0.0",
+				entry: path.resolve(pkgDir, entry)
+			};
+		}
+		const parent = path.dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+async function importWorkspacePackage(userCwd, name) {
+	const resolved = resolveWorkspacePackage(userCwd, name);
+	if (!resolved) return null;
+	return await import(pathToFileURL(resolved.entry).href);
+}
+//#endregion
+//#region src/agent/providers/claude.ts
+const CLAUDE_SDK_PACKAGE = "@anthropic-ai/claude-agent-sdk";
+const CLAUDE_EFFORTS = [
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+const CLAUDE_MODELS = [
+	{
+		id: "opus",
+		label: "Opus",
+		efforts: CLAUDE_EFFORTS
+	},
+	{
+		id: "sonnet",
+		label: "Sonnet",
+		efforts: CLAUDE_EFFORTS
+	},
+	{
+		id: "haiku",
+		label: "Haiku",
+		efforts: []
+	}
+];
+const EDIT_TOOLS = /* @__PURE__ */ new Set([
+	"Edit",
+	"MultiEdit",
+	"Write",
+	"NotebookEdit"
+]);
+function claudeEffort(effort) {
+	return effort && effort !== "minimal" ? effort : void 0;
+}
+function describeClaudeTool(name, input, cwd) {
+	const file = relativeToCwd(cwd, input.file_path ?? input.path ?? input.notebook_path);
+	switch (name) {
+		case "Read": return {
+			title: "Read",
+			detail: file
+		};
+		case "Edit":
+		case "MultiEdit":
+		case "Write":
+		case "NotebookEdit": return {
+			title: name === "Write" ? "Write" : "Edit",
+			detail: file
+		};
+		case "Bash": return {
+			title: "Run command",
+			detail: clipDetail(input.command)
+		};
+		case "Glob":
+		case "Grep": return {
+			title: "Search",
+			detail: clipDetail(input.pattern)
+		};
+		case "WebFetch": return {
+			title: "Fetch",
+			detail: clipDetail(input.url)
+		};
+		case "WebSearch": return {
+			title: "Web search",
+			detail: clipDetail(input.query)
+		};
+		case "Skill": return {
+			title: "Skill",
+			detail: clipDetail(input.skill ?? input.name)
+		};
+		case "Task": return {
+			title: "Subagent",
+			detail: clipDetail(input.description)
+		};
+		case "AskUserQuestion": return {
+			title: "Question",
+			detail: null
+		};
+		case "TodoWrite": return {
+			title: "Plan",
+			detail: null
+		};
+		default: return {
+			title: name,
+			detail: clipDetail(input)
+		};
+	}
+}
+function createClaudeMapper(emit, cwd) {
+	let counter = 0;
+	const nextId = () => `t-${Date.now().toString(36)}-${(counter++).toString(36)}`;
+	const textByIndex = /* @__PURE__ */ new Map();
+	const openTextIds = [];
+	let resultSeen = false;
+	const handleBlocks = (blocks) => {
+		for (const block of blocks) if (block.type === "text") {
+			const { text } = block;
+			const id = openTextIds.shift();
+			if (id) emit({
+				type: "text-end",
+				id,
+				text
+			});
+			else if (text.trim()) {
+				const fresh = nextId();
+				emit({
+					type: "text-start",
+					id: fresh
+				});
+				emit({
+					type: "text-end",
+					id: fresh,
+					text
+				});
+			}
+		} else if (block.type === "tool_use") {
+			const { title, detail } = describeClaudeTool(block.name, block.input ?? {}, cwd);
+			emit({
+				type: "tool-start",
+				id: block.id,
+				name: block.name,
+				title,
+				detail
+			});
+		}
+		textByIndex.clear();
+		openTextIds.length = 0;
+	};
+	return {
+		get resultSeen() {
+			return resultSeen;
+		},
+		handle(msg) {
+			if (!msg || typeof msg !== "object") return;
+			if (msg.type === "system" && msg.subtype === "init") {
+				emit({
+					type: "session-id",
+					id: msg.session_id
+				});
+				return;
+			}
+			if (msg.type === "stream_event") {
+				if (msg.parent_tool_use_id) return;
+				const ev = msg.event;
+				if (ev.type === "content_block_start") {
+					if (ev.content_block.type === "text") {
+						const id = nextId();
+						textByIndex.set(ev.index, id);
+						openTextIds.push(id);
+						emit({
+							type: "text-start",
+							id
+						});
+					}
+				} else if (ev.type === "content_block_delta") {
+					const id = textByIndex.get(ev.index);
+					if (id && ev.delta.type === "text_delta" && ev.delta.text) emit({
+						type: "text-delta",
+						id,
+						text: ev.delta.text
+					});
+				}
+				return;
+			}
+			if (msg.type === "assistant") {
+				if (msg.parent_tool_use_id) return;
+				handleBlocks(msg.message?.content ?? []);
+				if (msg.uuid) emit({
+					type: "checkpoint",
+					id: msg.uuid
+				});
+				return;
+			}
+			if (msg.type === "user") {
+				if (msg.parent_tool_use_id) return;
+				if (msg.uuid) emit({
+					type: "checkpoint",
+					id: msg.uuid
+				});
+				const content = msg.message?.content;
+				if (!Array.isArray(content)) return;
+				for (const block of content) if (block.type === "tool_result") emit({
+					type: "tool-end",
+					id: block.tool_use_id,
+					ok: !block.is_error
+				});
+				return;
+			}
+			if (msg.type === "result") {
+				resultSeen = true;
+				if (msg.session_id) emit({
+					type: "session-id",
+					id: msg.session_id
+				});
+				if (msg.is_error || msg.subtype && msg.subtype !== "success") emit({
+					type: "error",
+					text: (Array.isArray(msg.errors) && msg.errors.length ? msg.errors.join("\n") : null) ?? (typeof msg.result === "string" && msg.result ? msg.result : null) ?? `Claude Code stopped: ${msg.subtype ?? "error"}`
+				});
+				emit({
+					type: "result",
+					durationMs: typeof msg.duration_ms === "number" ? msg.duration_ms : null,
+					costUsd: typeof msg.total_cost_usd === "number" ? msg.total_cost_usd : null
+				});
+			}
+		}
+	};
+}
+function createClaudeProvider() {
+	return {
+		id: "claude",
+		name: "Claude Code",
+		sdkPackage: CLAUDE_SDK_PACKAGE,
+		cliCommand: "claude",
+		askInstruction: "Ask the user questions with the AskUserQuestion tool, never as plain text.",
+		canRewind: true,
+		async models() {
+			return CLAUDE_MODELS;
+		},
+		async run(opts) {
+			const sdk = await importWorkspacePackage(opts.cwd, CLAUDE_SDK_PACKAGE);
+			if (!sdk || typeof sdk.query !== "function") throw new ProviderUnavailableError(this);
+			const mapper = createClaudeMapper(opts.emit, opts.cwd);
+			if (opts.signal.aborted) return;
+			const abortController = new AbortController();
+			opts.signal.addEventListener("abort", () => abortController.abort(), { once: true });
+			const canUseTool = async (toolName, input) => {
+				if (toolName === "AskUserQuestion") {
+					const questions = parseQuestions(input);
+					const answers = await opts.askUser(questions);
+					if (!answers) return {
+						behavior: "deny",
+						message: "The user dismissed the question."
+					};
+					return {
+						behavior: "allow",
+						updatedInput: {
+							...input,
+							answers
+						}
+					};
+				}
+				const target = input.file_path ?? input.notebook_path;
+				if (EDIT_TOOLS.has(toolName) && isInsideRoots(opts.cwd, target, opts.writableRoots)) return {
+					behavior: "allow",
+					updatedInput: input
+				};
+				const { title, detail } = describeClaudeTool(toolName, input, opts.cwd);
+				return await opts.requestPermission({
+					tool: toolName,
+					title,
+					detail
+				}) ? {
+					behavior: "allow",
+					updatedInput: input
+				} : {
+					behavior: "deny",
+					message: "The user declined this action in the open-slide agent panel."
+				};
+			};
+			const localCli = findSpawnableCli("claude");
+			const effort = claudeEffort(opts.effort);
+			let stderr = "";
+			const stream = sdk.query({
+				prompt: opts.prompt,
+				options: {
+					cwd: opts.cwd,
+					permissionMode: "default",
+					settingSources: [
+						"user",
+						"project",
+						"local"
+					],
+					systemPrompt: {
+						type: "preset",
+						preset: "claude_code",
+						append: opts.systemPromptAppend
+					},
+					includePartialMessages: true,
+					abortController,
+					canUseTool,
+					...opts.resume ? { resume: opts.resume } : {},
+					...opts.resume && opts.resumeAt ? { resumeSessionAt: opts.resumeAt } : {},
+					...opts.model ? { model: opts.model } : {},
+					...effort ? { effort } : {},
+					...localCli ? { pathToClaudeCodeExecutable: localCli } : {},
+					stderr: (data) => {
+						stderr = (stderr + data).slice(-2e3);
+					}
+				}
+			});
+			try {
+				for await (const message of stream) mapper.handle(message);
+			} catch (err) {
+				if (opts.signal.aborted || mapper.resultSeen) return;
+				const base = err instanceof Error ? err.message : String(err);
+				const tail = stderr.trim();
+				throw new Error(tail && !base.includes(tail) ? `${base}\n${tail}` : base);
+			}
+		}
+	};
+}
+//#endregion
+//#region src/agent/types.ts
+const AGENT_PROVIDER_IDS = ["claude", "codex"];
+const AGENT_EFFORTS = [
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+function isAgentProviderId(value) {
+	return typeof value === "string" && AGENT_PROVIDER_IDS.includes(value);
+}
+function isAgentEffort(value) {
+	return typeof value === "string" && AGENT_EFFORTS.includes(value);
+}
+function sessionSummary(session) {
+	const { providerSessionId: _p, providerCheckpoint: _c, trimmed: _t, items: _i, ...summary } = session;
+	return summary;
+}
+//#endregion
+//#region src/agent/providers/codex.ts
+const CODEX_SDK_PACKAGE = "@openai/codex-sdk";
+const CODEX_DEFAULT_MODEL = {
+	id: "",
+	label: "Default",
+	efforts: [
+		"low",
+		"medium",
+		"high"
+	]
+};
+function parseCodexModelsCache(raw) {
+	const list = raw?.models;
+	if (!Array.isArray(list)) return [];
+	const models = [];
+	for (const entry of list) {
+		if (!entry || typeof entry !== "object") continue;
+		const m = entry;
+		if (typeof m.slug !== "string" || !m.slug) continue;
+		if (m.visibility !== void 0 && m.visibility !== "list") continue;
+		const efforts = (Array.isArray(m.supported_reasoning_levels) ? m.supported_reasoning_levels : []).map((l) => l && typeof l === "object" ? l.effort : l).filter(isAgentEffort);
+		models.push({
+			option: {
+				id: m.slug,
+				label: typeof m.display_name === "string" && m.display_name ? m.display_name : m.slug,
+				efforts
+			},
+			priority: typeof m.priority === "number" ? m.priority : Number.MAX_SAFE_INTEGER
+		});
+	}
+	return models.sort((a, b) => a.priority - b.priority).map((m) => m.option);
+}
+async function readCodexModels() {
+	const home = process.env.CODEX_HOME || path.join(os.homedir(), ".codex");
+	try {
+		const models = parseCodexModelsCache(JSON.parse(await fs.readFile(path.join(home, "models_cache.json"), "utf8")));
+		return models.length > 0 ? models : [CODEX_DEFAULT_MODEL];
+	} catch {
+		return [CODEX_DEFAULT_MODEL];
+	}
+}
+function createCodexMapper(emit) {
+	const started = /* @__PURE__ */ new Set();
+	let resultSeen = false;
+	const startTool = (item, name, title, detail) => {
+		if (started.has(item.id)) return;
+		started.add(item.id);
+		emit({
+			type: "tool-start",
+			id: item.id,
+			name,
+			title,
+			detail
+		});
+	};
+	const describe = (item) => {
+		switch (item.type) {
+			case "command_execution": return {
+				name: "command",
+				title: "Run command",
+				detail: clipDetail(item.command)
+			};
+			case "file_change": return {
+				name: "file_change",
+				title: "Edit",
+				detail: clipDetail(item.changes.map((c) => c.path).join(", "))
+			};
+			case "mcp_tool_call": return {
+				name: "mcp",
+				title: `${item.server}: ${item.tool}`,
+				detail: null
+			};
+			case "web_search": return {
+				name: "web_search",
+				title: "Web search",
+				detail: clipDetail(item.query)
+			};
+			default: return {
+				name: item.type,
+				title: item.type,
+				detail: null
+			};
+		}
+	};
+	const handleItem = (phase, item) => {
+		switch (item.type) {
+			case "agent_message": {
+				if (phase !== "completed" || !item.text.trim()) return;
+				const asked = extractQuestionBlock(item.text);
+				const text = asked ? asked.text : item.text;
+				if (text) {
+					emit({
+						type: "text-start",
+						id: item.id
+					});
+					emit({
+						type: "text-end",
+						id: item.id,
+						text
+					});
+				}
+				if (asked) emit({
+					type: "questions",
+					questions: asked.questions
+				});
+				return;
+			}
+			case "error":
+				if (phase === "completed") emit({
+					type: "error",
+					text: item.message
+				});
+				return;
+			case "command_execution":
+			case "file_change":
+			case "mcp_tool_call":
+			case "web_search": {
+				const { name, title, detail } = describe(item);
+				startTool(item, name, title, detail);
+				if (phase === "completed") {
+					const status = "status" in item ? item.status : "completed";
+					emit({
+						type: "tool-end",
+						id: item.id,
+						ok: status !== "failed"
+					});
+				}
+				return;
+			}
+			default: return;
+		}
+	};
+	return {
+		get resultSeen() {
+			return resultSeen;
+		},
+		handle(event) {
+			if (!event || typeof event !== "object") return;
+			switch (event.type) {
+				case "thread.started":
+					emit({
+						type: "session-id",
+						id: event.thread_id
+					});
+					return;
+				case "item.started":
+					handleItem("started", event.item);
+					return;
+				case "item.updated":
+					handleItem("updated", event.item);
+					return;
+				case "item.completed":
+					handleItem("completed", event.item);
+					return;
+				case "turn.failed":
+					resultSeen = true;
+					emit({
+						type: "error",
+						text: event.error.message
+					});
+					emit({
+						type: "result",
+						durationMs: null,
+						costUsd: null
+					});
+					return;
+				case "error":
+					emit({
+						type: "error",
+						text: event.message
+					});
+					return;
+				case "turn.completed":
+					resultSeen = true;
+					emit({
+						type: "result",
+						durationMs: null,
+						costUsd: null
+					});
+					return;
+				default: return;
+			}
+		}
+	};
+}
+function createCodexProvider() {
+	return {
+		id: "codex",
+		name: "Codex",
+		sdkPackage: CODEX_SDK_PACKAGE,
+		askInstruction: TEXT_QUESTIONS_INSTRUCTION,
+		canRewind: false,
+		cliCommand: "codex",
+		models: readCodexModels,
+		async run(opts) {
+			const sdk = await importWorkspacePackage(opts.cwd, CODEX_SDK_PACKAGE);
+			if (!sdk || typeof sdk.Codex !== "function") throw new ProviderUnavailableError(this);
+			const localCli = findSpawnableCli("codex");
+			const codex = new sdk.Codex(localCli ? { codexPathOverride: localCli } : {});
+			const threadOptions = {
+				workingDirectory: opts.cwd,
+				skipGitRepoCheck: true,
+				sandboxMode: "workspace-write",
+				approvalPolicy: "never",
+				...opts.model ? { model: opts.model } : {},
+				...opts.effort ? { modelReasoningEffort: opts.effort } : {}
+			};
+			const thread = opts.resume ? codex.resumeThread(opts.resume, threadOptions) : codex.startThread(threadOptions);
+			const input = opts.resume ? opts.prompt : `${opts.systemPromptAppend}\n\n${opts.prompt}`;
+			const mapper = createCodexMapper(opts.emit);
+			const { events } = await thread.runStreamed(input, { signal: opts.signal });
+			try {
+				for await (const event of events) mapper.handle(event);
+			} catch (err) {
+				if (opts.signal.aborted || mapper.resultSeen) return;
+				throw err;
+			}
+			if (thread.id) opts.emit({
+				type: "session-id",
+				id: thread.id
+			});
+		}
+	};
+}
+//#endregion
+//#region src/agent/providers/index.ts
+function createProviders() {
+	return {
+		claude: createClaudeProvider(),
+		codex: createCodexProvider()
+	};
+}
+//#endregion
+//#region src/agent/store.ts
+const MAX_SESSIONS = 30;
+const MAX_ITEMS_PER_SESSION = 400;
+const SAVE_DEBOUNCE_MS = 150;
+const TITLE_MAX = 60;
+function newId(prefix) {
+	return `${prefix}-${randomBytes(6).toString("hex")}`;
+}
+function titleFromPrompt(text) {
+	const line = text.split("\n").map((l) => l.trim()).find((l) => l.length > 0);
+	if (!line) return "Untitled";
+	return line.length > TITLE_MAX ? `${line.slice(0, 59)}…` : line;
+}
+function readPersisted(file) {
+	if (!existsSync(file)) return [];
+	try {
+		const parsed = JSON.parse(readFileSync(file, "utf8"));
+		if (parsed?.version !== 1 || !Array.isArray(parsed.sessions)) return [];
+		return parsed.sessions.map((s) => ({
+			...s,
+			status: "idle",
+			items: s.items.map(closePending)
+		}));
+	} catch {
+		return [];
+	}
+}
+function closePending(item) {
+	if (item.kind === "assistant" && item.streaming) return {
+		...item,
+		streaming: false
+	};
+	if (item.kind === "tool" && item.status === "running") return {
+		...item,
+		status: "error"
+	};
+	if (item.kind === "question" && item.status === "pending") return {
+		...item,
+		status: "cancelled"
+	};
+	if (item.kind === "permission" && item.status === "pending") return {
+		...item,
+		status: "denied"
+	};
+	return item;
+}
+function createSessionStore(opts) {
+	const sessions = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	let saveTimer = null;
+	let seq = 0;
+	const order = /* @__PURE__ */ new Map();
+	if (opts.file) for (const s of readPersisted(opts.file)) {
+		sessions.set(s.id, s);
+		order.set(s.id, seq++);
+	}
+	const emit = (event) => {
+		for (const l of listeners) l(event);
+	};
+	const scheduleSave = () => {
+		if (!opts.file) return;
+		if (saveTimer) clearTimeout(saveTimer);
+		saveTimer = setTimeout(() => {
+			saveTimer = null;
+			save();
+		}, SAVE_DEBOUNCE_MS);
+	};
+	const writeSnapshot = async (file) => {
+		const body = {
+			version: 1,
+			sessions: list().flatMap((s) => sessions.get(s.id) ?? [])
+		};
+		const tmp = `${file}.tmp`;
+		try {
+			await fs.mkdir(path.dirname(file), { recursive: true });
+			await fs.writeFile(tmp, JSON.stringify(body), {
+				encoding: "utf8",
+				mode: 384
+			});
+			await fs.rename(tmp, file);
+		} catch (err) {
+			console.error("[open-slide] failed to save agent sessions:", err);
+			await fs.rm(tmp, { force: true }).catch(() => {});
+		}
+	};
+	let saving = Promise.resolve();
+	const save = () => {
+		const file = opts.file;
+		if (!file) return saving;
+		saving = saving.then(() => writeSnapshot(file));
+		return saving;
+	};
+	const touch = (session) => {
+		session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		order.set(session.id, seq++);
+		emit({
+			type: "session",
+			session: sessionSummary(session)
+		});
+		scheduleSave();
+	};
+	const require = (id) => {
+		const session = sessions.get(id);
+		if (!session) throw new Error(`unknown agent session: ${id}`);
+		return session;
+	};
+	function list() {
+		return Array.from(sessions.values()).sort((a, b) => {
+			if (a.updatedAt !== b.updatedAt) return a.updatedAt < b.updatedAt ? 1 : -1;
+			return (order.get(b.id) ?? 0) - (order.get(a.id) ?? 0);
+		}).map(sessionSummary);
+	}
+	function get(id) {
+		return sessions.get(id) ?? null;
+	}
+	function create(provider, slideId) {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const session = {
+			id: newId("s"),
+			provider,
+			title: "New session",
+			createdAt: now,
+			updatedAt: now,
+			status: "idle",
+			slideId,
+			providerSessionId: null,
+			items: []
+		};
+		sessions.set(session.id, session);
+		order.set(session.id, seq++);
+		const idle = list().filter((s) => s.status === "idle");
+		for (const stale of idle.slice(MAX_SESSIONS)) {
+			sessions.delete(stale.id);
+			order.delete(stale.id);
+			emit({
+				type: "session-removed",
+				sessionId: stale.id
+			});
+		}
+		touch(session);
+		return session;
+	}
+	function remove(id) {
+		if (!sessions.delete(id)) return false;
+		order.delete(id);
+		emit({
+			type: "session-removed",
+			sessionId: id
+		});
+		scheduleSave();
+		return true;
+	}
+	function patch(id, changes) {
+		const session = require(id);
+		Object.assign(session, changes);
+		touch(session);
+		return session;
+	}
+	function appendItem(sessionId, item) {
+		const session = require(sessionId);
+		session.items.push(item);
+		if (session.items.length > MAX_ITEMS_PER_SESSION) {
+			session.items.splice(0, session.items.length - MAX_ITEMS_PER_SESSION);
+			session.trimmed = true;
+		}
+		emit({
+			type: "item",
+			sessionId,
+			item
+		});
+		touch(session);
+		return item;
+	}
+	function updateItem(sessionId, itemId, kind, changes) {
+		const session = require(sessionId);
+		const index = session.items.findIndex((i) => i.id === itemId && i.kind === kind);
+		if (index === -1) return null;
+		const next = {
+			...session.items[index],
+			...changes
+		};
+		session.items[index] = next;
+		emit({
+			type: "item",
+			sessionId,
+			item: next
+		});
+		touch(session);
+		return next;
+	}
+	function truncateFrom(sessionId, itemId) {
+		const session = require(sessionId);
+		const index = session.items.findIndex((i) => i.id === itemId);
+		if (index === -1) return false;
+		session.items.splice(index);
+		emit({
+			type: "truncate",
+			sessionId,
+			itemId
+		});
+		touch(session);
+		return true;
+	}
+	function appendDelta(sessionId, itemId, text) {
+		if (!text) return;
+		const item = require(sessionId).items.find((i) => i.id === itemId);
+		if (item?.kind !== "assistant") return;
+		item.text += text;
+		emit({
+			type: "delta",
+			sessionId,
+			itemId,
+			text
+		});
+		scheduleSave();
+	}
+	function subscribe(listener) {
+		listeners.add(listener);
+		return () => {
+			listeners.delete(listener);
+		};
+	}
+	async function flush() {
+		if (saveTimer) {
+			clearTimeout(saveTimer);
+			saveTimer = null;
+		}
+		await save();
+	}
+	return {
+		list,
+		get,
+		create,
+		remove,
+		patch,
+		appendItem,
+		updateItem,
+		truncateFrom,
+		appendDelta,
+		subscribe,
+		flush
+	};
+}
+//#endregion
+//#region src/agent/runner.ts
+function cancelPrompt(prompt) {
+	if (prompt.kind === "question") prompt.resolve(null);
+	else prompt.resolve(false);
+}
+function createAgentRunner(opts) {
+	const { userCwd, writableRoots, store, providers, onTurnEnd } = opts;
+	const running = /* @__PURE__ */ new Map();
+	const pending = /* @__PURE__ */ new Map();
+	const lastOptions = /* @__PURE__ */ new Map();
+	const now = () => (/* @__PURE__ */ new Date()).toISOString();
+	function isRunning(sessionId) {
+		return running.has(sessionId);
+	}
+	async function send(sessionId, options) {
+		const session = store.get(sessionId);
+		if (!session) throw new Error(`unknown agent session: ${sessionId}`);
+		if (running.has(sessionId)) throw new Error("session is already running");
+		const text = options.text.trim();
+		if (!text) throw new Error("empty prompt");
+		const provider = providers[session.provider];
+		let context = options.context;
+		let promptText = text;
+		let resumeAt = null;
+		if (options.edit) {
+			const index = session.items.findIndex((i) => i.id === options.edit);
+			const target = session.items[index];
+			if (target?.kind !== "user") throw new Error("unknown message");
+			if (!session.trimmed && !session.items.slice(0, index).some((i) => i.kind === "user")) {
+				store.patch(sessionId, {
+					providerSessionId: null,
+					providerCheckpoint: null
+				});
+				if (target.newDeck && context) context = {
+					...context,
+					newDeck: true
+				};
+			} else if (provider.canRewind && target.resumeAt) {
+				resumeAt = target.resumeAt;
+				store.patch(sessionId, { providerCheckpoint: resumeAt });
+				promptText = rewoundPrompt(text);
+			} else promptText = editedPrompt(target.text, text);
+			store.truncateFrom(sessionId, target.id);
+		}
+		const controller = new AbortController();
+		running.set(sessionId, controller);
+		lastOptions.set(sessionId, {
+			...options,
+			context,
+			edit: void 0
+		});
+		if (session.items.length === 0) store.patch(sessionId, { title: titleFromPrompt(text) });
+		if (options.context?.slideId && !session.slideId) store.patch(sessionId, { slideId: options.context.slideId });
+		for (const item of session.items) if (item.kind === "question" && item.status === "pending" && item.id !== options.answering) store.updateItem(sessionId, item.id, "question", { status: "cancelled" });
+		const userItemId = options.answering ?? newId("u");
+		if (!options.answering) store.appendItem(sessionId, {
+			kind: "user",
+			id: userItemId,
+			ts: now(),
+			text,
+			...session.providerCheckpoint ? { resumeAt: session.providerCheckpoint } : {},
+			...context?.newDeck ? { newDeck: true } : {}
+		});
+		store.patch(sessionId, { status: "running" });
+		const openText = /* @__PURE__ */ new Set();
+		const openTools = /* @__PURE__ */ new Set();
+		const startedAt = Date.now();
+		let resultSeen = false;
+		const appendQuestion = (questions) => store.appendItem(sessionId, {
+			kind: "question",
+			id: newId("q"),
+			ts: now(),
+			questions,
+			answers: null,
+			status: "pending"
+		});
+		const emit = (event) => {
+			if (!store.get(sessionId)) return;
+			switch (event.type) {
+				case "session-id":
+					store.patch(sessionId, { providerSessionId: event.id });
+					return;
+				case "checkpoint":
+					store.patch(sessionId, { providerCheckpoint: event.id });
+					return;
+				case "text-start":
+					openText.add(event.id);
+					store.appendItem(sessionId, {
+						kind: "assistant",
+						id: event.id,
+						ts: now(),
+						text: "",
+						streaming: true
+					});
+					return;
+				case "text-delta":
+					if (!openText.has(event.id)) emit({
+						type: "text-start",
+						id: event.id
+					});
+					store.appendDelta(sessionId, event.id, event.text);
+					return;
+				case "text-end": {
+					if (!openText.has(event.id)) {
+						if (!event.text) return;
+						emit({
+							type: "text-start",
+							id: event.id
+						});
+					}
+					openText.delete(event.id);
+					const changes = event.text !== null ? {
+						streaming: false,
+						text: event.text
+					} : { streaming: false };
+					store.updateItem(sessionId, event.id, "assistant", changes);
+					return;
+				}
+				case "tool-start":
+					openTools.add(event.id);
+					store.appendItem(sessionId, {
+						kind: "tool",
+						id: event.id,
+						ts: now(),
+						name: event.name,
+						title: event.title,
+						detail: event.detail,
+						status: "running"
+					});
+					return;
+				case "tool-end":
+					openTools.delete(event.id);
+					store.updateItem(sessionId, event.id, "tool", { status: event.ok ? "done" : "error" });
+					return;
+				case "error":
+					store.appendItem(sessionId, {
+						kind: "error",
+						id: newId("e"),
+						ts: now(),
+						text: event.text
+					});
+					return;
+				case "questions":
+					appendQuestion(event.questions);
+					return;
+				case "result":
+					resultSeen = true;
+					store.appendItem(sessionId, {
+						kind: "result",
+						id: newId("r"),
+						ts: now(),
+						durationMs: event.durationMs ?? Date.now() - startedAt,
+						costUsd: event.costUsd,
+						aborted: false
+					});
+					return;
+			}
+		};
+		const askUser = (questions) => new Promise((resolve) => {
+			if (controller.signal.aborted) return resolve(null);
+			const item = appendQuestion(questions);
+			pending.set(item.id, {
+				kind: "question",
+				resolve: (answers) => {
+					pending.delete(item.id);
+					store.updateItem(sessionId, item.id, "question", {
+						answers,
+						status: answers ? "answered" : "cancelled"
+					});
+					resolve(answers);
+				}
+			});
+		});
+		const requestPermission = (request) => new Promise((resolve) => {
+			if (controller.signal.aborted) return resolve(false);
+			const item = store.appendItem(sessionId, {
+				kind: "permission",
+				id: newId("p"),
+				ts: now(),
+				tool: request.tool,
+				title: request.title,
+				detail: request.detail,
+				status: options.autoApprove ? "allowed" : "pending"
+			});
+			if (options.autoApprove) return resolve(true);
+			pending.set(item.id, {
+				kind: "permission",
+				resolve: (allow) => {
+					pending.delete(item.id);
+					store.updateItem(sessionId, item.id, "permission", { status: allow ? "allowed" : "denied" });
+					resolve(allow);
+				}
+			});
+		});
+		const finish = () => {
+			running.delete(sessionId);
+			if (!store.get(sessionId)) return;
+			for (const id of openText) store.updateItem(sessionId, id, "assistant", { streaming: false });
+			for (const id of openTools) store.updateItem(sessionId, id, "tool", { status: "error" });
+			if (!resultSeen) store.appendItem(sessionId, {
+				kind: "result",
+				id: newId("r"),
+				ts: now(),
+				durationMs: Date.now() - startedAt,
+				costUsd: null,
+				aborted: controller.signal.aborted
+			});
+			store.patch(sessionId, { status: "idle" });
+			if (onTurnEnd) Promise.resolve().then(() => onTurnEnd({
+				sessionId,
+				userItemId
+			})).catch((err) => {
+				console.error("[open-slide] agent turn-end handler failed:", err);
+			});
+		};
+		const prompt = buildTurnPrompt(promptText, context);
+		provider.run({
+			cwd: userCwd,
+			writableRoots,
+			prompt,
+			systemPromptAppend: systemPromptAppend(provider.askInstruction),
+			resume: session.providerSessionId,
+			resumeAt,
+			model: options.model ?? null,
+			effort: options.effort ?? null,
+			signal: controller.signal,
+			emit,
+			askUser,
+			requestPermission
+		}).catch((err) => {
+			if (controller.signal.aborted) return;
+			emit({
+				type: "error",
+				text: err instanceof Error ? err.message : String(err)
+			});
+		}).finally(finish);
+	}
+	function stop(sessionId) {
+		const controller = running.get(sessionId);
+		if (!controller) return false;
+		const session = store.get(sessionId);
+		if (session) for (const item of session.items) {
+			const prompt = pending.get(item.id);
+			if (prompt) cancelPrompt(prompt);
+		}
+		controller.abort();
+		return true;
+	}
+	function respond(sessionId, itemId, payload, next = {}) {
+		if (!store.get(sessionId)?.items.some((i) => i.id === itemId)) return false;
+		const prompt = pending.get(itemId);
+		if (!prompt) return answerInNextTurn(sessionId, itemId, payload, next);
+		if ("cancel" in payload) {
+			cancelPrompt(prompt);
+			return true;
+		}
+		if (prompt.kind === "question" && "answers" in payload) {
+			prompt.resolve(payload.answers);
+			return true;
+		}
+		if (prompt.kind === "permission" && "allow" in payload) {
+			prompt.resolve(payload.allow);
+			return true;
+		}
+		return false;
+	}
+	function answerInNextTurn(sessionId, itemId, payload, next) {
+		const item = store.get(sessionId)?.items.find((i) => i.id === itemId);
+		if (item?.kind !== "question" || item.status !== "pending" || running.has(sessionId)) return false;
+		if (!("answers" in payload) && !("cancel" in payload)) return false;
+		const answers = "answers" in payload ? payload.answers : null;
+		store.updateItem(sessionId, itemId, "question", {
+			answers,
+			status: answers ? "answered" : "cancelled"
+		});
+		const previous = {
+			...lastOptions.get(sessionId),
+			...next
+		};
+		const context = previous.context ? {
+			...previous.context,
+			newDeck: void 0
+		} : void 0;
+		send(sessionId, {
+			...previous,
+			context,
+			text: answersPrompt(item.questions, answers),
+			answering: itemId
+		}).catch((err) => {
+			console.error("[open-slide] agent turn failed:", err);
+		});
+		return true;
+	}
+	function stopAll() {
+		for (const id of Array.from(running.keys())) stop(id);
+	}
+	return {
+		send,
+		stop,
+		respond,
+		isRunning,
+		stopAll
+	};
+}
+//#endregion
+//#region src/agent/status.ts
+const INSTALL_TIMEOUT_MS = 6e5;
+async function providerStatus(userCwd, provider) {
+	const sdk = resolveWorkspacePackage(userCwd, provider.sdkPackage);
+	const cliPath = findOnPath(provider.cliCommand);
+	const [cliVersion, models] = await Promise.all([cliPath ? commandVersion(cliPath) : null, provider.models()]);
+	return {
+		id: provider.id,
+		name: provider.name,
+		sdkPackage: provider.sdkPackage,
+		sdkVersion: sdk?.version ?? null,
+		cliCommand: provider.cliCommand,
+		cliFound: cliPath !== null,
+		cliVersion,
+		ready: sdk !== null,
+		models
+	};
+}
+async function agentStatus(userCwd, providers, packageManager) {
+	return {
+		enabled: true,
+		packageManager,
+		providers: await Promise.all(Object.values(providers).map((provider) => providerStatus(userCwd, provider)))
+	};
+}
+function installCommandFor(packageManager, pkg) {
+	switch (packageManager) {
+		case "pnpm": return {
+			cmd: "pnpm",
+			args: [
+				"add",
+				"-D",
+				pkg
+			]
+		};
+		case "yarn": return {
+			cmd: "yarn",
+			args: [
+				"add",
+				"-D",
+				pkg
+			]
+		};
+		case "bun": return {
+			cmd: "bun",
+			args: [
+				"add",
+				"-d",
+				pkg
+			]
+		};
+		case "npm": return {
+			cmd: "npm",
+			args: [
+				"install",
+				"-D",
+				pkg
+			]
+		};
+	}
+}
+function installSdk(packageManager, pkg, cwd) {
+	return runCommand(installCommandFor(packageManager, pkg), cwd, INSTALL_TIMEOUT_MS);
+}
+//#endregion
+//#region src/vite/recent-writes.ts
+const recentWrites = /* @__PURE__ */ new Map();
+/** Record that `file` was just written by us. */
+function recordWrite(file, now = Date.now()) {
+	recentWrites.set(file, now);
+}
+/**
+* True if `file` was recorded within the recent-write window. Expired entries
+* are pruned so a stale path can no longer suppress a later genuine edit.
+*/
+function hasRecentWrite(file, now = Date.now()) {
+	const ts = recentWrites.get(file);
+	if (ts == null) return false;
+	if (now - ts < 1500) return true;
+	recentWrites.delete(file);
+	return false;
+}
+//#endregion
+//#region src/vite/open-slide-plugin.ts
+const CONFIG_FILE = "open-slide.config.ts";
+const SLIDES_VMOD = "virtual:open-slide/slides";
+const CONFIG_VMOD = "virtual:open-slide/config";
+const FOLDERS_VMOD = "virtual:open-slide/folders";
+function resolved$1(id) {
+	return `\0${id}`;
+}
+async function findSlides(userCwd, slidesDir) {
+	const abs = path.resolve(userCwd, slidesDir);
+	if (!existsSync(abs)) return [];
+	return (await fg("*/index.{tsx,jsx,ts,js}", {
+		cwd: abs,
+		absolute: true,
+		onlyFiles: true
+	})).sort();
+}
+function toId(absFile, slidesRoot) {
+	return path.relative(slidesRoot, absFile).split(path.sep)[0];
+}
+const META_THEME_RE = /(?:^|[\s,{])theme\s*:\s*['"]([^'"]+)['"]/;
+const META_CREATED_AT_RE = /(?:^|[\s,{])createdAt\s*:\s*['"]([^'"]+)['"]/;
+function extractMeta(src) {
+	const empty = {
+		theme: null,
+		createdAt: null
+	};
+	const metaStart = src.search(/export\s+const\s+meta\b/);
+	if (metaStart === -1) return empty;
+	const eqIdx = src.indexOf("=", metaStart);
+	if (eqIdx === -1) return empty;
+	const openBrace = src.indexOf("{", eqIdx);
+	if (openBrace === -1) return empty;
+	let depth = 0;
+	let closeBrace = -1;
+	for (let i = openBrace; i < src.length; i++) {
+		const ch = src[i];
+		if (ch === "{") depth++;
+		else if (ch === "}") {
+			depth--;
+			if (depth === 0) {
+				closeBrace = i;
+				break;
+			}
+		}
+	}
+	if (closeBrace === -1) return empty;
+	const body = src.slice(openBrace + 1, closeBrace);
+	const themeMatch = body.match(META_THEME_RE);
+	const createdAtMatch = body.match(META_CREATED_AT_RE);
+	return {
+		theme: themeMatch ? themeMatch[1] : null,
+		createdAt: createdAtMatch ? createdAtMatch[1] : null
+	};
+}
+async function readSlideMeta(abs) {
+	try {
+		return extractMeta(await fs.readFile(abs, "utf8"));
+	} catch {
+		return {
+			theme: null,
+			createdAt: null
+		};
+	}
+}
+function parseCreatedAtMs(iso) {
+	if (!iso) return null;
+	const ms = Date.parse(iso);
+	return Number.isFinite(ms) ? ms : null;
+}
+const warnedInvalidSlideIds = /* @__PURE__ */ new Set();
+async function generateSlidesModule(files, slidesRoot, isDev) {
+	const scanned = await Promise.all(files.map(async (abs) => {
+		const id = toId(abs, slidesRoot);
+		const importPath = isDev ? `@fs/${normalizePath(abs).replace(/^\/+/, "")}` : abs;
+		const meta = await readSlideMeta(abs);
+		return {
+			id,
+			importPath,
+			theme: meta.theme,
+			createdAt: parseCreatedAtMs(meta.createdAt)
+		};
+	}));
+	const entries = scanned.filter((e) => SLIDE_ID_RE.test(e.id));
+	const ignored = scanned.filter((e) => !SLIDE_ID_RE.test(e.id)).map((e) => e.id);
+	const ids = JSON.stringify(entries.map((e) => e.id).sort());
+	const themesMap = {};
+	const createdAtMap = {};
+	for (const e of entries) {
+		if (e.theme) themesMap[e.id] = e.theme;
+		if (e.createdAt !== null) createdAtMap[e.id] = e.createdAt;
+	}
+	const themesJson = JSON.stringify(themesMap);
+	const createdAtJson = JSON.stringify(createdAtMap);
+	const importTokens = JSON.stringify(Object.fromEntries(entries.map((e) => [e.id, 0])));
+	return {
+		code: `// virtual:open-slide/slides — generated
+export const slideIds = ${ids};
+export const slideThemes = ${themesJson};
+export const slideCreatedAt = ${createdAtJson};
+${isDev ? `
+const slideImportTokens = ${importTokens};
+if (import.meta.hot) {
+  import.meta.hot.on('open-slide:slide-changed', (data) => {
+    const ids = Array.isArray(data?.slideIds) ? data.slideIds : [];
+    const token = Date.now();
+    for (const id of ids) {
+      if (Object.prototype.hasOwnProperty.call(slideImportTokens, id)) slideImportTokens[id] = token;
+    }
+  });
+}
+` : ""}
+
+export async function loadSlide(id) {
+  switch (id) {
+${entries.map((e) => {
+			const importExpr = isDev ? `import(/* @vite-ignore */ import.meta.env.BASE_URL + ${JSON.stringify(`${e.importPath}?t=`)} + slideImportTokens[${JSON.stringify(e.id)}])` : `import(${JSON.stringify(e.importPath)})`;
+			return `    case ${JSON.stringify(e.id)}: return ${importExpr};`;
+		}).join("\n")}
+    default: throw new Error('Slide not found: ' + id);
+  }
+}
+`,
+		ignored
+	};
+}
+function openSlidePlugin(opts) {
+	const { userCwd, config, coreVersion } = opts;
+	const slidesDir = config.slidesDir ?? "slides";
+	const slidesRoot = path.resolve(userCwd, slidesDir);
+	const manifestPath = foldersManifestPath(slidesRoot);
+	let isDev = false;
+	const slideIdForEntry = (p) => {
+		const rel = path.relative(slidesRoot, p);
+		if (rel.startsWith("..") || path.isAbsolute(rel)) return null;
+		const parts = rel.split(path.sep);
+		if (parts.length !== 2) return null;
+		if (!/^index\.(tsx|jsx|ts|js)$/.test(parts[1])) return null;
+		return parts[0];
+	};
+	let slideChangeTimer = null;
+	const pendingSlideChanges = /* @__PURE__ */ new Set();
+	const queueSlideChanged = (server, id) => {
+		pendingSlideChanges.add(id);
+		if (slideChangeTimer) clearTimeout(slideChangeTimer);
+		slideChangeTimer = setTimeout(() => {
+			slideChangeTimer = null;
+			const mod = server.moduleGraph.getModuleById(resolved$1(SLIDES_VMOD));
+			if (mod) server.moduleGraph.invalidateModule(mod);
+			const slideIds = Array.from(pendingSlideChanges);
+			pendingSlideChanges.clear();
+			server.ws.send({
+				type: "custom",
+				event: "open-slide:slide-changed",
+				data: { slideIds }
+			});
+		}, 100);
+	};
+	return {
+		name: "open-slide",
+		config(_c, env) {
+			isDev = env.command === "serve";
+		},
+		resolveId(id) {
+			if (id === SLIDES_VMOD) return resolved$1(SLIDES_VMOD);
+			if (id === CONFIG_VMOD) return resolved$1(CONFIG_VMOD);
+			if (id === FOLDERS_VMOD) return resolved$1(FOLDERS_VMOD);
+			return null;
+		},
+		async load(id) {
+			if (id === resolved$1(SLIDES_VMOD)) {
+				const { code, ignored } = await generateSlidesModule(await findSlides(userCwd, slidesDir), slidesRoot, isDev);
+				for (const slideId of ignored) {
+					if (warnedInvalidSlideIds.has(slideId)) continue;
+					warnedInvalidSlideIds.add(slideId);
+					this.warn(`Ignoring slide folder "${slideId}": slide ids must match ${SLIDE_ID_RE} (lowercase/uppercase letters, digits, "-", "_"). Rename the folder under "${slidesDir}/" to a kebab-case id so it appears in the browser and can be moved into folders.`);
+				}
+				return code;
+			}
+			if (id === resolved$1(CONFIG_VMOD)) {
+				const userBuild = config.build ?? {};
+				const buildResolved = isDev ? {
+					showSlideBrowser: true,
+					showSlideUi: true,
+					allowHtmlDownload: true
+				} : {
+					showSlideBrowser: userBuild.showSlideBrowser ?? true,
+					showSlideUi: userBuild.showSlideUi ?? true,
+					allowHtmlDownload: userBuild.allowHtmlDownload ?? true
+				};
+				const resolvedConfig = {
+					...config,
+					build: buildResolved,
+					version: coreVersion
+				};
+				return `export default ${JSON.stringify(resolvedConfig)};\n`;
+			}
+			if (id === resolved$1(FOLDERS_VMOD)) {
+				const manifest = await readManifest(manifestPath);
+				return `export default ${JSON.stringify(manifest)};\n`;
+			}
+			return null;
+		},
+		handleHotUpdate(ctx) {
+			const slideId = slideIdForEntry(ctx.file);
+			if (!slideId) return;
+			if (hasRecentWrite(ctx.file)) return [];
+			queueSlideChanged(ctx.server, slideId);
+			return [];
+		},
+		configureServer(server) {
+			const isSlideEntry = (p) => slideIdForEntry(p) !== null;
+			let reloadTimer = null;
+			const reload = () => {
+				if (reloadTimer) clearTimeout(reloadTimer);
+				reloadTimer = setTimeout(() => {
+					reloadTimer = null;
+					const mod = server.moduleGraph.getModuleById(resolved$1(SLIDES_VMOD));
+					if (mod) server.moduleGraph.invalidateModule(mod);
+					server.ws.send({ type: "full-reload" });
+				}, 150);
+			};
+			if (existsSync(slidesRoot)) server.watcher.add(slidesRoot);
+			server.watcher.on("add", (p) => {
+				if (isSlideEntry(p) && !hasRecentWrite(p)) reload();
+			});
+			server.watcher.on("unlink", (p) => {
+				if (isSlideEntry(p) && !hasRecentWrite(p)) reload();
+			});
+			let foldersTimer = null;
+			const invalidateFolders = () => {
+				if (foldersTimer) clearTimeout(foldersTimer);
+				foldersTimer = setTimeout(() => {
+					foldersTimer = null;
+					const mod = server.moduleGraph.getModuleById(resolved$1(FOLDERS_VMOD));
+					if (mod) server.moduleGraph.invalidateModule(mod);
+				}, 100);
+			};
+			server.watcher.add(manifestPath);
+			server.watcher.on("change", (p) => {
+				if (p === manifestPath) invalidateFolders();
+			});
+			server.watcher.on("add", (p) => {
+				if (p === manifestPath) invalidateFolders();
+			});
+			server.watcher.on("unlink", (p) => {
+				if (p === manifestPath) invalidateFolders();
+			});
+		}
+	};
+}
+function invalidateSlidesModule(server) {
+	const mod = server.moduleGraph.getModuleById(resolved$1(SLIDES_VMOD));
+	if (mod) server.moduleGraph.invalidateModule(mod);
+}
+async function loadUserConfig(userCwd) {
+	const file = path.join(userCwd, CONFIG_FILE);
+	if (!existsSync(file)) return {};
+	return (await loadConfigFromFile({
+		command: "serve",
+		mode: "development"
+	}, file, userCwd, "silent"))?.config ?? {};
+}
+//#endregion
+//#region src/vite/routes/agent.ts
+function parseContext(raw) {
+	if (!raw || typeof raw !== "object") return void 0;
+	const r = raw;
+	const ctx = {};
+	if (typeof r.slideId === "string" && SLIDE_ID_RE.test(r.slideId)) ctx.slideId = r.slideId;
+	if (typeof r.slideTitle === "string") ctx.slideTitle = r.slideTitle.slice(0, 120);
+	if (typeof r.pageNumber === "number" && Number.isFinite(r.pageNumber)) ctx.pageNumber = Math.max(1, Math.floor(r.pageNumber));
+	if (typeof r.totalPages === "number" && Number.isFinite(r.totalPages)) ctx.totalPages = Math.max(1, Math.floor(r.totalPages));
+	if (typeof r.pendingComments === "number" && Number.isFinite(r.pendingComments)) ctx.pendingComments = Math.max(0, Math.floor(r.pendingComments));
+	if (r.newDeck === true) ctx.newDeck = true;
+	const sel = r.selection;
+	if (sel && typeof sel === "object") {
+		const s = sel;
+		if (typeof s.line === "number" && typeof s.column === "number") ctx.selection = {
+			line: Math.max(1, Math.floor(s.line)),
+			column: Math.max(0, Math.floor(s.column)),
+			tagName: typeof s.tagName === "string" ? s.tagName.slice(0, 32) : "element",
+			text: typeof s.text === "string" ? s.text.slice(0, 120) : ""
+		};
+	}
+	return ctx;
+}
+const MODEL_RE = /^[\w.:[\]-]{1,80}$/;
+function parseModel(raw) {
+	return typeof raw === "string" && MODEL_RE.test(raw) ? raw : null;
+}
+async function renamePlaceholderDeck(server, ctx, store, broadcast, turn) {
+	const session = store.get(turn.sessionId);
+	const slideId = session?.slideId;
+	if (!session || !slideId || !UNTITLED_SLIDE_ID_RE.test(slideId)) return;
+	const start = session.items.findIndex((i) => i.id === turn.userItemId);
+	let marked = null;
+	for (const item of session.items.slice(start + 1)) {
+		if (item.kind !== "assistant") continue;
+		const slug = extractDeckSlug(item.text);
+		if (slug === null) continue;
+		marked = slug;
+		store.updateItem(session.id, item.id, "assistant", { text: stripDeckSlug(item.text) });
+	}
+	if (store.list().some((s) => s.slideId === slideId && s.status === "running")) return;
+	const entry = resolveSlideEntry(ctx.slidesRoot, slideId);
+	if (!entry) return;
+	let source;
+	try {
+		source = await fs.readFile(entry, "utf8");
+	} catch {
+		return;
+	}
+	const meta = readMetaTitleInSource(source);
+	if (meta.kind !== "found" || meta.title === "Untitled") return;
+	const desired = slugifyTitle(marked ?? "") || slugifyTitle(meta.title);
+	if (!desired || UNTITLED_SLIDE_ID_RE.test(desired)) return;
+	if (store.list().some((s) => s.slideId === slideId && s.status === "running")) return;
+	recordWrite(entry);
+	const renamed = await renameSlideDir(ctx.slidesRoot, slideId, desired);
+	if (!renamed.ok) return;
+	recordWrite(path.join(renamed.to, "index.tsx"));
+	const manifest = await readManifest(ctx.manifestPath);
+	const folderId = manifest.assignments[slideId];
+	if (folderId) {
+		delete manifest.assignments[slideId];
+		manifest.assignments[renamed.slideId] = folderId;
+		await writeManifest(ctx.manifestPath, manifest);
+	}
+	for (const s of store.list()) if (s.slideId === slideId) store.patch(s.id, { slideId: renamed.slideId });
+	invalidateSlidesModule(server);
+	broadcast({
+		type: "slide-renamed",
+		from: slideId,
+		to: renamed.slideId
+	});
+}
+function parseRespond(raw) {
+	if (!raw || typeof raw !== "object") return null;
+	const r = raw;
+	if (r.cancel === true) return { cancel: true };
+	if (typeof r.allow === "boolean") return { allow: r.allow };
+	if (r.answers && typeof r.answers === "object") {
+		const answers = {};
+		for (const [k, v] of Object.entries(r.answers)) if (typeof v === "string") answers[k] = v;
+		return { answers };
+	}
+	return null;
+}
+function parseTurnSettings(raw) {
+	const settings = {};
+	const context = parseContext(raw.context);
+	if (context) settings.context = context;
+	if (typeof raw.autoApprove === "boolean") settings.autoApprove = raw.autoApprove;
+	if ("model" in raw) settings.model = parseModel(raw.model);
+	if ("effort" in raw) settings.effort = isAgentEffort(raw.effort) ? raw.effort : null;
+	return settings;
+}
+const AGENT_BODY_LIMIT = 1048576;
+function registerAgentRoutes(server, ctx) {
+	const providers = createProviders();
+	const store = createSessionStore({ file: path.join(ctx.userCwd, "node_modules", ".open-slide", "agent-sessions.json") });
+	const streams = /* @__PURE__ */ new Set();
+	const broadcast = (event) => {
+		const frame = `data: ${JSON.stringify(event)}\n\n`;
+		for (const stream of streams) stream.write(frame);
+	};
+	const heartbeat = setInterval(() => {
+		for (const stream of streams) stream.write(": ping\n\n");
+	}, 25e3);
+	heartbeat.unref();
+	const runner = createAgentRunner({
+		userCwd: ctx.userCwd,
+		writableRoots: [ctx.slidesRoot, ctx.globalAssetsRoot],
+		store,
+		providers,
+		onTurnEnd: (turn) => renamePlaceholderDeck(server, ctx, store, broadcast, turn)
+	});
+	store.subscribe(broadcast);
+	server.httpServer?.on("close", () => {
+		clearInterval(heartbeat);
+		for (const stream of streams) stream.end();
+		runner.stopAll();
+		store.flush();
+	});
+	const installsInFlight = /* @__PURE__ */ new Map();
+	server.middlewares.use("/__agent", async (req, res, next) => {
+		const url = new URL(req.url ?? "/", "http://local");
+		const method = req.method ?? "GET";
+		const segments = url.pathname.split("/").filter(Boolean);
+		const enabled = ctx.agentEnabled && isLoopbackRequest(req);
+		try {
+			if (method === "GET" && url.pathname === "/status") {
+				res.setHeader("cache-control", "no-store");
+				if (!enabled) return json(res, 200, {
+					enabled: false,
+					packageManager: "",
+					providers: []
+				});
+				const pm = await detectPackageManager(ctx.userCwd);
+				return json(res, 200, await agentStatus(ctx.userCwd, providers, pm));
+			}
+			if (!enabled) return json(res, 404, { error: "agent panel disabled" });
+			if (method === "GET" && url.pathname === "/events") {
+				res.writeHead(200, {
+					"content-type": "text/event-stream",
+					"cache-control": "no-store",
+					connection: "keep-alive"
+				});
+				res.write(": connected\n\n");
+				streams.add(res);
+				const drop = () => streams.delete(res);
+				res.on("close", drop);
+				res.on("error", drop);
+				return;
+			}
+			if (method === "POST" && url.pathname === "/install") {
+				const guard = validateMutationRequest(req, { requireJsonBody: true });
+				if (!guard.ok) return json(res, guard.status, { error: guard.error });
+				const body = await readBody(req, AGENT_BODY_LIMIT);
+				if (!isAgentProviderId(body.provider)) return json(res, 400, { error: "invalid provider" });
+				const provider = providers[body.provider];
+				const pm = await detectPackageManager(ctx.userCwd);
+				const pkg = provider.sdkPackage;
+				let install = installsInFlight.get(pkg);
+				if (!install) {
+					install = installSdk(pm, pkg, ctx.userCwd).finally(() => installsInFlight.delete(pkg));
+					installsInFlight.set(pkg, install);
+				}
+				await install;
+				return json(res, 200, { ok: true });
+			}
+			if (method === "GET" && url.pathname === "/sessions") {
+				res.setHeader("cache-control", "no-store");
+				return json(res, 200, { sessions: store.list() });
+			}
+			if (method === "POST" && url.pathname === "/sessions") {
+				const guard = validateMutationRequest(req, { requireJsonBody: true });
+				if (!guard.ok) return json(res, guard.status, { error: guard.error });
+				const body = await readBody(req, AGENT_BODY_LIMIT);
+				if (!isAgentProviderId(body.provider)) return json(res, 400, { error: "invalid provider" });
+				const slideId = typeof body.slideId === "string" && SLIDE_ID_RE.test(body.slideId) ? body.slideId : null;
+				return json(res, 200, store.create(body.provider, slideId));
+			}
+			if (segments[0] === "sessions" && segments[1]) {
+				const id = segments[1];
+				const action = segments[2];
+				const session = store.get(id);
+				if (!session) return json(res, 404, { error: "session not found" });
+				if (method === "GET" && !action) {
+					res.setHeader("cache-control", "no-store");
+					return json(res, 200, session);
+				}
+				if (method === "DELETE" && !action) {
+					const guard = validateMutationRequest(req);
+					if (!guard.ok) return json(res, guard.status, { error: guard.error });
+					runner.stop(id);
+					store.remove(id);
+					return json(res, 200, { ok: true });
+				}
+				if (method === "POST" && action === "messages") {
+					const guard = validateMutationRequest(req, { requireJsonBody: true });
+					if (!guard.ok) return json(res, guard.status, { error: guard.error });
+					const body = await readBody(req, AGENT_BODY_LIMIT);
+					if (typeof body.text !== "string" || !body.text.trim()) return json(res, 400, { error: "missing text" });
+					if (runner.isRunning(id)) return json(res, 409, { error: "session is already running" });
+					if (body.edit !== void 0 && !session.items.some((i) => i.id === body.edit && i.kind === "user")) return json(res, 400, { error: "unknown message" });
+					await runner.send(id, {
+						text: body.text,
+						context: parseContext(body.context),
+						autoApprove: body.autoApprove === true,
+						model: parseModel(body.model),
+						effort: isAgentEffort(body.effort) ? body.effort : null,
+						edit: typeof body.edit === "string" ? body.edit : void 0
+					});
+					return json(res, 202, { ok: true });
+				}
+				if (method === "POST" && action === "stop") {
+					const guard = validateMutationRequest(req);
+					if (!guard.ok) return json(res, guard.status, { error: guard.error });
+					return json(res, 200, { ok: runner.stop(id) });
+				}
+				if (method === "POST" && action === "respond") {
+					const guard = validateMutationRequest(req, { requireJsonBody: true });
+					if (!guard.ok) return json(res, guard.status, { error: guard.error });
+					const body = await readBody(req, AGENT_BODY_LIMIT);
+					const payload = parseRespond(body);
+					if (typeof body.itemId !== "string" || !payload) return json(res, 400, { error: "invalid response" });
+					const ok = runner.respond(id, body.itemId, payload, parseTurnSettings(body));
+					return json(res, ok ? 200 : 409, ok ? { ok } : { error: "nothing pending" });
+				}
+			}
+			next();
+		} catch (err) {
+			if (err instanceof BodyTooLargeError) return json(res, 413, { error: err.message });
+			json(res, 500, { error: String(err.message ?? err) });
+		}
+	});
+}
+//#endregion
 //#region src/editing/babel-walk.ts
 const SKIP_KEYS = /* @__PURE__ */ new Set([
 	"loc",
@@ -2120,6 +4089,18 @@ function registerSlideRoutes(server, ctx) {
 		const url = new URL(req.url ?? "/", "http://local");
 		const method = req.method ?? "GET";
 		try {
+			if (url.pathname === "/" && method === "POST") {
+				const requestCheck = validateMutationRequest(req);
+				if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+				const created = await createBlankSlideDir(ctx.slidesRoot);
+				if (!created.ok) return json(res, created.status, { error: created.error });
+				recordWrite(created.file);
+				invalidateSlidesModule(server);
+				return json(res, 200, {
+					ok: true,
+					slideId: created.slideId
+				});
+			}
 			const reorderMatch = url.pathname.match(/^\/([^/]+)\/reorder$/);
 			if (reorderMatch && method === "PUT") {
 				const requestCheck = validateMutationRequest(req, { requireJsonBody: true });
@@ -2341,6 +4322,7 @@ function apiPlugin(opts) {
 			registerFolderRoutes(server, ctx);
 			registerUpdateRoutes(server, ctx);
 			registerRestartRoutes(server);
+			registerAgentRoutes(server, ctx);
 		}
 	};
 }
@@ -2851,24 +4833,6 @@ function locTagsPlugin(opts) {
 	};
 }
 //#endregion
-//#region src/vite/recent-writes.ts
-const recentWrites = /* @__PURE__ */ new Map();
-/** Record that `file` was just written by us. */
-function recordWrite(file, now = Date.now()) {
-	recentWrites.set(file, now);
-}
-/**
-* True if `file` was recorded within the recent-write window. Expired entries
-* are pruned so a stale path can no longer suppress a later genuine edit.
-*/
-function hasRecentWrite(file, now = Date.now()) {
-	const ts = recentWrites.get(file);
-	if (ts == null) return false;
-	if (now - ts < 1500) return true;
-	recentWrites.delete(file);
-	return false;
-}
-//#endregion
 //#region src/vite/notes-plugin.ts
 function findNotesExport(ast) {
 	for (const stmt of ast.program.body) {
@@ -2919,353 +4883,93 @@ function applyNotesEdit(source, index, text) {
 	};
 	const found = findNotesExport(ast);
 	if (found && "error" in found) return {
-		ok: false,
-		status: 422,
-		error: found.error
-	};
-	const literal = renderNoteLiteral(text);
-	if (!found) {
-		if (text === "") return {
-			ok: true,
-			source
-		};
-		const block = [
-			"",
-			"",
-			"export const notes: (string | undefined)[] = [",
-			...[...Array.from({ length: index }, () => "undefined"), literal].map((s) => `  ${s},`),
-			"];",
-			""
-		].join("\n");
-		const offset = findInsertionOffset(ast, source);
-		return {
-			ok: true,
-			source: source.slice(0, offset) + block + source.slice(offset)
-		};
-	}
-	const elementTexts = [];
-	for (const el of found.elements) {
-		if (el === null) {
-			elementTexts.push("undefined");
-			continue;
-		}
-		if (typeof el.start !== "number" || typeof el.end !== "number") return {
-			ok: false,
-			status: 422,
-			error: "`notes` element missing source range"
-		};
-		elementTexts.push(source.slice(el.start, el.end));
-	}
-	while (elementTexts.length <= index) elementTexts.push("undefined");
-	elementTexts[index] = literal;
-	while (elementTexts.length > 0 && elementTexts[elementTexts.length - 1] === "undefined") elementTexts.pop();
-	const replacement = elementTexts.length === 0 ? "[]" : `[\n${elementTexts.map((s) => `  ${s},`).join("\n")}\n]`;
-	return {
-		ok: true,
-		source: source.slice(0, found.arrayStart) + replacement + source.slice(found.arrayEnd)
-	};
-}
-function notesPlugin(opts) {
-	const slidesRoot = path.resolve(opts.userCwd, opts.slidesDir ?? "slides");
-	return {
-		name: "open-slide:notes",
-		apply: "serve",
-		handleHotUpdate(ctx) {
-			if (hasRecentWrite(ctx.file)) return [];
-		},
-		configureServer(server) {
-			server.middlewares.use("/__notes", async (req, res, next) => {
-				const url = new URL(req.url ?? "/", "http://local");
-				if ((req.method ?? "GET") !== "PUT" || url.pathname !== "/") return next();
-				const requestCheck = validateMutationRequest(req, { requireJsonBody: true });
-				if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
-				try {
-					const body = await readBody(req);
-					const slideId = body.slideId ?? "";
-					const file = resolveSlideEntry(slidesRoot, slideId);
-					if (!file) return json(res, 400, { error: "invalid slideId" });
-					if (typeof body.index !== "number") return json(res, 400, { error: "missing index" });
-					if (typeof body.text !== "string") return json(res, 400, { error: "missing text" });
-					const source = await readSlideSource(file);
-					if (source === null) return json(res, 404, { error: "slide not found" });
-					const result = applyNotesEdit(source, body.index, body.text);
-					if (!result.ok) return json(res, result.status, { error: result.error });
-					const changed = result.source !== source;
-					if (changed) {
-						recordWrite(file);
-						await fs.writeFile(file, result.source, "utf8");
-					}
-					return json(res, 200, {
-						ok: true,
-						changed
-					});
-				} catch (err) {
-					json(res, 500, { error: String(err.message ?? err) });
-				}
-			});
-		}
-	};
-}
-//#endregion
-//#region src/vite/open-slide-plugin.ts
-const CONFIG_FILE = "open-slide.config.ts";
-const SLIDES_VMOD = "virtual:open-slide/slides";
-const CONFIG_VMOD = "virtual:open-slide/config";
-const FOLDERS_VMOD = "virtual:open-slide/folders";
-function resolved$1(id) {
-	return `\0${id}`;
-}
-async function findSlides(userCwd, slidesDir) {
-	const abs = path.resolve(userCwd, slidesDir);
-	if (!existsSync(abs)) return [];
-	return (await fg("*/index.{tsx,jsx,ts,js}", {
-		cwd: abs,
-		absolute: true,
-		onlyFiles: true
-	})).sort();
-}
-function toId(absFile, slidesRoot) {
-	return path.relative(slidesRoot, absFile).split(path.sep)[0];
-}
-const META_THEME_RE = /(?:^|[\s,{])theme\s*:\s*['"]([^'"]+)['"]/;
-const META_CREATED_AT_RE = /(?:^|[\s,{])createdAt\s*:\s*['"]([^'"]+)['"]/;
-function extractMeta(src) {
-	const empty = {
-		theme: null,
-		createdAt: null
-	};
-	const metaStart = src.search(/export\s+const\s+meta\b/);
-	if (metaStart === -1) return empty;
-	const eqIdx = src.indexOf("=", metaStart);
-	if (eqIdx === -1) return empty;
-	const openBrace = src.indexOf("{", eqIdx);
-	if (openBrace === -1) return empty;
-	let depth = 0;
-	let closeBrace = -1;
-	for (let i = openBrace; i < src.length; i++) {
-		const ch = src[i];
-		if (ch === "{") depth++;
-		else if (ch === "}") {
-			depth--;
-			if (depth === 0) {
-				closeBrace = i;
-				break;
-			}
-		}
-	}
-	if (closeBrace === -1) return empty;
-	const body = src.slice(openBrace + 1, closeBrace);
-	const themeMatch = body.match(META_THEME_RE);
-	const createdAtMatch = body.match(META_CREATED_AT_RE);
-	return {
-		theme: themeMatch ? themeMatch[1] : null,
-		createdAt: createdAtMatch ? createdAtMatch[1] : null
+		ok: false,
+		status: 422,
+		error: found.error
 	};
-}
-async function readSlideMeta(abs) {
-	try {
-		return extractMeta(await fs.readFile(abs, "utf8"));
-	} catch {
+	const literal = renderNoteLiteral(text);
+	if (!found) {
+		if (text === "") return {
+			ok: true,
+			source
+		};
+		const block = [
+			"",
+			"",
+			"export const notes: (string | undefined)[] = [",
+			...[...Array.from({ length: index }, () => "undefined"), literal].map((s) => `  ${s},`),
+			"];",
+			""
+		].join("\n");
+		const offset = findInsertionOffset(ast, source);
 		return {
-			theme: null,
-			createdAt: null
+			ok: true,
+			source: source.slice(0, offset) + block + source.slice(offset)
 		};
 	}
-}
-function parseCreatedAtMs(iso) {
-	if (!iso) return null;
-	const ms = Date.parse(iso);
-	return Number.isFinite(ms) ? ms : null;
-}
-const warnedInvalidSlideIds = /* @__PURE__ */ new Set();
-async function generateSlidesModule(files, slidesRoot, isDev) {
-	const scanned = await Promise.all(files.map(async (abs) => {
-		const id = toId(abs, slidesRoot);
-		const importPath = isDev ? `@fs/${normalizePath(abs).replace(/^\/+/, "")}` : abs;
-		const meta = await readSlideMeta(abs);
-		return {
-			id,
-			importPath,
-			theme: meta.theme,
-			createdAt: parseCreatedAtMs(meta.createdAt)
+	const elementTexts = [];
+	for (const el of found.elements) {
+		if (el === null) {
+			elementTexts.push("undefined");
+			continue;
+		}
+		if (typeof el.start !== "number" || typeof el.end !== "number") return {
+			ok: false,
+			status: 422,
+			error: "`notes` element missing source range"
 		};
-	}));
-	const entries = scanned.filter((e) => SLIDE_ID_RE.test(e.id));
-	const ignored = scanned.filter((e) => !SLIDE_ID_RE.test(e.id)).map((e) => e.id);
-	const ids = JSON.stringify(entries.map((e) => e.id).sort());
-	const themesMap = {};
-	const createdAtMap = {};
-	for (const e of entries) {
-		if (e.theme) themesMap[e.id] = e.theme;
-		if (e.createdAt !== null) createdAtMap[e.id] = e.createdAt;
+		elementTexts.push(source.slice(el.start, el.end));
 	}
-	const themesJson = JSON.stringify(themesMap);
-	const createdAtJson = JSON.stringify(createdAtMap);
-	const importTokens = JSON.stringify(Object.fromEntries(entries.map((e) => [e.id, 0])));
+	while (elementTexts.length <= index) elementTexts.push("undefined");
+	elementTexts[index] = literal;
+	while (elementTexts.length > 0 && elementTexts[elementTexts.length - 1] === "undefined") elementTexts.pop();
+	const replacement = elementTexts.length === 0 ? "[]" : `[\n${elementTexts.map((s) => `  ${s},`).join("\n")}\n]`;
 	return {
-		code: `// virtual:open-slide/slides — generated
-export const slideIds = ${ids};
-export const slideThemes = ${themesJson};
-export const slideCreatedAt = ${createdAtJson};
-${isDev ? `
-const slideImportTokens = ${importTokens};
-if (import.meta.hot) {
-  import.meta.hot.on('open-slide:slide-changed', (data) => {
-    const ids = Array.isArray(data?.slideIds) ? data.slideIds : [];
-    const token = Date.now();
-    for (const id of ids) {
-      if (Object.prototype.hasOwnProperty.call(slideImportTokens, id)) slideImportTokens[id] = token;
-    }
-  });
-}
-` : ""}
-
-export async function loadSlide(id) {
-  switch (id) {
-${entries.map((e) => {
-			const importExpr = isDev ? `import(/* @vite-ignore */ import.meta.env.BASE_URL + ${JSON.stringify(`${e.importPath}?t=`)} + slideImportTokens[${JSON.stringify(e.id)}])` : `import(${JSON.stringify(e.importPath)})`;
-			return `    case ${JSON.stringify(e.id)}: return ${importExpr};`;
-		}).join("\n")}
-    default: throw new Error('Slide not found: ' + id);
-  }
-}
-`,
-		ignored
+		ok: true,
+		source: source.slice(0, found.arrayStart) + replacement + source.slice(found.arrayEnd)
 	};
 }
-function openSlidePlugin(opts) {
-	const { userCwd, config, coreVersion } = opts;
-	const slidesDir = config.slidesDir ?? "slides";
-	const slidesRoot = path.resolve(userCwd, slidesDir);
-	const manifestPath = foldersManifestPath(slidesRoot);
-	let isDev = false;
-	const slideIdForEntry = (p) => {
-		const rel = path.relative(slidesRoot, p);
-		if (rel.startsWith("..") || path.isAbsolute(rel)) return null;
-		const parts = rel.split(path.sep);
-		if (parts.length !== 2) return null;
-		if (!/^index\.(tsx|jsx|ts|js)$/.test(parts[1])) return null;
-		return parts[0];
-	};
-	let slideChangeTimer = null;
-	const pendingSlideChanges = /* @__PURE__ */ new Set();
-	const queueSlideChanged = (server, id) => {
-		pendingSlideChanges.add(id);
-		if (slideChangeTimer) clearTimeout(slideChangeTimer);
-		slideChangeTimer = setTimeout(() => {
-			slideChangeTimer = null;
-			const mod = server.moduleGraph.getModuleById(resolved$1(SLIDES_VMOD));
-			if (mod) server.moduleGraph.invalidateModule(mod);
-			const slideIds = Array.from(pendingSlideChanges);
-			pendingSlideChanges.clear();
-			server.ws.send({
-				type: "custom",
-				event: "open-slide:slide-changed",
-				data: { slideIds }
-			});
-		}, 100);
-	};
+function notesPlugin(opts) {
+	const slidesRoot = path.resolve(opts.userCwd, opts.slidesDir ?? "slides");
 	return {
-		name: "open-slide",
-		config(_c, env) {
-			isDev = env.command === "serve";
-		},
-		resolveId(id) {
-			if (id === SLIDES_VMOD) return resolved$1(SLIDES_VMOD);
-			if (id === CONFIG_VMOD) return resolved$1(CONFIG_VMOD);
-			if (id === FOLDERS_VMOD) return resolved$1(FOLDERS_VMOD);
-			return null;
-		},
-		async load(id) {
-			if (id === resolved$1(SLIDES_VMOD)) {
-				const { code, ignored } = await generateSlidesModule(await findSlides(userCwd, slidesDir), slidesRoot, isDev);
-				for (const slideId of ignored) {
-					if (warnedInvalidSlideIds.has(slideId)) continue;
-					warnedInvalidSlideIds.add(slideId);
-					this.warn(`Ignoring slide folder "${slideId}": slide ids must match ${SLIDE_ID_RE} (lowercase/uppercase letters, digits, "-", "_"). Rename the folder under "${slidesDir}/" to a kebab-case id so it appears in the browser and can be moved into folders.`);
-				}
-				return code;
-			}
-			if (id === resolved$1(CONFIG_VMOD)) {
-				const userBuild = config.build ?? {};
-				const buildResolved = isDev ? {
-					showSlideBrowser: true,
-					showSlideUi: true,
-					allowHtmlDownload: true
-				} : {
-					showSlideBrowser: userBuild.showSlideBrowser ?? true,
-					showSlideUi: userBuild.showSlideUi ?? true,
-					allowHtmlDownload: userBuild.allowHtmlDownload ?? true
-				};
-				const resolvedConfig = {
-					...config,
-					build: buildResolved,
-					version: coreVersion
-				};
-				return `export default ${JSON.stringify(resolvedConfig)};\n`;
-			}
-			if (id === resolved$1(FOLDERS_VMOD)) {
-				const manifest = await readManifest(manifestPath);
-				return `export default ${JSON.stringify(manifest)};\n`;
-			}
-			return null;
-		},
+		name: "open-slide:notes",
+		apply: "serve",
 		handleHotUpdate(ctx) {
-			const slideId = slideIdForEntry(ctx.file);
-			if (!slideId) return;
 			if (hasRecentWrite(ctx.file)) return [];
-			queueSlideChanged(ctx.server, slideId);
-			return [];
 		},
 		configureServer(server) {
-			const isSlideEntry = (p) => slideIdForEntry(p) !== null;
-			let reloadTimer = null;
-			const reload = () => {
-				if (reloadTimer) clearTimeout(reloadTimer);
-				reloadTimer = setTimeout(() => {
-					reloadTimer = null;
-					const mod = server.moduleGraph.getModuleById(resolved$1(SLIDES_VMOD));
-					if (mod) server.moduleGraph.invalidateModule(mod);
-					server.ws.send({ type: "full-reload" });
-				}, 150);
-			};
-			if (existsSync(slidesRoot)) server.watcher.add(slidesRoot);
-			server.watcher.on("add", (p) => {
-				if (isSlideEntry(p)) reload();
-			});
-			server.watcher.on("unlink", (p) => {
-				if (isSlideEntry(p)) reload();
-			});
-			let foldersTimer = null;
-			const invalidateFolders = () => {
-				if (foldersTimer) clearTimeout(foldersTimer);
-				foldersTimer = setTimeout(() => {
-					foldersTimer = null;
-					const mod = server.moduleGraph.getModuleById(resolved$1(FOLDERS_VMOD));
-					if (mod) server.moduleGraph.invalidateModule(mod);
-				}, 100);
-			};
-			server.watcher.add(manifestPath);
-			server.watcher.on("change", (p) => {
-				if (p === manifestPath) invalidateFolders();
-			});
-			server.watcher.on("add", (p) => {
-				if (p === manifestPath) invalidateFolders();
-			});
-			server.watcher.on("unlink", (p) => {
-				if (p === manifestPath) invalidateFolders();
+			server.middlewares.use("/__notes", async (req, res, next) => {
+				const url = new URL(req.url ?? "/", "http://local");
+				if ((req.method ?? "GET") !== "PUT" || url.pathname !== "/") return next();
+				const requestCheck = validateMutationRequest(req, { requireJsonBody: true });
+				if (!requestCheck.ok) return json(res, requestCheck.status, { error: requestCheck.error });
+				try {
+					const body = await readBody(req);
+					const slideId = body.slideId ?? "";
+					const file = resolveSlideEntry(slidesRoot, slideId);
+					if (!file) return json(res, 400, { error: "invalid slideId" });
+					if (typeof body.index !== "number") return json(res, 400, { error: "missing index" });
+					if (typeof body.text !== "string") return json(res, 400, { error: "missing text" });
+					const source = await readSlideSource(file);
+					if (source === null) return json(res, 404, { error: "slide not found" });
+					const result = applyNotesEdit(source, body.index, body.text);
+					if (!result.ok) return json(res, result.status, { error: result.error });
+					const changed = result.source !== source;
+					if (changed) {
+						recordWrite(file);
+						await fs.writeFile(file, result.source, "utf8");
+					}
+					return json(res, 200, {
+						ok: true,
+						changed
+					});
+				} catch (err) {
+					json(res, 500, { error: String(err.message ?? err) });
+				}
 			});
 		}
 	};
 }
-async function loadUserConfig(userCwd) {
-	const file = path.join(userCwd, CONFIG_FILE);
-	if (!existsSync(file)) return {};
-	return (await loadConfigFromFile({
-		command: "serve",
-		mode: "development"
-	}, file, userCwd, "silent"))?.config ?? {};
-}
 //#endregion
 //#region src/vite/server-info-plugin.ts
 function serverInfoUrl(address, https, base) {
@@ -3527,7 +5231,8 @@ async function createViteConfig(opts) {
 				userCwd,
 				slidesDir,
 				assetsDir,
-				coreVersion: CORE_VERSION
+				coreVersion: CORE_VERSION,
+				agentEnabled: config.agent?.enabled ?? true
 			}),
 			notesPlugin({
 				userCwd,
@@ -3561,7 +5266,8 @@ async function createViteConfig(opts) {
 				"clsx",
 				"tailwind-merge",
 				"class-variance-authority",
-				"emoji-picker-react"
+				"emoji-picker-react",
+				"pele"
 			],
 			rolldownOptions: { plugins: [{
 				name: "open-slide:virtual-externals",