@nawc/cli 0.1.1

package/dist/server-B0NGps95.mjs

@@ -0,0 +1,1646 @@
+import { createRequire } from "node:module";
+import { syntaxFor } from "@nawc/config";
+import { vscode } from "@nawc/editor-vscode";
+import { nawcLight } from "@nawc/theme-nawc";
+import { createServer } from "node:http";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { randomUUID } from "node:crypto";
+import { access, mkdir, readFile, readdir, realpath, rename, rm, rmdir, stat, writeFile } from "node:fs/promises";
+import { getRequestListener } from "@hono/node-server";
+import { watch } from "chokidar";
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import { createJiti } from "jiti";
+import { spawn } from "node-pty";
+import { createServer as createServer$1 } from "vite";
+import { WebSocketServer } from "ws";
+import { execFile, spawn as spawn$1 } from "node:child_process";
+import { promisify } from "node:util";
+import MiniSearch from "minisearch";
+import { parseFragment } from "parse5";
+import { mkdirSync } from "node:fs";
+import { DatabaseSync } from "node:sqlite";
+import { z } from "zod";
+//#region src/workspace.ts
+const execFileAsync = promisify(execFile);
+const GENERATED_DIRECTORY_NAMES = /* @__PURE__ */ new Set([
+	".git",
+	".nawc",
+	".skills",
+	"build",
+	"coverage",
+	"dist",
+	"node_modules"
+]);
+const PROJECT_FILE_CACHE_TTL_MS = 2e3;
+const projectFileCache = /* @__PURE__ */ new Map();
+async function safePath(root, relative) {
+	if (path.isAbsolute(relative)) throw new Error("Paths must be relative");
+	const resolvedRoot = path.resolve(root);
+	const target = path.resolve(resolvedRoot, relative);
+	if (target !== resolvedRoot && !target.startsWith(`${resolvedRoot}${path.sep}`)) throw new Error("Path escapes the configured directory");
+	return target;
+}
+async function safeExistingPath(root, relative) {
+	const target = await realpath(await safePath(root, relative));
+	const resolvedRoot = await realpath(root);
+	if (target !== resolvedRoot && !target.startsWith(`${resolvedRoot}${path.sep}`)) throw new Error("Path escapes the configured directory through a symbolic link");
+	return target;
+}
+async function listNotes(srcDir) {
+	const notes = [];
+	const walk = async (directory) => {
+		for (const entry of await readdir(directory, { withFileTypes: true })) {
+			const file = path.join(directory, entry.name);
+			if (entry.isDirectory()) await walk(file);
+			else if (entry.isFile() && entry.name.endsWith(".html")) notes.push(path.relative(srcDir, file));
+		}
+	};
+	await mkdir(srcDir, { recursive: true });
+	await walk(srcDir);
+	return notes.sort();
+}
+async function listEntries(srcDir) {
+	const entries = [];
+	const walk = async (directory) => {
+		for (const entry of await readdir(directory, { withFileTypes: true })) {
+			const file = path.join(directory, entry.name);
+			if (entry.isDirectory()) {
+				entries.push({
+					path: path.relative(srcDir, file),
+					type: "folder"
+				});
+				await walk(file);
+			} else if (entry.isFile() && entry.name.endsWith(".html")) entries.push({
+				path: path.relative(srcDir, file),
+				type: "file"
+			});
+		}
+	};
+	await mkdir(srcDir, { recursive: true });
+	await walk(srcDir);
+	return entries.sort((left, right) => left.path.localeCompare(right.path));
+}
+async function projectFileCandidates(baseDir) {
+	const cacheKey = path.resolve(baseDir);
+	const cached = projectFileCache.get(cacheKey);
+	if (cached && cached.expiresAt > Date.now()) return cached.files;
+	const { stdout } = await execFileAsync("git", [
+		"-C",
+		baseDir,
+		"ls-files",
+		"-co",
+		"--exclude-standard",
+		"-z",
+		"--",
+		"."
+	], {
+		encoding: "utf8",
+		maxBuffer: 16 * 1024 * 1024
+	});
+	const files = stdout.split("\0").filter(Boolean).filter((file) => !file.split(/[\\/]/).some((segment) => GENERATED_DIRECTORY_NAMES.has(segment))).sort();
+	projectFileCache.set(cacheKey, {
+		expiresAt: Date.now() + PROJECT_FILE_CACHE_TTL_MS,
+		files
+	});
+	return files;
+}
+async function projectPathCandidates(baseDir) {
+	const files = await projectFileCandidates(baseDir);
+	const paths = new Set(files);
+	for (const file of files) {
+		const segments = file.split("/");
+		for (let index = 1; index < segments.length; index++) paths.add(segments.slice(0, index).join("/"));
+	}
+	return [...paths].sort();
+}
+/** Lists searchable project files and their containing directories. */
+async function listProjectPaths(baseDir, options = {}) {
+	const query = options.query?.trim().toLowerCase();
+	const limit = options.limit === void 0 ? void 0 : Math.max(0, options.limit);
+	const candidates = (await projectPathCandidates(baseDir)).filter((candidate) => !query || candidate.toLowerCase().includes(query)).slice(0, limit === void 0 ? void 0 : limit * 2);
+	return (await Promise.all(candidates.map(async (candidate) => {
+		try {
+			return {
+				path: candidate,
+				kind: (await stat(await safeExistingPath(baseDir, candidate))).isDirectory() ? "directory" : "file"
+			};
+		} catch {
+			return;
+		}
+	}))).filter((entry) => entry !== void 0).slice(0, limit);
+}
+/** Validates one submitted project path, including directories. */
+async function isProjectPath(baseDir, file) {
+	if (!(await projectPathCandidates(baseDir)).includes(file)) return false;
+	try {
+		await safeExistingPath(baseDir, file);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function readNote(srcDir, note) {
+	return readFile(await safePath(srcDir, note), "utf8");
+}
+async function writeNote(srcDir, note, content) {
+	if (!note.endsWith(".html")) throw new Error("Notes must use the .html extension");
+	const file = await safePath(srcDir, note);
+	await mkdir(path.dirname(file), { recursive: true });
+	await writeFile(file, content, "utf8");
+}
+async function deleteNote(srcDir, note) {
+	await rm(await safePath(srcDir, note));
+}
+async function createFolder(srcDir, folder) {
+	await mkdir(await safePath(srcDir, folder), { recursive: false });
+}
+async function deleteEntry(srcDir, entry) {
+	await rm(await safePath(srcDir, entry), { recursive: true });
+}
+async function renameEntry(srcDir, from, to) {
+	const source = await safePath(srcDir, from);
+	const target = await safePath(srcDir, to);
+	try {
+		await access(target);
+		throw new Error(`An entry already exists at ${to}`);
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+			await mkdir(path.dirname(target), { recursive: true });
+			await rename(source, target);
+			return;
+		}
+		throw error;
+	}
+}
+async function moveEntry(srcDir, from, to, replace = false) {
+	const source = await safePath(srcDir, from);
+	const target = await safePath(srcDir, to);
+	if (source === target) return;
+	if (target.startsWith(`${source}${path.sep}`)) throw new Error("A folder cannot be moved inside itself");
+	try {
+		await access(target);
+		if (!replace) throw new Error(`An entry already exists at ${to}`);
+		await rm(target, { recursive: true });
+	} catch (error) {
+		if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
+	}
+	await mkdir(path.dirname(target), { recursive: true });
+	await rename(source, target);
+}
+async function renameNote(srcDir, from, to) {
+	if (!to.endsWith(".html")) throw new Error("Notes must use the .html extension");
+	const target = await safePath(srcDir, to);
+	await mkdir(path.dirname(target), { recursive: true });
+	await rename(await safePath(srcDir, from), target);
+}
+async function resolveSource(config, baseDir, selection) {
+	const source = await readFile(await safePath(baseDir, selection.file), "utf8");
+	if (!selection.syntax) return {
+		...selection,
+		code: source,
+		startLine: 1,
+		endLine: source.split("\n").length
+	};
+	const syntax = syntaxFor(config, selection.syntax);
+	if (!syntax) throw new Error(`Unknown syntax: ${selection.syntax}`);
+	const resolved = syntax.resolve(source, selection);
+	if (!resolved) throw new Error(`Could not find ${selection.type ?? "symbol"} ${selection.name ?? ""}${selection.params === void 0 ? "" : `(${selection.params})`} in ${selection.file}`);
+	return resolved;
+}
+async function assertGitRepository(baseDir) {
+	let current = await realpath(baseDir);
+	while (true) try {
+		await realpath(path.join(current, ".git"));
+		return;
+	} catch {
+		const parent = path.dirname(current);
+		if (parent === current) throw new Error(`NAWC baseDir must be inside a Git repository: ${baseDir}`);
+		current = parent;
+	}
+}
+//#endregion
+//#region src/skills.ts
+const legacyHeader = "<!-- Generated by NAWC. Changes will be replaced. -->\n\n";
+const generatedHeader = "---\n# Generated by NAWC. Changes will be replaced.\n";
+function isGeneratedSkill(content) {
+	return content.startsWith(legacyHeader) || content.startsWith(generatedHeader);
+}
+/** Canonicalize skill markdown so generation matches oxfmt (lists, spacing). */
+function normalizeSkillMarkdown(content) {
+	const lines = content.split("\n").map((line) => line.replace(/^(\s*)\*(\s+)/, "$1-$2"));
+	const out = [];
+	for (const line of lines) {
+		const prev = out.at(-1);
+		const isList = /^(\s*)([-*+]|\d+\.)\s/.test(line);
+		const prevIsList = prev !== void 0 && /^(\s*)([-*+]|\d+\.)\s/.test(prev);
+		const prevBlank = prev === void 0 || prev === "";
+		const prevIsFence = prev !== void 0 && /^`{3}/.test(prev);
+		const prevIsAtxHeading = prev !== void 0 && /^#{1,6}(\s|$)/.test(prev);
+		if (isList && prev !== void 0 && !prevBlank && !prevIsList && !prevIsFence && !prevIsAtxHeading) out.push("");
+		out.push(line);
+	}
+	return out.join("\n");
+}
+function renderGeneratedSkill(content) {
+	const trimmed = content.trim();
+	return normalizeSkillMarkdown(trimmed.startsWith("---") ? `${generatedHeader}${trimmed.slice(3).replace(/^\n/, "")}\n` : `${legacyHeader}${trimmed}\n`);
+}
+async function syncSkills(projectDir, plugins) {
+	const skillsDir = path.join(projectDir, ".skills");
+	const generatedSkills = /* @__PURE__ */ new Set();
+	for (const plugin of plugins) for (const skill of plugin.skills ?? []) {
+		generatedSkills.add(skill.name);
+		const directory = path.join(skillsDir, skill.name);
+		const file = path.join(directory, "SKILL.md");
+		await mkdir(directory, { recursive: true });
+		try {
+			if (!isGeneratedSkill(await readFile(file, "utf8"))) throw new Error(`Refusing to overwrite user-owned skill: ${file}`);
+		} catch (error) {
+			if (error instanceof Error && !error.message.includes("ENOENT")) throw error;
+		}
+		await writeFile(file, renderGeneratedSkill(skill.content), "utf8");
+	}
+	for (const entry of await readdir(skillsDir, { withFileTypes: true })) {
+		if (!entry.isDirectory() || generatedSkills.has(entry.name)) continue;
+		const file = path.join(skillsDir, entry.name, "SKILL.md");
+		try {
+			if (!isGeneratedSkill(await readFile(file, "utf8"))) continue;
+			await rm(file);
+			await rmdir(path.join(skillsDir, entry.name));
+		} catch (error) {
+			const code = error && typeof error === "object" && "code" in error && typeof error.code === "string" ? error.code : void 0;
+			if (code !== "ENOENT" && code !== "ENOTEMPTY") throw error;
+		}
+	}
+	return skillsDir;
+}
+//#endregion
+//#region src/run-protocol.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isOptionalString(value) {
+	return value === void 0 || typeof value === "string";
+}
+function isSelection(value) {
+	return isRecord(value) && (typeof value.file === "string" && value.file.length > 0 || typeof value.source === "string" && value.source.length <= 1e6) && isOptionalString(value.source) && (value.source === void 0 || value.source.length <= 1e6) && isOptionalString(value.syntax) && isOptionalString(value.name) && isOptionalString(value.type) && isOptionalString(value.params);
+}
+function isDimension(value) {
+	return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value > 0;
+}
+function parseRunClientEvent(value) {
+	let parsed;
+	try {
+		parsed = JSON.parse(value);
+	} catch {
+		return;
+	}
+	if (!isRecord(parsed) || typeof parsed.type !== "string") return;
+	if (parsed.type === "start" && isSelection(parsed.selection) && isDimension(parsed.cols) && isDimension(parsed.rows)) return {
+		type: "start",
+		selection: parsed.selection,
+		cols: parsed.cols,
+		rows: parsed.rows
+	};
+	if (parsed.type === "input" && typeof parsed.data === "string") return {
+		type: "input",
+		data: parsed.data
+	};
+	if (parsed.type === "resize" && isDimension(parsed.cols) && isDimension(parsed.rows)) return {
+		type: "resize",
+		cols: parsed.cols,
+		rows: parsed.rows
+	};
+}
+function isSameOrigin(origin, host, allowRemote = false) {
+	if (!origin || !host) return false;
+	try {
+		const configured = new URL(`http://${host}`);
+		if (!allowRemote && configured.hostname !== "localhost" && configured.hostname !== "127.0.0.1" && configured.hostname !== "::1") return false;
+		const requested = new URL(origin);
+		return (requested.protocol === "http:" || requested.protocol === "https:") && requested.host === configured.host;
+	} catch {
+		return false;
+	}
+}
+function isPreviewRequest(origin, host) {
+	return origin === "null" || host?.startsWith("127.0.0.1:") === true;
+}
+//#endregion
+//#region src/editor.ts
+const CLI_INSTALL_HINTS = {
+	vscode: "Open the Command Palette and run 'Shell Command: Install code command in PATH'.",
+	idea: "In the IDE use Tools → Create Command-line Launcher, or add the install's bin directory to your PATH. Toolbox users: Settings → Generate shell scripts.",
+	webstorm: "In the IDE use Tools → Create Command-line Launcher, or add the install's bin directory to your PATH. Toolbox users: Settings → Generate shell scripts.",
+	clion: "In the IDE use Tools → Create Command-line Launcher, or add the install's bin directory to your PATH. Toolbox users: Settings → Generate shell scripts.",
+	zed: "Install the Zed CLI: open Zed → Command Palette → 'cli: install cli binary'.",
+	cursor: "Open the Command Palette and run 'Shell Command: Install cursor command in PATH'."
+};
+function installHint(editorName) {
+	return CLI_INSTALL_HINTS[editorName] ?? "Make sure the editor's CLI is installed and available on your PATH.";
+}
+function commandNotFoundError(editor, command) {
+	return /* @__PURE__ */ new Error(`Could not find the "${command}" command for ${editor.label}. ${installHint(editor.name)}`);
+}
+function urlOpenCommand(url, platform = process.platform) {
+	if (platform === "darwin") return ["open", url];
+	if (platform === "win32") return [
+		"rundll32.exe",
+		"url.dll,FileProtocolHandler",
+		url
+	];
+	return ["xdg-open", url];
+}
+async function launchEditor(editor, location) {
+	const target = editor.open(location);
+	const [command, ...args] = target.type === "url" ? urlOpenCommand(target.url) : target.command;
+	if (!command) throw new Error(`Editor ${editor.name} returned an empty command`);
+	const child = spawn$1(command, args, {
+		detached: target.type === "command",
+		stdio: "ignore"
+	});
+	if (target.type === "url") {
+		await new Promise((resolve, reject) => {
+			child.once("error", (err) => {
+				if (err.code === "ENOENT") reject(commandNotFoundError(editor, command));
+				else reject(err);
+			});
+			child.once("close", (code) => {
+				if (code === 0) resolve();
+				else reject(/* @__PURE__ */ new Error(`Could not open ${editor.label} (launcher exited with code ${code})`));
+			});
+		});
+		return;
+	}
+	await new Promise((resolve, reject) => {
+		let settled = false;
+		const settle = (fn) => {
+			if (settled) return;
+			settled = true;
+			fn();
+		};
+		child.once("error", (err) => {
+			settle(() => {
+				if (err.code === "ENOENT") reject(commandNotFoundError(editor, command));
+				else reject(err);
+			});
+		});
+		child.once("spawn", () => settle(() => resolve()));
+	});
+	child.unref();
+}
+//#endregion
+//#region src/note-search.ts
+function noteTitle(notePath) {
+	return path.basename(notePath, ".html");
+}
+function htmlText(html) {
+	const root = parseFragment(html);
+	const parts = [];
+	const visit = (node, ignored = false) => {
+		const skip = ignored || node.nodeName === "script" || node.nodeName === "style";
+		if (!skip && node.nodeName === "#text" && node.value) parts.push(node.value);
+		for (const child of node.childNodes ?? []) visit(child, skip);
+	};
+	visit(root);
+	return parts.join(" ").replace(/\s+/g, " ").trim();
+}
+function snippet(text, terms, maximumLength = 150) {
+	if (text.length <= maximumLength) return text;
+	const lower = text.toLowerCase();
+	const positions = terms.map((term) => lower.indexOf(term.toLowerCase())).filter((position) => position >= 0);
+	const match = positions.length ? Math.min(...positions) : 0;
+	const start = Math.max(0, Math.min(match - 45, text.length - maximumLength));
+	const beginning = start > 0 ? "…" : "";
+	const ending = start + maximumLength < text.length ? "…" : "";
+	return `${beginning}${text.slice(start, start + maximumLength).trim()}${ending}`;
+}
+function createIndex() {
+	return new MiniSearch({
+		fields: [
+			"title",
+			"path",
+			"text"
+		],
+		idField: "path",
+		storeFields: [
+			"path",
+			"title",
+			"text"
+		],
+		searchOptions: {
+			boost: {
+				title: 6,
+				path: 4,
+				text: 1
+			},
+			combineWith: "OR",
+			fuzzy: .2,
+			prefix: (_term, index, terms) => index === terms.length - 1
+		}
+	});
+}
+var NoteSearchIndex = class {
+	#srcDir;
+	#dirty = true;
+	#revision = 0;
+	#index = createIndex();
+	#rebuild;
+	#recencyBoost = /* @__PURE__ */ new Map();
+	constructor(srcDir) {
+		this.#srcDir = srcDir;
+	}
+	invalidate() {
+		this.#dirty = true;
+		this.#revision += 1;
+	}
+	async #ensureFresh() {
+		while (this.#dirty) {
+			if (!this.#rebuild) {
+				const revision = this.#revision;
+				this.#rebuild = (async () => {
+					const notes = await listNotes(this.#srcDir);
+					const entries = await Promise.all(notes.map(async (notePath) => {
+						const fullPath = path.join(this.#srcDir, notePath);
+						const [html, fileStat] = await Promise.all([readFile(fullPath, "utf8"), stat(fullPath)]);
+						const daysOld = (Date.now() - fileStat.mtimeMs) / (1e3 * 60 * 60 * 24);
+						const boost = 1 + .5 * Math.exp(-daysOld / 14);
+						return {
+							doc: {
+								path: notePath,
+								title: noteTitle(notePath),
+								text: htmlText(html)
+							},
+							boost
+						};
+					}));
+					const next = createIndex();
+					next.addAll(entries.map((e) => e.doc));
+					this.#index = next;
+					this.#recencyBoost = new Map(entries.map((e) => [e.doc.path, e.boost]));
+					this.#dirty = revision !== this.#revision;
+				})().finally(() => {
+					this.#rebuild = void 0;
+				});
+			}
+			await this.#rebuild;
+		}
+	}
+	async search(query, limit = 30) {
+		await this.#ensureFresh();
+		const normalized = query.trim();
+		if (!normalized) return [];
+		return this.#index.search(normalized, { boostDocument: (docId) => this.#recencyBoost.get(docId) ?? 1 }).slice(0, limit).map((result) => {
+			const note = result;
+			return {
+				path: note.path,
+				title: note.title,
+				snippet: snippet(note.text, result.terms),
+				terms: result.terms
+			};
+		});
+	}
+};
+//#endregion
+//#region src/agent-references.ts
+function promptReferenceKey(reference) {
+	switch (reference.type) {
+		case "file": return `file:${reference.path}`;
+		case "skill": return `skill:${reference.name}`;
+		case "note": return `note:${reference.path}`;
+		case "diagnostic": return `diagnostic:${reference.file ?? ""}:${reference.line ?? ""}:${reference.message}`;
+	}
+}
+/** Drop bulky note bodies from thread message metadata (UI only shows path chips). */
+function displayReference(reference) {
+	if (reference.type === "note") return {
+		type: "note",
+		path: reference.path
+	};
+	return reference;
+}
+/**
+* Full content (notes) and structured attach lines are injected once per thread.
+* Later turns keep:
+* - notes as path-only (current note still known)
+* - files/skills/diagnostics omitted (already in provider history; user text still has @/$ etc.)
+*/
+function prepareTurnReferences(references, attachedReferenceKeys) {
+	const attached = new Set(attachedReferenceKeys);
+	const prepared = [];
+	for (const reference of references) {
+		const key = promptReferenceKey(reference);
+		if (attached.has(key)) {
+			if (reference.type === "note") prepared.push({
+				type: "note",
+				path: reference.path
+			});
+			continue;
+		}
+		attached.add(key);
+		attachedReferenceKeys.push(key);
+		prepared.push(reference);
+	}
+	return prepared;
+}
+//#endregion
+//#region src/agent-thread.ts
+const timestamp = () => (/* @__PURE__ */ new Date()).toISOString();
+function createAgentThread(provider, id = randomUUID()) {
+	const now = timestamp();
+	return {
+		id,
+		provider,
+		createdAt: now,
+		updatedAt: now,
+		status: "idle",
+		turns: [],
+		messages: [],
+		activities: [],
+		requests: [],
+		warnings: [],
+		unknownEvents: [],
+		attachedReferenceKeys: []
+	};
+}
+function startAgentTurn(thread, input, turnId = randomUUID()) {
+	const now = timestamp();
+	const turn = {
+		id: turnId,
+		status: "running",
+		createdAt: now,
+		updatedAt: now
+	};
+	thread.turns.push(turn);
+	thread.messages.push({
+		id: randomUUID(),
+		role: "user",
+		text: input.text,
+		turnId,
+		createdAt: now,
+		updatedAt: now,
+		streaming: false,
+		references: input.references,
+		attachments: input.attachments?.map(({ dataUrl: _dataUrl, ...attachment }) => attachment)
+	});
+	thread.status = "running";
+	thread.updatedAt = now;
+	return turn;
+}
+function findTurn(thread, turnId) {
+	const turn = thread.turns.find((item) => item.id === turnId);
+	if (!turn) throw new Error(`Unknown agent turn: ${turnId}`);
+	return turn;
+}
+function assistantMessage(thread, turnId, event) {
+	const itemId = event.itemId;
+	const existing = [...thread.messages].reverse().find((message) => message.turnId === turnId && message.role === "assistant" && (itemId === void 0 || message.id === itemId));
+	if (existing) return existing;
+	const now = event.createdAt ?? timestamp();
+	const message = {
+		id: itemId ?? randomUUID(),
+		role: "assistant",
+		text: "",
+		turnId,
+		createdAt: now,
+		updatedAt: now,
+		streaming: true
+	};
+	thread.messages.push(message);
+	return message;
+}
+function projectProviderEvent(thread, defaultTurnId, event) {
+	const turnId = event.turnId ?? defaultTurnId;
+	const now = event.createdAt ?? timestamp();
+	thread.updatedAt = now;
+	switch (event.type) {
+		case "session.started":
+			thread.providerSessionId = event.sessionId;
+			return;
+		case "thread.started":
+			thread.providerThreadId = event.threadId;
+			return;
+		case "turn.started": return;
+		case "message.started":
+			assistantMessage(thread, turnId, event);
+			return;
+		case "message.delta": {
+			const message = assistantMessage(thread, turnId, event);
+			message.text += event.text;
+			message.updatedAt = now;
+			return;
+		}
+		case "message.completed":
+		case "message": {
+			const message = assistantMessage(thread, turnId, event);
+			const text = event.type === "message" ? event.text : event.text;
+			if (text !== void 0 && (!message.text || text !== message.text)) message.text = text;
+			message.streaming = false;
+			message.updatedAt = now;
+			return;
+		}
+		case "command":
+		case "tool.started":
+		case "tool.updated":
+		case "tool.completed": {
+			const legacy = event.type === "command";
+			const id = event.itemId ?? event.id ?? `${turnId}:${legacy ? event.command : event.title}`;
+			const existing = thread.activities.find((activity) => activity.id === id);
+			const status = legacy ? event.status === "running" ? "running" : "completed" : event.status ?? (event.type === "tool.completed" ? "completed" : "running");
+			if (existing) {
+				existing.status = status;
+				existing.title = legacy ? event.command : event.title;
+				if (!legacy && event.output !== void 0) existing.output = event.output;
+			} else thread.activities.push({
+				id,
+				turnId,
+				createdAt: now,
+				tool: legacy ? "command_execution" : event.tool,
+				title: legacy ? event.command : event.title,
+				status,
+				...!legacy && event.output !== void 0 ? { output: event.output } : {}
+			});
+			return;
+		}
+		case "plan.updated":
+			findTurn(thread, turnId).plan = event.markdown;
+			return;
+		case "thinking": {
+			const turn = findTurn(thread, turnId);
+			if (!turn.thinking) turn.thinking = [];
+			turn.thinking.push({
+				text: event.text,
+				createdAt: now
+			});
+			return;
+		}
+		case "request.opened":
+			thread.requests.push({
+				id: event.requestId,
+				turnId,
+				kind: event.requestKind,
+				title: event.title,
+				details: event.details,
+				choices: event.choices,
+				allowCustom: event.allowCustom,
+				status: "pending"
+			});
+			return;
+		case "request.resolved": {
+			const request = thread.requests.find((item) => item.id === event.requestId);
+			if (request) {
+				request.status = "resolved";
+				request.decision = event.decision;
+			}
+			return;
+		}
+		case "warning":
+			thread.warnings.push({
+				message: event.message,
+				turnId: event.turnId
+			});
+			return;
+		case "error": {
+			thread.status = "error";
+			const turn = findTurn(thread, turnId);
+			turn.status = "failed";
+			turn.updatedAt = now;
+			thread.warnings.push({
+				message: event.message,
+				turnId: event.turnId ?? turnId
+			});
+			return;
+		}
+		case "turn.interrupted": {
+			const turn = findTurn(thread, turnId);
+			turn.status = "interrupted";
+			turn.updatedAt = now;
+			thread.status = "idle";
+			return;
+		}
+		case "turn.completed":
+		case "done": {
+			const turn = findTurn(thread, turnId);
+			turn.status = "completed";
+			turn.updatedAt = now;
+			if (event.type === "turn.completed" && event.usage) turn.usage = {
+				...turn.usage,
+				...event.usage
+			};
+			for (const message of thread.messages) if (message.turnId === turnId) message.streaming = false;
+			thread.status = "idle";
+			return;
+		}
+		case "context.updated": {
+			const turn = findTurn(thread, turnId);
+			turn.usage = event.usage;
+			turn.updatedAt = now;
+			thread.updatedAt = now;
+			return;
+		}
+		case "unknown":
+			thread.unknownEvents.push(event);
+			if (thread.unknownEvents.length > 500) thread.unknownEvents.splice(0, thread.unknownEvents.length - 500);
+			return;
+	}
+}
+//#endregion
+//#region src/agent-state.ts
+const agentWarningSchema = z.object({
+	message: z.string(),
+	turnId: z.string().optional()
+});
+const SAVE_DEBOUNCE_MS = 100;
+var AgentState = class {
+	#database;
+	#saveStatement;
+	#deleteStatement;
+	#pending = /* @__PURE__ */ new Map();
+	#timers = /* @__PURE__ */ new Map();
+	constructor(file) {
+		mkdirSync(path.dirname(file), { recursive: true });
+		this.#database = new DatabaseSync(file);
+		this.#database.exec("CREATE TABLE IF NOT EXISTS agent_threads (id TEXT PRIMARY KEY, data TEXT NOT NULL)");
+		this.#saveStatement = this.#database.prepare("INSERT INTO agent_threads (id, data) VALUES (?, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data");
+		this.#deleteStatement = this.#database.prepare("DELETE FROM agent_threads WHERE id = ?");
+	}
+	load() {
+		return this.#database.prepare("SELECT data FROM agent_threads").all().map((row) => {
+			if (typeof row.data !== "string") throw new Error("Invalid persisted agent thread");
+			const thread = JSON.parse(row.data);
+			return {
+				...thread,
+				warnings: thread.warnings.map((w) => agentWarningSchema.safeParse(w)).filter((r) => r.success).map((r) => r.data)
+			};
+		});
+	}
+	save(thread) {
+		this.#pending.set(thread.id, thread);
+		const existing = this.#timers.get(thread.id);
+		if (existing) clearTimeout(existing);
+		const timer = setTimeout(() => {
+			this.#timers.delete(thread.id);
+			this.#flushOne(thread.id);
+		}, SAVE_DEBOUNCE_MS);
+		timer.unref?.();
+		this.#timers.set(thread.id, timer);
+	}
+	#flushOne(threadId) {
+		const thread = this.#pending.get(threadId);
+		if (!thread) return;
+		this.#pending.delete(threadId);
+		this.#saveStatement.run(thread.id, JSON.stringify(thread));
+	}
+	delete(threadId) {
+		const timer = this.#timers.get(threadId);
+		if (timer) {
+			clearTimeout(timer);
+			this.#timers.delete(threadId);
+		}
+		this.#pending.delete(threadId);
+		this.#deleteStatement.run(threadId);
+	}
+	close() {
+		for (const timer of this.#timers.values()) clearTimeout(timer);
+		this.#timers.clear();
+		for (const threadId of Array.from(this.#pending.keys())) this.#flushOne(threadId);
+		this.#database.close();
+	}
+};
+//#endregion
+//#region src/agent-manager.ts
+var AgentManager = class {
+	#provider;
+	#cwd;
+	#skillsDir;
+	#threads = /* @__PURE__ */ new Map();
+	#state;
+	#sessions = /* @__PURE__ */ new Map();
+	#controllers = /* @__PURE__ */ new Map();
+	#activeTurns = /* @__PURE__ */ new Set();
+	#listeners = /* @__PURE__ */ new Set();
+	#closed = false;
+	constructor(input) {
+		this.#provider = input.provider;
+		this.#cwd = input.cwd;
+		this.#skillsDir = input.skillsDir;
+		this.#state = input.statePath ? new AgentState(input.statePath) : void 0;
+		for (const thread of this.#state?.load() ?? []) {
+			const recovered = recoverThread(thread);
+			this.#threads.set(thread.id, thread);
+			if (recovered) this.#state?.save(thread);
+		}
+	}
+	metadata() {
+		return {
+			name: this.#provider.name,
+			label: this.#provider.label ?? this.#provider.name,
+			capabilities: this.#provider.capabilities ?? [],
+			modes: this.#provider.modes ?? [{
+				id: "default",
+				label: "Build"
+			}]
+		};
+	}
+	listThreads() {
+		return [...this.#threads.values()].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+	}
+	getThread(id) {
+		return this.#threads.get(id);
+	}
+	subscribe(listener) {
+		this.#listeners.add(listener);
+		return () => this.#listeners.delete(listener);
+	}
+	async createThread(settings) {
+		const thread = createAgentThread(this.#provider.name);
+		thread.model = settings.model;
+		thread.reasoningEffort = settings.reasoningEffort;
+		thread.options = settings.options;
+		thread.mode = settings.mode;
+		this.#threads.set(thread.id, thread);
+		this.#notify(thread.id);
+		return thread;
+	}
+	async deleteThread(id) {
+		const thread = this.#requireThread(id);
+		const session = this.#sessions.get(id);
+		this.#controllers.get(id)?.abort();
+		this.#controllers.delete(id);
+		const waiting = [...this.#activeTurns];
+		if (waiting.length > 0) await Promise.allSettled(waiting);
+		if (session) await this.#provider.closeSession?.(session);
+		this.#sessions.delete(id);
+		this.#threads.delete(thread.id);
+		this.#notify(thread.id);
+	}
+	async *sendTurn(input) {
+		const thread = this.#requireThread(input.threadId);
+		if (thread.status === "running" || this.#controllers.has(thread.id)) throw new Error("This agent thread is already running");
+		thread.model = input.model ?? thread.model;
+		thread.reasoningEffort = input.reasoningEffort ?? thread.reasoningEffort;
+		thread.options = input.options ?? thread.options;
+		thread.mode = input.mode ?? thread.mode;
+		const references = prepareTurnReferences(input.references, thread.attachedReferenceKeys);
+		const turn = startAgentTurn(thread, {
+			text: input.prompt,
+			references: input.references.map(displayReference),
+			attachments: input.attachments
+		});
+		this.#notify(thread.id);
+		const controller = new AbortController();
+		this.#controllers.set(thread.id, controller);
+		try {
+			let session = this.#sessions.get(thread.id);
+			if (!session) {
+				session = this.#provider.startSession ? await this.#provider.startSession({
+					cwd: this.#cwd,
+					providerThreadId: thread.providerThreadId,
+					model: thread.model,
+					reasoningEffort: thread.reasoningEffort,
+					options: thread.options,
+					mode: thread.mode
+				}) : {
+					id: thread.id,
+					providerThreadId: thread.providerThreadId
+				};
+				this.#sessions.set(thread.id, session);
+			}
+			const providerInput = {
+				prompt: input.prompt,
+				cwd: this.#cwd,
+				skillsDir: this.#skillsDir,
+				references,
+				attachments: input.attachments,
+				model: thread.model,
+				reasoningEffort: thread.reasoningEffort,
+				options: thread.options,
+				mode: thread.mode,
+				signal: controller.signal
+			};
+			const events = this.#provider.sendTurn ? this.#provider.sendTurn(session, providerInput) : this.#provider.prompt?.(providerInput);
+			if (!events) throw new Error(`Provider ${this.#provider.name} cannot send turns`);
+			let completed = false;
+			for await (const event of events) {
+				projectProviderEvent(thread, turn.id, event);
+				this.#notify(thread.id);
+				if (event.type === "thread.started") {
+					session = {
+						...session,
+						providerThreadId: event.threadId
+					};
+					this.#sessions.set(thread.id, session);
+				}
+				if (event.type === "turn.completed" || event.type === "done") completed = true;
+				yield {
+					...event,
+					turnId: event.turnId ?? turn.id
+				};
+			}
+			if (!completed) {
+				const event = controller.signal.aborted ? {
+					type: "turn.interrupted",
+					turnId: turn.id
+				} : {
+					type: "turn.completed",
+					turnId: turn.id
+				};
+				projectProviderEvent(thread, turn.id, event);
+				this.#notify(thread.id);
+				yield event;
+			}
+		} catch (error) {
+			const event = {
+				type: controller.signal.aborted ? "turn.interrupted" : "error",
+				turnId: turn.id,
+				...controller.signal.aborted ? {} : { message: error instanceof Error ? error.message : String(error) }
+			};
+			projectProviderEvent(thread, turn.id, event);
+			this.#notify(thread.id);
+			yield event;
+		} finally {
+			this.#controllers.delete(thread.id);
+		}
+	}
+	async interrupt(threadId) {
+		const thread = this.#threads.get(threadId);
+		const turn = thread?.turns.findLast((item) => item.status === "running");
+		if (thread?.status === "running" && turn) {
+			projectProviderEvent(thread, turn.id, {
+				type: "turn.interrupted",
+				turnId: turn.id
+			});
+			this.#notify(thread.id);
+		}
+		const session = this.#sessions.get(threadId);
+		this.#controllers.get(threadId)?.abort();
+		if (session) await this.#provider.interrupt?.(session);
+	}
+	async respondToRequest(threadId, requestId, decision) {
+		const thread = this.#requireThread(threadId);
+		const session = this.#sessions.get(threadId);
+		if (!session || !this.#provider.respondToRequest) throw new Error("This provider cannot respond to interactive requests");
+		await this.#provider.respondToRequest(session, requestId, decision);
+		const request = thread.requests.find((item) => item.id === requestId);
+		if (request) projectProviderEvent(thread, request.turnId, {
+			type: "request.resolved",
+			requestId,
+			decision
+		});
+		this.#notify(thread.id);
+	}
+	async close() {
+		if (this.#closed) return;
+		for (const threadId of this.#controllers.keys()) await this.interrupt(threadId);
+		if (this.#activeTurns.size > 0) await Promise.allSettled(this.#activeTurns);
+		for (const session of this.#sessions.values()) await this.#provider.closeSession?.(session);
+		this.#closed = true;
+		this.#state?.close();
+	}
+	trackActiveTurn(promise) {
+		const settled = promise.then(() => void 0, () => void 0);
+		this.#activeTurns.add(settled);
+		settled.finally(() => {
+			this.#activeTurns.delete(settled);
+		});
+	}
+	#requireThread(id) {
+		const thread = this.#threads.get(id);
+		if (!thread) throw new Error(`Unknown agent thread: ${id}`);
+		return thread;
+	}
+	#notify(threadId) {
+		const thread = this.#threads.get(threadId);
+		if (!this.#closed) if (thread) this.#state?.save(thread);
+		else this.#state?.delete(threadId);
+		for (const listener of this.#listeners) listener(threadId, thread);
+	}
+};
+function recoverThread(thread) {
+	let recovered = thread.status === "running";
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	for (const turn of thread.turns) {
+		if (turn.status !== "running") continue;
+		turn.status = "interrupted";
+		turn.updatedAt = now;
+		recovered = true;
+		for (const message of thread.messages) if (message.turnId === turn.id) message.streaming = false;
+	}
+	if (recovered) {
+		thread.status = "idle";
+		thread.updatedAt = now;
+	}
+	return recovered;
+}
+//#endregion
+//#region src/agent-input.ts
+const MAX_ATTACHMENTS = 8;
+const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+const MAX_DATA_URL_CHARACTERS = 14e6;
+function validateAgentAttachments(value) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value) || value.length > MAX_ATTACHMENTS) throw new Error("Invalid agent attachments");
+	const attachments = [];
+	for (const item of value) {
+		if (typeof item !== "object" || item === null) throw new Error("Invalid agent image attachment");
+		if (!("type" in item) || !("id" in item) || !("name" in item) || !("mimeType" in item) || !("sizeBytes" in item) || !("dataUrl" in item)) throw new Error("Invalid agent image attachment");
+		if (item.type !== "image" || typeof item.id !== "string" || !item.id || typeof item.name !== "string" || !item.name || typeof item.mimeType !== "string" || !item.mimeType.startsWith("image/") || typeof item.sizeBytes !== "number" || !Number.isInteger(item.sizeBytes) || item.sizeBytes < 0 || item.sizeBytes > MAX_IMAGE_BYTES || typeof item.dataUrl !== "string" || item.dataUrl.length > MAX_DATA_URL_CHARACTERS || !item.dataUrl.startsWith(`data:${item.mimeType};base64,`) || Buffer.byteLength(item.dataUrl.slice(item.dataUrl.indexOf(",") + 1), "base64") !== item.sizeBytes) throw new Error("Invalid agent image attachment");
+		attachments.push({
+			type: item.type,
+			id: item.id,
+			name: item.name,
+			mimeType: item.mimeType,
+			sizeBytes: item.sizeBytes,
+			dataUrl: item.dataUrl
+		});
+	}
+	return attachments;
+}
+//#endregion
+//#region src/server.ts
+async function loadConfig(projectDir, configFile = "nawc.config.ts") {
+	const file = path.resolve(projectDir, configFile);
+	return createJiti(import.meta.url, { interopDefault: true }).import(file, { default: true });
+}
+function message(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function rawDataText(data) {
+	if (Array.isArray(data)) return Buffer.concat(data).toString();
+	if (data instanceof ArrayBuffer) return Buffer.from(data).toString();
+	return data.toString();
+}
+async function listPromptSkills(config, skillsDir, providerSkills) {
+	const skills = providerSkills.filter((skill) => skill.enabled !== false).map((skill) => ({
+		name: skill.name,
+		path: skill.path,
+		source: skill.scope ? `${config.provider.name} · ${skill.scope}` : config.provider.name,
+		...skill.displayName ? { displayName: skill.displayName } : {},
+		...skill.shortDescription ? { shortDescription: skill.shortDescription } : {},
+		...skill.description ? { description: skill.description } : {},
+		...skill.scope ? { scope: skill.scope } : {}
+	}));
+	for (const plugin of config.plugins) for (const skill of plugin.skills ?? []) skills.push({
+		name: skill.name,
+		path: await safeExistingPath(skillsDir, path.join(skill.name, "SKILL.md")),
+		source: plugin.name,
+		displayName: skill.name,
+		shortDescription: "NAWC plugin skill"
+	});
+	return skills;
+}
+async function createNawcServer(options) {
+	const projectDir = path.resolve(options.projectDir);
+	const config = await loadConfig(projectDir, options.configFile);
+	const baseDir = path.resolve(projectDir, config.baseDir);
+	const srcDir = path.join(projectDir, "src");
+	const noteSearch = new NoteSearchIndex(srcDir);
+	await assertGitRepository(baseDir);
+	const skillsDir = await syncSkills(projectDir, config.plugins);
+	const agentManager = new AgentManager({
+		provider: config.provider,
+		cwd: baseDir,
+		skillsDir,
+		statePath: path.join(projectDir, ".nawc", "state.sqlite")
+	});
+	let providerSkillsPromise;
+	let providerModelsPromise;
+	let providerSettingsPromise;
+	const getProviderSkills = () => {
+		if (!providerSkillsPromise) providerSkillsPromise = (config.provider.listSkills ? config.provider.listSkills({
+			cwd: baseDir,
+			skillsDir
+		}) : Promise.resolve([])).catch((error) => {
+			providerSkillsPromise = void 0;
+			throw error;
+		});
+		return providerSkillsPromise;
+	};
+	const getPromptSkills = async () => listPromptSkills(config, skillsDir, await getProviderSkills());
+	const getProviderModels = () => {
+		if (!providerModelsPromise) providerModelsPromise = (config.provider.listModels ? config.provider.listModels({ cwd: baseDir }) : Promise.resolve([])).catch((error) => {
+			providerModelsPromise = void 0;
+			throw error;
+		});
+		return providerModelsPromise;
+	};
+	const getProviderSettings = () => {
+		if (!providerSettingsPromise) providerSettingsPromise = (config.provider.getSettings ? config.provider.getSettings({ cwd: baseDir }) : Promise.resolve({})).catch((error) => {
+			providerSettingsPromise = void 0;
+			throw error;
+		});
+		return providerSettingsPromise;
+	};
+	const validateAgentSelection = async (selection) => {
+		const models = await getProviderModels();
+		const settings = await getProviderSettings();
+		const modelId = selection.model ?? settings.model;
+		const model = modelId ? models.find((item) => item.id === modelId) : void 0;
+		if (selection.model && !model) throw new Error(`Unknown model: ${selection.model}`);
+		if (selection.reasoningEffort && model?.reasoningEfforts && !model.reasoningEfforts.some((effort) => effort.id === selection.reasoningEffort)) throw new Error(`Unknown reasoning effort: ${selection.reasoningEffort}`);
+		const seen = /* @__PURE__ */ new Set();
+		for (const option of selection.options ?? []) {
+			if (seen.has(option.id)) throw new Error(`Duplicate provider option: ${option.id}`);
+			seen.add(option.id);
+			const descriptor = model?.options?.find((item) => item.id === option.id);
+			if (!descriptor) throw new Error(`Unknown provider option: ${option.id}`);
+			if (descriptor.type === "boolean" && typeof option.value !== "boolean" || descriptor.type === "select" && (typeof option.value !== "string" || !descriptor.choices.some((choice) => choice.id === option.value))) throw new Error(`Invalid value for provider option: ${option.id}`);
+		}
+	};
+	const fileListeners = /* @__PURE__ */ new Set();
+	const watcher = watch(srcDir, {
+		ignored: [
+			"**/.git/**",
+			"**/node_modules/**",
+			"**/.skills/**"
+		],
+		ignoreInitial: true,
+		usePolling: true,
+		interval: 500
+	});
+	watcher.on("all", (event, file) => {
+		noteSearch.invalidate();
+		for (const listener of fileListeners) listener(event, file);
+	});
+	const watchedSourcePaths = [];
+	const MAX_WATCHED_SOURCE_PATHS = 1e3;
+	function watchSourcePath(absolutePath) {
+		if (watchedSourcePaths.includes(absolutePath)) {
+			const idx = watchedSourcePaths.indexOf(absolutePath);
+			watchedSourcePaths.splice(idx, 1);
+			watchedSourcePaths.push(absolutePath);
+			return;
+		}
+		if (watchedSourcePaths.length >= MAX_WATCHED_SOURCE_PATHS) {
+			const evicted = watchedSourcePaths.shift();
+			if (evicted) watcher.unwatch(evicted);
+		}
+		watchedSourcePaths.push(absolutePath);
+		watcher.add(absolutePath);
+	}
+	const app = new Hono();
+	app.onError((error, context) => context.json({ error: message(error) }, 400));
+	app.get("/api/meta", (context) => context.json({
+		provider: config.provider.name,
+		baseDir,
+		srcDir,
+		editor: {
+			name: (config.editor ?? vscode()).name,
+			label: (config.editor ?? vscode()).label,
+			icon: (config.editor ?? vscode()).icon
+		},
+		theme: config.theme ?? nawcLight(),
+		plugins: config.plugins.map(({ name, nodes }) => ({
+			name,
+			nodes
+		}))
+	}));
+	app.get("/api/notes", async (context) => context.json(await listNotes(srcDir)));
+	app.get("/api/search", async (context) => {
+		const query = context.req.query("q") ?? "";
+		return context.json(await noteSearch.search(query));
+	});
+	app.get("/api/files", async (context) => context.json(await listEntries(srcDir)));
+	app.get("/api/prompt/skills", async (context) => context.json((await getPromptSkills()).map(({ name, source, displayName, shortDescription, description, scope }) => ({
+		name,
+		source,
+		...displayName ? { displayName } : {},
+		...shortDescription ? { shortDescription } : {},
+		...description ? { description } : {},
+		...scope ? { scope } : {}
+	}))));
+	app.get("/api/prompt/files", async (context) => {
+		const query = (context.req.query("q") ?? "").trim().toLowerCase();
+		return context.json(await listProjectPaths(baseDir, {
+			query,
+			limit: 50
+		}));
+	});
+	app.get("/api/prompt/models", async (context) => context.json(await getProviderModels()));
+	app.get("/api/prompt/settings", async (context) => context.json(await getProviderSettings()));
+	app.get("/api/prompt/commands", async (context) => context.json(config.provider.listCommands ? await config.provider.listCommands({ cwd: baseDir }) : config.provider.slashCommands ?? []));
+	app.get("/api/agent/provider", (context) => context.json(agentManager.metadata()));
+	app.get("/api/agent/threads", (context) => context.json(agentManager.listThreads()));
+	app.get("/api/agent/threads/:id", (context) => {
+		const thread = agentManager.getThread(context.req.param("id"));
+		if (!thread) throw new Error("Unknown agent thread");
+		return context.json(thread);
+	});
+	app.post("/api/agent/threads", async (context) => {
+		const body = await context.req.json();
+		await validateAgentSelection(body);
+		return context.json(await agentManager.createThread(body));
+	});
+	app.delete("/api/agent/threads/:id", async (context) => {
+		await agentManager.deleteThread(context.req.param("id"));
+		return context.json({ ok: true });
+	});
+	app.post("/api/agent/threads/:id/interrupt", async (context) => {
+		await agentManager.interrupt(context.req.param("id"));
+		return context.json({ ok: true });
+	});
+	app.post("/api/agent/threads/:id/requests/:requestId", async (context) => {
+		const body = await context.req.json();
+		if (typeof body.decision !== "string" || !body.decision) throw new Error("Invalid decision");
+		await agentManager.respondToRequest(context.req.param("id"), context.req.param("requestId"), body.decision);
+		return context.json({ ok: true });
+	});
+	app.post("/api/agent/threads/:id/turns", async (context) => {
+		const body = await context.req.json();
+		if (typeof body.prompt !== "string" || !body.prompt.trim()) throw new Error("Prompt is required");
+		if ((body.references?.length ?? 0) > 50) throw new Error("Too many agent references");
+		const attachments = validateAgentAttachments(body.attachments);
+		await validateAgentSelection(body);
+		const availableSkills = new Map((await getPromptSkills()).map((skill) => [skill.name, skill.path]));
+		const references = [];
+		if (body.note) {
+			const content = body.noteContent ?? await readNote(srcDir, body.note);
+			references.push({
+				type: "note",
+				path: body.note,
+				content
+			});
+		}
+		for (const reference of body.references ?? []) if (reference.type === "file") {
+			if (!await isProjectPath(baseDir, reference.path)) continue;
+			references.push(reference);
+		} else if (reference.type === "skill") {
+			const skillPath = availableSkills.get(reference.name);
+			if (!skillPath) throw new Error(`Unknown skill reference: ${reference.name}`);
+			references.push({
+				...reference,
+				path: skillPath
+			});
+		} else if (reference.type === "diagnostic" && reference.message) references.push(reference);
+		else throw new Error("Invalid agent reference");
+		const threadId = context.req.param("id");
+		return streamSSE(context, async (stream) => {
+			stream.onAbort(() => {
+				agentManager.interrupt(threadId);
+			});
+			const turn = agentManager.sendTurn({
+				threadId,
+				prompt: body.prompt,
+				references,
+				attachments,
+				model: body.model,
+				reasoningEffort: body.reasoningEffort,
+				options: body.options,
+				mode: body.mode
+			});
+			let drainError;
+			const drain = (async () => {
+				try {
+					for await (const event of turn) await stream.writeSSE({
+						data: JSON.stringify(event),
+						event: event.type
+					});
+				} catch (error) {
+					drainError = error;
+				}
+			})();
+			agentManager.trackActiveTurn(drain);
+			await drain;
+			if (drainError) throw drainError;
+		});
+	});
+	app.get("/api/events", (context) => streamSSE(context, async (stream) => {
+		const agentListener = (threadId, thread) => void stream.writeSSE({
+			data: JSON.stringify({
+				event: "agent",
+				threadId,
+				thread: thread ?? null
+			}),
+			event: "agent"
+		});
+		const unsubscribeAgent = agentManager.subscribe(agentListener);
+		await stream.writeSSE({ data: JSON.stringify({ event: "ready" }) });
+		await new Promise((resolve) => {
+			const listener = (event, file) => void stream.writeSSE({ data: JSON.stringify({
+				event,
+				file: path.relative(srcDir, file)
+			}) });
+			fileListeners.add(listener);
+			stream.onAbort(() => {
+				fileListeners.delete(listener);
+				unsubscribeAgent();
+				resolve();
+			});
+		});
+	}));
+	app.get("/api/note", async (context) => context.text(await readNote(srcDir, context.req.query("path") ?? "")));
+	app.put("/api/note", async (context) => {
+		const body = await context.req.json();
+		await writeNote(srcDir, body.path, body.content);
+		noteSearch.invalidate();
+		return context.json({ ok: true });
+	});
+	app.delete("/api/note", async (context) => {
+		await deleteNote(srcDir, context.req.query("path") ?? "");
+		noteSearch.invalidate();
+		return context.json({ ok: true });
+	});
+	app.post("/api/note/rename", async (context) => {
+		const body = await context.req.json();
+		await renameNote(srcDir, body.from, body.to);
+		noteSearch.invalidate();
+		return context.json({ ok: true });
+	});
+	app.post("/api/folder", async (context) => {
+		const { path: folder } = await context.req.json();
+		await createFolder(srcDir, folder);
+		noteSearch.invalidate();
+		return context.json({ ok: true });
+	});
+	app.delete("/api/entry", async (context) => {
+		await deleteEntry(srcDir, context.req.query("path") ?? "");
+		noteSearch.invalidate();
+		return context.json({ ok: true });
+	});
+	app.post("/api/entry/rename", async (context) => {
+		const body = await context.req.json();
+		await renameEntry(srcDir, body.from, body.to);
+		noteSearch.invalidate();
+		return context.json({ ok: true });
+	});
+	app.post("/api/entry/move", async (context) => {
+		const body = await context.req.json();
+		await moveEntry(srcDir, body.from, body.to, body.replace);
+		noteSearch.invalidate();
+		return context.json({ ok: true });
+	});
+	app.post("/api/source", async (context) => {
+		const selection = await context.req.json();
+		watchSourcePath(await safePath(baseDir, selection.file));
+		return context.json(await resolveSource(config, baseDir, selection));
+	});
+	app.post("/api/editor/open", async (context) => {
+		const request = await context.req.json();
+		if (request.scope !== "note" && request.scope !== "source") throw new Error("Invalid editor scope");
+		if (request.line !== void 0 && (!Number.isInteger(request.line) || request.line < 1)) throw new Error("Invalid editor line");
+		if (request.column !== void 0 && (!Number.isInteger(request.column) || request.column < 1)) throw new Error("Invalid editor column");
+		let file;
+		let reveal;
+		try {
+			const resolved = await safeExistingPath(request.scope === "note" ? srcDir : baseDir, request.file);
+			if (resolved.startsWith(`${baseDir}${path.sep}`) || resolved === baseDir) {
+				reveal = path.relative(baseDir, resolved);
+				file = baseDir;
+			} else file = resolved;
+		} catch (err) {
+			if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") throw new Error(`File not found: ${request.file}`);
+			throw err;
+		}
+		await launchEditor(config.editor ?? vscode(), {
+			file,
+			line: request.line,
+			column: request.column,
+			reveal
+		});
+		return context.json({ ok: true });
+	});
+	app.post("/api/prompt", async (context) => {
+		const body = await context.req.json();
+		if (typeof body.prompt !== "string") throw new Error("Prompt must be a string");
+		if (body.model !== void 0 && typeof body.model !== "string") throw new Error("Model must be a string");
+		if (body.reasoningEffort !== void 0 && typeof body.reasoningEffort !== "string") throw new Error("Reasoning effort must be a string");
+		if (body.mode !== void 0 && body.mode !== "default" && body.mode !== "plan") throw new Error("Invalid prompt mode");
+		if ((body.references?.length ?? 0) > 50) throw new Error("Too many prompt references");
+		if (body.model && config.provider.listModels) {
+			if (!(await getProviderModels()).some((model) => model.id === body.model)) throw new Error(`Unknown model: ${body.model}`);
+		}
+		const availableSkills = new Map((await getPromptSkills()).map((skill) => [skill.name, skill.path]));
+		const references = [];
+		for (const reference of body.references ?? []) if (reference.type === "file") {
+			if (!await isProjectPath(baseDir, reference.path)) continue;
+			references.push({
+				type: "file",
+				path: reference.path
+			});
+		} else if (reference.type === "skill") {
+			const skillPath = availableSkills.get(reference.name);
+			if (!skillPath) throw new Error(`Unknown skill reference: ${reference.name}`);
+			references.push({
+				type: "skill",
+				name: reference.name,
+				path: skillPath
+			});
+		} else throw new Error("Invalid prompt reference");
+		const referenceContext = references.length ? `\n\nNAWC references selected by the user:\n${references.map((reference) => reference.type === "file" ? `- File: ${JSON.stringify(reference.path)} (relative to the working directory)` : reference.type === "skill" ? `- Skill: ${JSON.stringify(`$${reference.name}`)} (${JSON.stringify(reference.path)}); read this SKILL.md before acting` : reference.type === "note" ? `- Note: ${JSON.stringify(reference.path)}` : `- Diagnostic: ${reference.message}`).join("\n")}` : "";
+		return streamSSE(context, async (stream) => {
+			if (!config.provider.prompt) throw new Error("Provider does not support the legacy prompt API");
+			for await (const event of config.provider.prompt({
+				prompt: body.prompt + referenceContext,
+				cwd: baseDir,
+				skillsDir,
+				references,
+				model: body.model,
+				reasoningEffort: body.reasoningEffort,
+				mode: body.mode
+			})) await stream.writeSSE({
+				data: JSON.stringify(event),
+				event: event.type
+			});
+		});
+	});
+	const uiRoot = path.dirname(fileURLToPath(import.meta.resolve("@nawc/ui/package.json")));
+	const projectRequire = createRequire(path.join(projectDir, "package.json"));
+	const pluginImports = config.plugins.flatMap((plugin, index) => plugin.client ? [`import plugin${index} from ${JSON.stringify(projectRequire.resolve(plugin.client))};`] : []).join("\n");
+	const pluginArray = config.plugins.flatMap((plugin, index) => plugin.client ? [`plugin${index}`] : []).join(", ");
+	const clientSyntax = config.plugins.flatMap((plugin) => (plugin.syntax ?? []).map(({ name, aliases, highlight }) => ({
+		name,
+		aliases,
+		highlight
+	})));
+	const vitePlugins = config.plugins.flatMap((plugin) => plugin.vite ? [plugin.vite({ baseDir })] : []);
+	const vite = await createServer$1({
+		root: uiRoot,
+		appType: "spa",
+		resolve: {
+			alias: { "@nawcui": path.join(uiRoot, "src") },
+			dedupe: ["react", "react-dom"]
+		},
+		server: {
+			middlewareMode: true,
+			hmr: false,
+			ws: false,
+			watch: {
+				usePolling: true,
+				interval: 500
+			},
+			fs: { allow: [
+				projectDir,
+				baseDir,
+				uiRoot
+			] }
+		},
+		plugins: [...vitePlugins, {
+			name: "nawc-configured-plugins",
+			resolveId(id) {
+				return id === "virtual:nawc-plugins" ? "\0virtual:nawc-plugins" : void 0;
+			},
+			load(id) {
+				return id === "\0virtual:nawc-plugins" ? `${pluginImports}\nexport const syntaxes = ${JSON.stringify(clientSyntax)};\nexport default [${pluginArray}];` : void 0;
+			}
+		}]
+	});
+	const api = getRequestListener(app.fetch);
+	const server = createServer((request, response) => {
+		const previewRequest = isPreviewRequest(request.headers.origin, request.headers.host);
+		const sandboxedPreview = request.headers.origin === "null";
+		if (previewRequest && request.url?.startsWith("/api/")) {
+			response.statusCode = 403;
+			response.end("NAWC APIs are unavailable to interactive previews");
+		} else if (request.url?.startsWith("/api/")) api(request, response);
+		else {
+			if (sandboxedPreview) response.setHeader("Access-Control-Allow-Origin", "*");
+			vite.middlewares(request, response, (error) => {
+				response.statusCode = 500;
+				response.end(message(error));
+			});
+		}
+	});
+	const runSockets = new WebSocketServer({ noServer: true });
+	const startRun = async (webSocket, selection, size) => {
+		let inlineFile;
+		try {
+			const syntax = syntaxFor(config, selection.syntax);
+			if (!syntax?.run) throw new Error(`Syntax ${selection.syntax ?? ""} is not runnable`);
+			let runSelection = selection;
+			if (!selection.file) {
+				if (!syntax.extension) throw new Error(`Syntax ${syntax.name} does not support inline runs`);
+				const runsDir = await safePath(baseDir, ".nawc/runs");
+				await mkdir(runsDir, { recursive: true });
+				inlineFile = path.join(runsDir, `${randomUUID()}.${syntax.extension}`);
+				await writeFile(inlineFile, selection.source ?? "", "utf8");
+				runSelection = {
+					...selection,
+					file: path.relative(baseDir, inlineFile)
+				};
+			} else await safePath(baseDir, selection.file);
+			const run = syntax.run({
+				...runSelection,
+				cwd: baseDir
+			});
+			const [command, ...args] = run.command;
+			if (!command) throw new Error("Runnable syntax returned an empty command");
+			const child = spawn(command, args, {
+				cols: size.cols,
+				cwd: run.cwd,
+				env: {
+					...process.env,
+					TERM: "xterm-256color"
+				},
+				name: "xterm-256color",
+				rows: size.rows
+			});
+			if (run.script) child.write(run.script);
+			child.onData((data) => {
+				if (webSocket.readyState === webSocket.OPEN) webSocket.send(JSON.stringify({
+					type: "output",
+					data
+				}));
+			});
+			child.onExit(({ exitCode }) => {
+				if (inlineFile) rm(inlineFile, { force: true });
+				if (webSocket.readyState === webSocket.OPEN) {
+					webSocket.send(JSON.stringify({
+						type: "exit",
+						exitCode
+					}));
+					webSocket.close(1e3, String(exitCode));
+				}
+			});
+			return child;
+		} catch (error) {
+			if (inlineFile) await rm(inlineFile, { force: true });
+			if (webSocket.readyState === webSocket.OPEN) {
+				webSocket.send(JSON.stringify({
+					type: "error",
+					message: message(error)
+				}));
+				webSocket.close(1011, "Runnable failed");
+			}
+		}
+	};
+	server.on("upgrade", (request, socket, head) => {
+		if (new URL(request.url ?? "", "http://localhost").pathname !== "/api/run") {
+			socket.destroy();
+			return;
+		}
+		if (!isSameOrigin(request.headers.origin, request.headers.host, host !== "127.0.0.1")) {
+			socket.end("HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n");
+			return;
+		}
+		runSockets.handleUpgrade(request, socket, head, (webSocket) => {
+			runSockets.emit("connection", webSocket, request);
+		});
+	});
+	runSockets.on("connection", (webSocket) => {
+		let child;
+		let closed = false;
+		const pendingInput = [];
+		let pendingSize;
+		let starting = false;
+		webSocket.on("message", (data) => {
+			const event = parseRunClientEvent(rawDataText(data));
+			if (!event) {
+				webSocket.close(1008, "Invalid runnable message");
+				return;
+			}
+			try {
+				if (event.type === "start" && !child && !starting) {
+					starting = true;
+					startRun(webSocket, event.selection, {
+						cols: Math.max(1, Math.min(500, event.cols)),
+						rows: Math.max(1, Math.min(200, event.rows))
+					}).then((process) => {
+						if (closed) {
+							process?.kill();
+							return;
+						}
+						child = process;
+						if (pendingSize) child?.resize(pendingSize.cols, pendingSize.rows);
+						for (const input of pendingInput) child?.write(input);
+					});
+				} else if (event.type === "input") {
+					if (child) child.write(event.data);
+					else if (starting) pendingInput.push(event.data);
+				} else if (event.type === "resize") {
+					const size = {
+						cols: Math.max(1, Math.min(500, event.cols)),
+						rows: Math.max(1, Math.min(200, event.rows))
+					};
+					if (child) child.resize(size.cols, size.rows);
+					else if (starting) pendingSize = size;
+				}
+			} catch {
+				webSocket.close(1008, "Invalid runnable message");
+			}
+		});
+		webSocket.on("close", () => {
+			closed = true;
+			child?.kill();
+		});
+	});
+	const port = options.port ?? config.port ?? 6292;
+	const host = options.host ?? config.host ?? "0.0.0.0";
+	await new Promise((resolve, reject) => server.listen(port, host, resolve).once("error", reject));
+	return {
+		server,
+		vite,
+		url: `http://${host === "0.0.0.0" || host === "::" ? "localhost" : host}:${port}`,
+		async close() {
+			for (const webSocket of runSockets.clients) webSocket.close(1001, "Server shutting down");
+			await agentManager.close();
+			runSockets.close();
+			await watcher.close();
+			await vite.close();
+			await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+		}
+	};
+}
+//#endregion
+export { assertGitRepository as n, createNawcServer as t };