@openspecui/server 1.0.4 → 1.1.2

package/dist/index.mjs

@@ -1,21 +1,413 @@
 import { serve } from "@hono/node-server";
-import { Hono } from "hono";
-import { cors } from "hono/cors";
+import { CliExecutor, ConfigManager, OpenSpecAdapter, OpenSpecWatcher, OpsxKernel, PtyClientMessageSchema, ReactiveContext, getAllTools, getAvailableTools, getConfiguredTools, getDefaultCliCommandString, initWatcherPool, isWatcherPoolInitialized, sniffGlobalCli } from "@openspecui/core";
 import { fetchRequestHandler } from "@trpc/server/adapters/fetch";
 import { applyWSSHandler } from "@trpc/server/adapters/ws";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
 import { WebSocketServer } from "ws";
-import { ApplyInstructionsSchema, ArtifactInstructionsSchema, ChangeStatusSchema, CliExecutor, ConfigManager, OpenSpecAdapter, OpenSpecWatcher, OpsxKernel, PtyClientMessageSchema, ReactiveContext, SchemaDetailSchema, SchemaInfoSchema, SchemaResolutionSchema, TemplatesSchema, getAllTools, getAvailableTools, getConfiguredTools, getDefaultCliCommandString, initWatcherPool, isWatcherPoolInitialized, reactiveReadDir, reactiveReadFile, reactiveStat, sniffGlobalCli } from "@openspecui/core";
+import { createServer as createServer$1 } from "node:net";
+import * as pty from "@lydell/node-pty";
+import { EventEmitter } from "events";
+import { SearchQuerySchema } from "@openspecui/search";
 import { initTRPC } from "@trpc/server";
 import { observable } from "@trpc/server/observable";
 import { mkdir, rm, writeFile } from "node:fs/promises";
-import { dirname, join, matchesGlob, relative, resolve, sep } from "node:path";
+import { dirname, join, resolve, sep } from "node:path";
 import { z } from "zod";
-import { parse } from "yaml";
-import { EventEmitter } from "node:events";
-import { createServer as createServer$1 } from "node:net";
-import * as pty from "@lydell/node-pty";
-import { EventEmitter as EventEmitter$1 } from "events";
+import { EventEmitter as EventEmitter$1 } from "node:events";
+import { NodeWorkerSearchProvider } from "@openspecui/search/node";
+
+//#region src/port-utils.ts
+/**
+* Check if a port is available by trying to listen on it.
+* Uses default binding (both IPv4 and IPv6) to detect conflicts.
+*/
+function isPortAvailable(port) {
+	return new Promise((resolve$1) => {
+		const server = createServer$1();
+		server.once("error", () => {
+			resolve$1(false);
+		});
+		server.once("listening", () => {
+			server.close(() => resolve$1(true));
+		});
+		server.listen(port);
+	});
+}
+/**
+* Find an available port starting from the given port.
+* Will try up to maxAttempts ports sequentially.
+*
+* @param startPort - The preferred port to start checking from
+* @param maxAttempts - Maximum number of ports to try (default: 10)
+* @returns The first available port found
+* @throws Error if no available port is found in the range
+*/
+async function findAvailablePort(startPort, maxAttempts = 10) {
+	for (let i = 0; i < maxAttempts; i++) {
+		const port = startPort + i;
+		if (await isPortAvailable(port)) return port;
+	}
+	throw new Error(`No available port found in range ${startPort}-${startPort + maxAttempts - 1}`);
+}
+
+//#endregion
+//#region src/pty-manager.ts
+const DEFAULT_SCROLLBACK = 1e3;
+const DEFAULT_MAX_BUFFER_BYTES = 2 * 1024 * 1024;
+function detectPtyPlatform() {
+	if (process.platform === "win32") return "windows";
+	if (process.platform === "darwin") return "macos";
+	return "common";
+}
+function resolveDefaultShell(platform, env) {
+	if (platform === "windows") return env.ComSpec?.trim() || "cmd.exe";
+	return env.SHELL?.trim() || "/bin/sh";
+}
+function resolvePtyCommand(opts) {
+	const command = opts.command?.trim();
+	if (command) return {
+		command,
+		args: opts.args ?? []
+	};
+	return {
+		command: resolveDefaultShell(opts.platform, opts.env),
+		args: []
+	};
+}
+var PtySession = class extends EventEmitter {
+	id;
+	command;
+	args;
+	platform;
+	createdAt;
+	process;
+	titleInterval = null;
+	lastTitle = "";
+	buffer = [];
+	bufferByteLength = 0;
+	maxBufferLines;
+	maxBufferBytes;
+	isExited = false;
+	exitCode = null;
+	constructor(id, opts) {
+		super();
+		this.id = id;
+		this.createdAt = Date.now();
+		const resolvedCommand = resolvePtyCommand({
+			platform: opts.platform,
+			command: opts.command,
+			args: opts.args,
+			env: process.env
+		});
+		this.command = resolvedCommand.command;
+		this.args = resolvedCommand.args;
+		this.platform = opts.platform;
+		this.maxBufferLines = opts.scrollback ?? DEFAULT_SCROLLBACK;
+		this.maxBufferBytes = opts.maxBufferBytes ?? DEFAULT_MAX_BUFFER_BYTES;
+		this.process = pty.spawn(this.command, this.args, {
+			name: "xterm-256color",
+			cols: opts.cols ?? 80,
+			rows: opts.rows ?? 24,
+			cwd: opts.cwd,
+			env: {
+				...process.env,
+				TERM: "xterm-256color"
+			}
+		});
+		this.process.onData((data) => {
+			this.appendBuffer(data);
+			this.emit("data", data);
+		});
+		this.process.onExit(({ exitCode }) => {
+			if (this.titleInterval) {
+				clearInterval(this.titleInterval);
+				this.titleInterval = null;
+			}
+			this.isExited = true;
+			this.exitCode = exitCode;
+			this.emit("exit", exitCode);
+		});
+		this.titleInterval = setInterval(() => {
+			try {
+				const title = this.process.process;
+				if (title && title !== this.lastTitle) {
+					this.lastTitle = title;
+					this.emit("title", title);
+				}
+			} catch {}
+		}, 1e3);
+	}
+	get title() {
+		return this.lastTitle;
+	}
+	appendBuffer(data) {
+		let chunk = data;
+		if (chunk.length > this.maxBufferBytes) chunk = chunk.slice(-this.maxBufferBytes);
+		this.buffer.push(chunk);
+		this.bufferByteLength += chunk.length;
+		while (this.bufferByteLength > this.maxBufferBytes && this.buffer.length > 0) {
+			const removed = this.buffer.shift();
+			this.bufferByteLength -= removed.length;
+		}
+		while (this.buffer.length > this.maxBufferLines) {
+			const removed = this.buffer.shift();
+			this.bufferByteLength -= removed.length;
+		}
+	}
+	getBuffer() {
+		return this.buffer.join("");
+	}
+	write(data) {
+		if (!this.isExited) this.process.write(data);
+	}
+	resize(cols, rows) {
+		if (!this.isExited) this.process.resize(cols, rows);
+	}
+	close() {
+		if (this.titleInterval) {
+			clearInterval(this.titleInterval);
+			this.titleInterval = null;
+		}
+		try {
+			this.process.kill();
+		} catch {}
+		this.removeAllListeners();
+	}
+	toInfo() {
+		return {
+			id: this.id,
+			title: this.lastTitle,
+			command: this.command,
+			args: this.args,
+			platform: this.platform,
+			isExited: this.isExited,
+			exitCode: this.exitCode,
+			createdAt: this.createdAt
+		};
+	}
+};
+var PtyManager = class {
+	sessions = /* @__PURE__ */ new Map();
+	idCounter = 0;
+	platform;
+	constructor(defaultCwd) {
+		this.defaultCwd = defaultCwd;
+		this.platform = detectPtyPlatform();
+	}
+	create(opts) {
+		const id = `pty-${++this.idCounter}`;
+		const session = new PtySession(id, {
+			cols: opts.cols,
+			rows: opts.rows,
+			command: opts.command,
+			args: opts.args,
+			cwd: this.defaultCwd,
+			scrollback: opts.scrollback,
+			maxBufferBytes: opts.maxBufferBytes,
+			platform: this.platform
+		});
+		this.sessions.set(id, session);
+		return session;
+	}
+	get(id) {
+		return this.sessions.get(id);
+	}
+	list() {
+		const result = [];
+		for (const session of this.sessions.values()) result.push(session.toInfo());
+		return result;
+	}
+	write(id, data) {
+		this.sessions.get(id)?.write(data);
+	}
+	resize(id, cols, rows) {
+		this.sessions.get(id)?.resize(cols, rows);
+	}
+	close(id) {
+		const session = this.sessions.get(id);
+		if (session) {
+			session.close();
+			this.sessions.delete(id);
+		}
+	}
+	closeAll() {
+		for (const session of this.sessions.values()) session.close();
+		this.sessions.clear();
+	}
+};
+
+//#endregion
+//#region src/pty-websocket.ts
+function createPtyWebSocketHandler(ptyManager) {
+	return (ws) => {
+		const cleanups = /* @__PURE__ */ new Map();
+		const send = (msg) => {
+			if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(msg));
+		};
+		const sendError = (code, message, opts) => {
+			send({
+				type: "error",
+				code,
+				message,
+				sessionId: opts?.sessionId
+			});
+		};
+		const attachToSession = (session, opts) => {
+			const sessionId = session.id;
+			cleanups.get(sessionId)?.();
+			if (opts?.cols && opts?.rows && !session.isExited) session.resize(opts.cols, opts.rows);
+			const onData = (data) => {
+				send({
+					type: "output",
+					sessionId,
+					data
+				});
+			};
+			const onExit = (exitCode) => {
+				send({
+					type: "exit",
+					sessionId,
+					exitCode
+				});
+			};
+			const onTitle = (title) => {
+				send({
+					type: "title",
+					sessionId,
+					title
+				});
+			};
+			session.on("data", onData);
+			session.on("exit", onExit);
+			session.on("title", onTitle);
+			cleanups.set(sessionId, () => {
+				session.removeListener("data", onData);
+				session.removeListener("exit", onExit);
+				session.removeListener("title", onTitle);
+				cleanups.delete(sessionId);
+			});
+		};
+		ws.on("message", (raw) => {
+			let parsed;
+			try {
+				parsed = JSON.parse(String(raw));
+			} catch {
+				sendError("INVALID_JSON", "Invalid JSON payload");
+				return;
+			}
+			const parsedMessage = PtyClientMessageSchema.safeParse(parsed);
+			if (!parsedMessage.success) {
+				const firstIssue = parsedMessage.error.issues[0]?.message;
+				sendError("INVALID_MESSAGE", firstIssue ?? "Invalid PTY message");
+				return;
+			}
+			const msg = parsedMessage.data;
+			switch (msg.type) {
+				case "create":
+					try {
+						const session = ptyManager.create({
+							cols: msg.cols,
+							rows: msg.rows,
+							command: msg.command,
+							args: msg.args
+						});
+						send({
+							type: "created",
+							requestId: msg.requestId,
+							sessionId: session.id,
+							platform: session.platform
+						});
+						attachToSession(session);
+					} catch (err) {
+						sendError("PTY_CREATE_FAILED", err instanceof Error ? err.message : String(err), { sessionId: msg.requestId });
+					}
+					break;
+				case "attach": {
+					const session = ptyManager.get(msg.sessionId);
+					if (!session) {
+						sendError("SESSION_NOT_FOUND", `Session not found: ${msg.sessionId}`, { sessionId: msg.sessionId });
+						send({
+							type: "exit",
+							sessionId: msg.sessionId,
+							exitCode: -1
+						});
+						break;
+					}
+					attachToSession(session, {
+						cols: msg.cols,
+						rows: msg.rows
+					});
+					const buffer = session.getBuffer();
+					if (buffer) send({
+						type: "buffer",
+						sessionId: session.id,
+						data: buffer
+					});
+					if (session.title) send({
+						type: "title",
+						sessionId: session.id,
+						title: session.title
+					});
+					if (session.isExited) send({
+						type: "exit",
+						sessionId: session.id,
+						exitCode: session.exitCode ?? -1
+					});
+					break;
+				}
+				case "list":
+					send({
+						type: "list",
+						sessions: ptyManager.list().map((s) => ({
+							id: s.id,
+							title: s.title,
+							command: s.command,
+							args: s.args,
+							platform: s.platform,
+							isExited: s.isExited,
+							exitCode: s.exitCode
+						}))
+					});
+					break;
+				case "input": {
+					const session = ptyManager.get(msg.sessionId);
+					if (!session) {
+						sendError("SESSION_NOT_FOUND", `Session not found: ${msg.sessionId}`, { sessionId: msg.sessionId });
+						break;
+					}
+					session.write(msg.data);
+					break;
+				}
+				case "resize": {
+					const session = ptyManager.get(msg.sessionId);
+					if (!session) {
+						sendError("SESSION_NOT_FOUND", `Session not found: ${msg.sessionId}`, { sessionId: msg.sessionId });
+						break;
+					}
+					session.resize(msg.cols, msg.rows);
+					break;
+				}
+				case "close": {
+					const session = ptyManager.get(msg.sessionId);
+					if (!session) {
+						sendError("SESSION_NOT_FOUND", `Session not found: ${msg.sessionId}`, { sessionId: msg.sessionId });
+						break;
+					}
+					cleanups.get(msg.sessionId)?.();
+					ptyManager.close(session.id);
+					break;
+				}
+			}
+		});
+		ws.on("close", () => {
+			for (const cleanup of cleanups.values()) cleanup();
+			cleanups.clear();
+		});
+	};
+}
 
+//#endregion
 //#region src/cli-stream-observable.ts
 /**
 * 创建安全的 CLI 流式 observable
@@ -72,53 +464,6 @@ function createCliStreamObservable(startStream) {
 	});
 }
 
-//#endregion
-//#region src/opsx-schema.ts
-const SchemaYamlArtifactSchema = z.object({
-	id: z.string(),
-	generates: z.string(),
-	description: z.string().optional(),
-	template: z.string().optional(),
-	instruction: z.string().optional(),
-	requires: z.array(z.string()).optional()
-});
-const SchemaYamlSchema = z.object({
-	name: z.string(),
-	version: z.union([z.string(), z.number()]).optional(),
-	description: z.string().optional(),
-	artifacts: z.array(SchemaYamlArtifactSchema),
-	apply: z.object({
-		requires: z.array(z.string()).optional(),
-		tracks: z.string().optional(),
-		instruction: z.string().optional()
-	}).optional()
-});
-function parseSchemaYaml(content) {
-	const raw = parse(content);
-	const parsed = SchemaYamlSchema.safeParse(raw);
-	if (!parsed.success) throw new Error(`Invalid schema.yaml: ${parsed.error.message}`);
-	const { artifacts, apply, name, description, version } = parsed.data;
-	const detail = {
-		name,
-		description,
-		version,
-		artifacts: artifacts.map((artifact) => ({
-			id: artifact.id,
-			outputPath: artifact.generates,
-			description: artifact.description,
-			template: artifact.template,
-			instruction: artifact.instruction,
-			requires: artifact.requires ?? []
-		})),
-		applyRequires: apply?.requires ?? [],
-		applyTracks: apply?.tracks,
-		applyInstruction: apply?.instruction
-	};
-	const validated = SchemaDetailSchema.safeParse(detail);
-	if (!validated.success) throw new Error(`Invalid schema detail: ${validated.error.message}`);
-	return validated.data;
-}
-
 //#endregion
 //#region src/reactive-kv.ts
 /**
@@ -131,7 +476,7 @@ function parseSchemaYaml(content) {
 */
 var ReactiveKV = class {
 	store = /* @__PURE__ */ new Map();
-	emitter = new EventEmitter();
+	emitter = new EventEmitter$1();
 	constructor() {
 		this.emitter.setMaxListeners(200);
 	}
@@ -246,20 +591,6 @@ function requireChangeId(changeId) {
 function ensureEditableSource(source, label) {
 	if (source === "package") throw new Error(`${label} is read-only (package source)`);
 }
-function parseCliJson(raw, schema, label) {
-	const trimmed = raw.trim();
-	if (!trimmed) throw new Error(`${label} returned empty output`);
-	let parsed;
-	try {
-		parsed = JSON.parse(trimmed);
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		throw new Error(`${label} returned invalid JSON: ${message}`);
-	}
-	const result = schema.safeParse(parsed);
-	if (!result.success) throw new Error(`${label} returned unexpected JSON: ${result.error.message}`);
-	return result.data;
-}
 function resolveEntryPath(root, entryPath) {
 	const normalizedRoot = resolve(root);
 	const resolvedPath = resolve(normalizedRoot, entryPath);
@@ -267,153 +598,62 @@ function resolveEntryPath(root, entryPath) {
 	if (resolvedPath !== normalizedRoot && !resolvedPath.startsWith(rootPrefix)) throw new Error("Invalid path: outside schema root");
 	return resolvedPath;
 }
-function toRelativePath(root, absolutePath) {
-	return relative(root, absolutePath).split(sep).join("/");
-}
-async function readEntriesUnderRoot(root) {
-	if (!(await reactiveStat(root))?.isDirectory) return [];
-	const collectEntries = async (dir) => {
-		const names = await reactiveReadDir(dir, { includeHidden: false });
-		const entries = [];
-		for (const name of names) {
-			const fullPath = join(dir, name);
-			const statInfo = await reactiveStat(fullPath);
-			if (!statInfo) continue;
-			const relativePath = toRelativePath(root, fullPath);
-			if (statInfo.isDirectory) {
-				entries.push({
-					path: relativePath,
-					type: "directory"
-				});
-				entries.push(...await collectEntries(fullPath));
-			} else {
-				const content = await reactiveReadFile(fullPath);
-				const size = content ? Buffer.byteLength(content, "utf-8") : void 0;
-				entries.push({
-					path: relativePath,
-					type: "file",
-					content: content ?? void 0,
-					size
-				});
-			}
-		}
-		return entries;
-	};
-	return collectEntries(root);
-}
-async function touchOpsxProjectDeps(projectDir) {
-	const openspecDir = join(projectDir, "openspec");
-	await reactiveReadFile(join(openspecDir, "config.yaml"));
-	const schemaRoot = join(openspecDir, "schemas");
-	const schemaDirs = await reactiveReadDir(schemaRoot, {
-		directoriesOnly: true,
-		includeHidden: true
-	});
-	await Promise.all(schemaDirs.map((name) => reactiveReadFile(join(schemaRoot, name, "schema.yaml"))));
-	await reactiveReadDir(join(openspecDir, "changes"), {
-		directoriesOnly: true,
-		includeHidden: true,
-		exclude: ["archive"]
-	});
-}
-async function touchOpsxChangeDeps(projectDir, changeId) {
-	const changeDir = join(projectDir, "openspec", "changes", changeId);
-	await reactiveReadDir(changeDir, { includeHidden: true });
-	await reactiveReadFile(join(changeDir, ".openspec.yaml"));
-}
-async function readGlobArtifactFiles(projectDir, changeId, outputPath) {
-	return (await readEntriesUnderRoot(join(projectDir, "openspec", "changes", changeId))).filter((entry) => entry.type === "file" && matchesGlob(entry.path, outputPath)).map((entry) => ({
-		path: entry.path,
-		type: "file",
-		content: entry.content ?? ""
-	}));
-}
 async function fetchOpsxStatus(ctx, input) {
 	const changeId = requireChangeId(input.change);
-	await touchOpsxProjectDeps(ctx.projectDir);
-	await touchOpsxChangeDeps(ctx.projectDir, changeId);
-	const args = [
-		"status",
-		"--json",
-		"--change",
-		changeId
-	];
-	if (input.schema) args.push("--schema", input.schema);
-	const result = await ctx.cliExecutor.execute(args);
-	if (!result.success) throw new Error(result.stderr || `openspec status failed (exit ${result.exitCode ?? "null"})`);
-	const status = parseCliJson(result.stdout, ChangeStatusSchema, "openspec status");
-	const changeRelDir = `openspec/changes/${changeId}`;
-	for (const artifact of status.artifacts) artifact.relativePath = `${changeRelDir}/${artifact.outputPath}`;
-	return status;
+	await ctx.kernel.waitForWarmup();
+	await ctx.kernel.ensureStatus(changeId, input.schema);
+	return ctx.kernel.getStatus(changeId, input.schema);
 }
 async function fetchOpsxStatusList(ctx) {
-	const changeIds = await reactiveReadDir(join(ctx.projectDir, "openspec", "changes"), {
-		directoriesOnly: true,
-		includeHidden: false,
-		exclude: ["archive"]
-	});
-	return await Promise.all(changeIds.map((changeId) => fetchOpsxStatus(ctx, { change: changeId })));
+	await ctx.kernel.waitForWarmup();
+	await ctx.kernel.ensureStatusList();
+	return ctx.kernel.getStatusList();
 }
 async function fetchOpsxInstructions(ctx, input) {
 	const changeId = requireChangeId(input.change);
-	await touchOpsxProjectDeps(ctx.projectDir);
-	await touchOpsxChangeDeps(ctx.projectDir, changeId);
-	const args = [
-		"instructions",
-		input.artifact,
-		"--json",
-		"--change",
-		changeId
-	];
-	if (input.schema) args.push("--schema", input.schema);
-	const result = await ctx.cliExecutor.execute(args);
-	if (!result.success) throw new Error(result.stderr || `openspec instructions failed (exit ${result.exitCode ?? "null"})`);
-	return parseCliJson(result.stdout, ArtifactInstructionsSchema, "openspec instructions");
+	await ctx.kernel.waitForWarmup();
+	await ctx.kernel.ensureInstructions(changeId, input.artifact, input.schema);
+	return ctx.kernel.getInstructions(changeId, input.artifact, input.schema);
 }
 async function fetchOpsxApplyInstructions(ctx, input) {
 	const changeId = requireChangeId(input.change);
-	await touchOpsxProjectDeps(ctx.projectDir);
-	await touchOpsxChangeDeps(ctx.projectDir, changeId);
-	const args = [
-		"instructions",
-		"apply",
-		"--json",
-		"--change",
-		changeId
-	];
-	if (input.schema) args.push("--schema", input.schema);
-	const result = await ctx.cliExecutor.execute(args);
-	if (!result.success) throw new Error(result.stderr || `openspec instructions apply failed (exit ${result.exitCode ?? "null"})`);
-	return parseCliJson(result.stdout, ApplyInstructionsSchema, "openspec instructions apply");
+	await ctx.kernel.waitForWarmup();
+	await ctx.kernel.ensureApplyInstructions(changeId, input.schema);
+	return ctx.kernel.getApplyInstructions(changeId, input.schema);
 }
-async function fetchOpsxSchemas(ctx) {
-	await touchOpsxProjectDeps(ctx.projectDir);
-	const result = await ctx.cliExecutor.schemas();
-	if (!result.success) throw new Error(result.stderr || `openspec schemas failed (exit ${result.exitCode ?? "null"})`);
-	return parseCliJson(result.stdout, z.array(SchemaInfoSchema), "openspec schemas");
+async function fetchOpsxConfigBundle(ctx) {
+	await ctx.kernel.ensureSchemas();
+	const schemas = ctx.kernel.getSchemas();
+	for (const schema of schemas) {
+		ctx.kernel.ensureSchemaDetail(schema.name).catch(() => {});
+		ctx.kernel.ensureSchemaResolution(schema.name).catch(() => {});
+	}
+	const schemaDetails = {};
+	const schemaResolutions = {};
+	for (const schema of schemas) {
+		schemaDetails[schema.name] = ctx.kernel.peekSchemaDetail(schema.name);
+		schemaResolutions[schema.name] = ctx.kernel.peekSchemaResolution(schema.name);
+	}
+	return {
+		schemas,
+		schemaDetails,
+		schemaResolutions
+	};
 }
 async function fetchOpsxSchemaResolution(ctx, name) {
-	await touchOpsxProjectDeps(ctx.projectDir);
-	const result = await ctx.cliExecutor.schemaWhich(name);
-	if (!result.success) throw new Error(result.stderr || `openspec schema which failed (exit ${result.exitCode ?? "null"})`);
-	return parseCliJson(result.stdout, SchemaResolutionSchema, "openspec schema which");
+	await ctx.kernel.waitForWarmup();
+	await ctx.kernel.ensureSchemaResolution(name);
+	return ctx.kernel.getSchemaResolution(name);
 }
 async function fetchOpsxTemplates(ctx, schema) {
-	await touchOpsxProjectDeps(ctx.projectDir);
-	const result = await ctx.cliExecutor.templates(schema);
-	if (!result.success) throw new Error(result.stderr || `openspec templates failed (exit ${result.exitCode ?? "null"})`);
-	return parseCliJson(result.stdout, TemplatesSchema, "openspec templates");
+	await ctx.kernel.waitForWarmup();
+	await ctx.kernel.ensureTemplates(schema);
+	return ctx.kernel.getTemplates(schema);
 }
 async function fetchOpsxTemplateContents(ctx, schema) {
-	const templates = await fetchOpsxTemplates(ctx, schema);
-	const entries = await Promise.all(Object.entries(templates).map(async ([artifactId, info]) => {
-		return [artifactId, {
-			content: await reactiveReadFile(info.path),
-			path: info.path,
-			source: info.source
-		}];
-	}));
-	return Object.fromEntries(entries);
+	await ctx.kernel.waitForWarmup();
+	await ctx.kernel.ensureTemplateContents(schema);
+	return ctx.kernel.getTemplateContents(schema);
 }
 /**
 * Spec router - spec CRUD operations
@@ -803,11 +1043,11 @@ const opsxRouter = router({
 	})).subscription(({ ctx, input }) => {
 		return createReactiveSubscription(() => fetchOpsxApplyInstructions(ctx, input));
 	}),
-	schemas: publicProcedure.query(async ({ ctx }) => {
-		return fetchOpsxSchemas(ctx);
+	configBundle: publicProcedure.query(async ({ ctx }) => {
+		return fetchOpsxConfigBundle(ctx);
 	}),
-	subscribeSchemas: publicProcedure.subscription(({ ctx }) => {
-		return createReactiveSubscription(() => fetchOpsxSchemas(ctx));
+	subscribeConfigBundle: publicProcedure.subscription(({ ctx }) => {
+		return createReactiveSubscription(() => fetchOpsxConfigBundle(ctx));
 	}),
 	templates: publicProcedure.input(z.object({ schema: z.string().optional() }).optional()).query(async ({ ctx, input }) => {
 		return fetchOpsxTemplates(ctx, input?.schema);
@@ -821,53 +1061,34 @@ const opsxRouter = router({
 	subscribeTemplateContents: publicProcedure.input(z.object({ schema: z.string().optional() }).optional()).subscription(({ ctx, input }) => {
 		return createReactiveSubscription(() => fetchOpsxTemplateContents(ctx, input?.schema));
 	}),
-	schemaResolution: publicProcedure.input(z.object({ name: z.string() })).query(async ({ ctx, input }) => {
-		return fetchOpsxSchemaResolution(ctx, input.name);
-	}),
-	subscribeSchemaResolution: publicProcedure.input(z.object({ name: z.string() })).subscription(({ ctx, input }) => {
-		return createReactiveSubscription(() => fetchOpsxSchemaResolution(ctx, input.name));
-	}),
-	schemaDetail: publicProcedure.input(z.object({ name: z.string() })).query(async ({ ctx, input }) => {
-		await touchOpsxProjectDeps(ctx.projectDir);
-		const schemaPath = join((await fetchOpsxSchemaResolution(ctx, input.name)).path, "schema.yaml");
-		const content = await reactiveReadFile(schemaPath);
-		if (!content) throw new Error(`schema.yaml not found at ${schemaPath}`);
-		return parseSchemaYaml(content);
-	}),
-	subscribeSchemaDetail: publicProcedure.input(z.object({ name: z.string() })).subscription(({ ctx, input }) => {
-		return createReactiveSubscription(async () => {
-			await touchOpsxProjectDeps(ctx.projectDir);
-			const schemaPath = join((await fetchOpsxSchemaResolution(ctx, input.name)).path, "schema.yaml");
-			const content = await reactiveReadFile(schemaPath);
-			if (!content) throw new Error(`schema.yaml not found at ${schemaPath}`);
-			return parseSchemaYaml(content);
-		});
-	}),
 	schemaFiles: publicProcedure.input(z.object({ name: z.string() })).query(async ({ ctx, input }) => {
-		await touchOpsxProjectDeps(ctx.projectDir);
-		return readEntriesUnderRoot((await fetchOpsxSchemaResolution(ctx, input.name)).path);
+		await ctx.kernel.waitForWarmup();
+		await ctx.kernel.ensureSchemaFiles(input.name);
+		return ctx.kernel.getSchemaFiles(input.name);
 	}),
 	subscribeSchemaFiles: publicProcedure.input(z.object({ name: z.string() })).subscription(({ ctx, input }) => {
 		return createReactiveSubscription(async () => {
-			await touchOpsxProjectDeps(ctx.projectDir);
-			return readEntriesUnderRoot((await fetchOpsxSchemaResolution(ctx, input.name)).path);
+			await ctx.kernel.waitForWarmup();
+			await ctx.kernel.ensureSchemaFiles(input.name);
+			return ctx.kernel.getSchemaFiles(input.name);
 		});
 	}),
 	schemaYaml: publicProcedure.input(z.object({ name: z.string() })).query(async ({ ctx, input }) => {
-		await touchOpsxProjectDeps(ctx.projectDir);
-		return reactiveReadFile(join((await fetchOpsxSchemaResolution(ctx, input.name)).path, "schema.yaml"));
+		await ctx.kernel.waitForWarmup();
+		await ctx.kernel.ensureSchemaYaml(input.name);
+		return ctx.kernel.getSchemaYaml(input.name);
 	}),
 	subscribeSchemaYaml: publicProcedure.input(z.object({ name: z.string() })).subscription(({ ctx, input }) => {
 		return createReactiveSubscription(async () => {
-			await touchOpsxProjectDeps(ctx.projectDir);
-			return reactiveReadFile(join((await fetchOpsxSchemaResolution(ctx, input.name)).path, "schema.yaml"));
+			await ctx.kernel.waitForWarmup();
+			await ctx.kernel.ensureSchemaYaml(input.name);
+			return ctx.kernel.getSchemaYaml(input.name);
 		});
 	}),
 	writeSchemaYaml: publicProcedure.input(z.object({
 		name: z.string(),
 		content: z.string()
 	})).mutation(async ({ ctx, input }) => {
-		await touchOpsxProjectDeps(ctx.projectDir);
 		const resolution = await fetchOpsxSchemaResolution(ctx, input.name);
 		ensureEditableSource(resolution.source, "schema.yaml");
 		const schemaPath = join(resolution.path, "schema.yaml");
@@ -880,7 +1101,6 @@ const opsxRouter = router({
 		path: z.string(),
 		content: z.string()
 	})).mutation(async ({ ctx, input }) => {
-		await touchOpsxProjectDeps(ctx.projectDir);
 		const resolution = await fetchOpsxSchemaResolution(ctx, input.schema);
 		ensureEditableSource(resolution.source, "schema file");
 		if (!input.path.trim()) throw new Error("path is required");
@@ -894,7 +1114,6 @@ const opsxRouter = router({
 		path: z.string(),
 		content: z.string().optional()
 	})).mutation(async ({ ctx, input }) => {
-		await touchOpsxProjectDeps(ctx.projectDir);
 		const resolution = await fetchOpsxSchemaResolution(ctx, input.schema);
 		ensureEditableSource(resolution.source, "schema file");
 		if (!input.path.trim()) throw new Error("path is required");
@@ -907,7 +1126,6 @@ const opsxRouter = router({
 		schema: z.string(),
 		path: z.string()
 	})).mutation(async ({ ctx, input }) => {
-		await touchOpsxProjectDeps(ctx.projectDir);
 		const resolution = await fetchOpsxSchemaResolution(ctx, input.schema);
 		ensureEditableSource(resolution.source, "schema directory");
 		if (!input.path.trim()) throw new Error("path is required");
@@ -918,7 +1136,6 @@ const opsxRouter = router({
 		schema: z.string(),
 		path: z.string()
 	})).mutation(async ({ ctx, input }) => {
-		await touchOpsxProjectDeps(ctx.projectDir);
 		const resolution = await fetchOpsxSchemaResolution(ctx, input.schema);
 		ensureEditableSource(resolution.source, "schema entry");
 		if (!input.path.trim()) throw new Error("path is required");
@@ -934,26 +1151,18 @@ const opsxRouter = router({
 		schema: z.string(),
 		artifactId: z.string()
 	})).query(async ({ ctx, input }) => {
-		const info = (await fetchOpsxTemplates(ctx, input.schema))[input.artifactId];
+		const info = (await fetchOpsxTemplateContents(ctx, input.schema))[input.artifactId];
 		if (!info) throw new Error(`Template not found for ${input.schema}:${input.artifactId}`);
-		return {
-			content: await reactiveReadFile(info.path),
-			path: info.path,
-			source: info.source
-		};
+		return info;
 	}),
 	subscribeTemplateContent: publicProcedure.input(z.object({
 		schema: z.string(),
 		artifactId: z.string()
 	})).subscription(({ ctx, input }) => {
 		return createReactiveSubscription(async () => {
-			const info = (await fetchOpsxTemplates(ctx, input.schema))[input.artifactId];
+			const info = (await fetchOpsxTemplateContents(ctx, input.schema))[input.artifactId];
 			if (!info) throw new Error(`Template not found for ${input.schema}:${input.artifactId}`);
-			return {
-				content: await reactiveReadFile(info.path),
-				path: info.path,
-				source: info.source
-			};
+			return info;
 		});
 	}),
 	writeTemplateContent: publicProcedure.input(z.object({
@@ -969,7 +1178,6 @@ const opsxRouter = router({
 		return { success: true };
 	}),
 	deleteSchema: publicProcedure.input(z.object({ name: z.string() })).mutation(async ({ ctx, input }) => {
-		await touchOpsxProjectDeps(ctx.projectDir);
 		const resolution = await fetchOpsxSchemaResolution(ctx, input.name);
 		ensureEditableSource(resolution.source, "schema");
 		await rm(resolution.path, {
@@ -979,11 +1187,15 @@ const opsxRouter = router({
 		return { success: true };
 	}),
 	projectConfig: publicProcedure.query(async ({ ctx }) => {
-		return reactiveReadFile(join(ctx.projectDir, "openspec", "config.yaml"));
+		await ctx.kernel.waitForWarmup();
+		await ctx.kernel.ensureProjectConfig();
+		return ctx.kernel.getProjectConfig();
 	}),
 	subscribeProjectConfig: publicProcedure.subscription(({ ctx }) => {
 		return createReactiveSubscription(async () => {
-			return reactiveReadFile(join(ctx.projectDir, "openspec", "config.yaml"));
+			await ctx.kernel.waitForWarmup();
+			await ctx.kernel.ensureProjectConfig();
+			return ctx.kernel.getProjectConfig();
 		});
 	}),
 	writeProjectConfig: publicProcedure.input(z.object({ content: z.string() })).mutation(async ({ ctx, input }) => {
@@ -993,55 +1205,63 @@ const opsxRouter = router({
 		return { success: true };
 	}),
 	listChanges: publicProcedure.query(async ({ ctx }) => {
-		return reactiveReadDir(join(ctx.projectDir, "openspec", "changes"), {
-			directoriesOnly: true,
-			exclude: ["archive"],
-			includeHidden: false
-		});
+		await ctx.kernel.waitForWarmup();
+		await ctx.kernel.ensureChangeIds();
+		return ctx.kernel.getChangeIds();
 	}),
 	subscribeChanges: publicProcedure.subscription(({ ctx }) => {
 		return createReactiveSubscription(async () => {
-			return reactiveReadDir(join(ctx.projectDir, "openspec", "changes"), {
-				directoriesOnly: true,
-				exclude: ["archive"],
-				includeHidden: false
-			});
+			await ctx.kernel.waitForWarmup();
+			await ctx.kernel.ensureChangeIds();
+			return ctx.kernel.getChangeIds();
 		});
 	}),
 	changeMetadata: publicProcedure.input(z.object({ changeId: z.string() })).query(async ({ ctx, input }) => {
-		return reactiveReadFile(join(ctx.projectDir, "openspec", "changes", input.changeId, ".openspec.yaml"));
+		await ctx.kernel.waitForWarmup();
+		await ctx.kernel.ensureChangeMetadata(input.changeId);
+		return ctx.kernel.getChangeMetadata(input.changeId);
 	}),
 	subscribeChangeMetadata: publicProcedure.input(z.object({ changeId: z.string() })).subscription(({ ctx, input }) => {
 		return createReactiveSubscription(async () => {
-			return reactiveReadFile(join(ctx.projectDir, "openspec", "changes", input.changeId, ".openspec.yaml"));
+			await ctx.kernel.waitForWarmup();
+			await ctx.kernel.ensureChangeMetadata(input.changeId);
+			return ctx.kernel.getChangeMetadata(input.changeId);
 		});
 	}),
 	readArtifactOutput: publicProcedure.input(z.object({
 		changeId: z.string(),
 		outputPath: z.string()
 	})).query(async ({ ctx, input }) => {
-		return reactiveReadFile(join(ctx.projectDir, "openspec", "changes", input.changeId, input.outputPath));
+		await ctx.kernel.waitForWarmup();
+		await ctx.kernel.ensureArtifactOutput(input.changeId, input.outputPath);
+		return ctx.kernel.getArtifactOutput(input.changeId, input.outputPath);
 	}),
 	subscribeArtifactOutput: publicProcedure.input(z.object({
 		changeId: z.string(),
 		outputPath: z.string()
 	})).subscription(({ ctx, input }) => {
 		return createReactiveSubscription(async () => {
-			return reactiveReadFile(join(ctx.projectDir, "openspec", "changes", input.changeId, input.outputPath));
+			await ctx.kernel.waitForWarmup();
+			await ctx.kernel.ensureArtifactOutput(input.changeId, input.outputPath);
+			return ctx.kernel.getArtifactOutput(input.changeId, input.outputPath);
 		});
 	}),
 	readGlobArtifactFiles: publicProcedure.input(z.object({
 		changeId: z.string(),
 		outputPath: z.string()
 	})).query(async ({ ctx, input }) => {
-		return readGlobArtifactFiles(ctx.projectDir, input.changeId, input.outputPath);
+		await ctx.kernel.waitForWarmup();
+		await ctx.kernel.ensureGlobArtifactFiles(input.changeId, input.outputPath);
+		return ctx.kernel.getGlobArtifactFiles(input.changeId, input.outputPath);
 	}),
 	subscribeGlobArtifactFiles: publicProcedure.input(z.object({
 		changeId: z.string(),
 		outputPath: z.string()
 	})).subscription(({ ctx, input }) => {
 		return createReactiveSubscription(async () => {
-			return readGlobArtifactFiles(ctx.projectDir, input.changeId, input.outputPath);
+			await ctx.kernel.waitForWarmup();
+			await ctx.kernel.ensureGlobArtifactFiles(input.changeId, input.outputPath);
+			return ctx.kernel.getGlobArtifactFiles(input.changeId, input.outputPath);
 		});
 	}),
 	writeArtifactOutput: publicProcedure.input(z.object({
@@ -1086,6 +1306,17 @@ const kvRouter = router({
 	})
 });
 /**
+* Search router - unified fulltext search over specs/changes/archives
+*/
+const searchRouter = router({
+	query: publicProcedure.input(SearchQuerySchema).query(async ({ ctx, input }) => {
+		return ctx.searchService.query(input);
+	}),
+	subscribe: publicProcedure.input(SearchQuerySchema).subscription(({ ctx, input }) => {
+		return createReactiveSubscriptionWithInput((queryInput) => ctx.searchService.queryReactive(queryInput))(input);
+	})
+});
+/**
 * Main app router
 */
 const appRouter = router({
@@ -1095,402 +1326,145 @@ const appRouter = router({
 	init: initRouter,
 	realtime: realtimeRouter,
 	config: configRouter,
-	cli: cliRouter,
-	opsx: opsxRouter,
-	kv: kvRouter
-});
-
-//#endregion
-//#region src/port-utils.ts
-/**
-* Check if a port is available by trying to listen on it.
-* Uses default binding (both IPv4 and IPv6) to detect conflicts.
-*/
-function isPortAvailable(port) {
-	return new Promise((resolve$1) => {
-		const server = createServer$1();
-		server.once("error", () => {
-			resolve$1(false);
-		});
-		server.once("listening", () => {
-			server.close(() => resolve$1(true));
-		});
-		server.listen(port);
-	});
-}
-/**
-* Find an available port starting from the given port.
-* Will try up to maxAttempts ports sequentially.
-*
-* @param startPort - The preferred port to start checking from
-* @param maxAttempts - Maximum number of ports to try (default: 10)
-* @returns The first available port found
-* @throws Error if no available port is found in the range
-*/
-async function findAvailablePort(startPort, maxAttempts = 10) {
-	for (let i = 0; i < maxAttempts; i++) {
-		const port = startPort + i;
-		if (await isPortAvailable(port)) return port;
-	}
-	throw new Error(`No available port found in range ${startPort}-${startPort + maxAttempts - 1}`);
-}
-
-//#endregion
-//#region src/pty-manager.ts
-const DEFAULT_SCROLLBACK = 1e3;
-const DEFAULT_MAX_BUFFER_BYTES = 2 * 1024 * 1024;
-function detectPtyPlatform() {
-	if (process.platform === "win32") return "windows";
-	if (process.platform === "darwin") return "macos";
-	return "common";
-}
-function resolveDefaultShell(platform, env) {
-	if (platform === "windows") return env.ComSpec?.trim() || "cmd.exe";
-	return env.SHELL?.trim() || "/bin/sh";
-}
-function resolvePtyCommand(opts) {
-	const command = opts.command?.trim();
-	if (command) return {
-		command,
-		args: opts.args ?? []
-	};
-	return {
-		command: resolveDefaultShell(opts.platform, opts.env),
-		args: []
-	};
-}
-var PtySession = class extends EventEmitter$1 {
-	id;
-	command;
-	args;
-	platform;
-	createdAt;
-	process;
-	titleInterval = null;
-	lastTitle = "";
-	buffer = [];
-	bufferByteLength = 0;
-	maxBufferLines;
-	maxBufferBytes;
-	isExited = false;
-	exitCode = null;
-	constructor(id, opts) {
-		super();
-		this.id = id;
-		this.createdAt = Date.now();
-		const resolvedCommand = resolvePtyCommand({
-			platform: opts.platform,
-			command: opts.command,
-			args: opts.args,
-			env: process.env
-		});
-		this.command = resolvedCommand.command;
-		this.args = resolvedCommand.args;
-		this.platform = opts.platform;
-		this.maxBufferLines = opts.scrollback ?? DEFAULT_SCROLLBACK;
-		this.maxBufferBytes = opts.maxBufferBytes ?? DEFAULT_MAX_BUFFER_BYTES;
-		this.process = pty.spawn(this.command, this.args, {
-			name: "xterm-256color",
-			cols: opts.cols ?? 80,
-			rows: opts.rows ?? 24,
-			cwd: opts.cwd,
-			env: {
-				...process.env,
-				TERM: "xterm-256color"
-			}
-		});
-		this.process.onData((data) => {
-			this.appendBuffer(data);
-			this.emit("data", data);
-		});
-		this.process.onExit(({ exitCode }) => {
-			if (this.titleInterval) {
-				clearInterval(this.titleInterval);
-				this.titleInterval = null;
-			}
-			this.isExited = true;
-			this.exitCode = exitCode;
-			this.emit("exit", exitCode);
-		});
-		this.titleInterval = setInterval(() => {
-			try {
-				const title = this.process.process;
-				if (title && title !== this.lastTitle) {
-					this.lastTitle = title;
-					this.emit("title", title);
-				}
-			} catch {}
-		}, 1e3);
-	}
-	get title() {
-		return this.lastTitle;
-	}
-	appendBuffer(data) {
-		let chunk = data;
-		if (chunk.length > this.maxBufferBytes) chunk = chunk.slice(-this.maxBufferBytes);
-		this.buffer.push(chunk);
-		this.bufferByteLength += chunk.length;
-		while (this.bufferByteLength > this.maxBufferBytes && this.buffer.length > 0) {
-			const removed = this.buffer.shift();
-			this.bufferByteLength -= removed.length;
-		}
-		while (this.buffer.length > this.maxBufferLines) {
-			const removed = this.buffer.shift();
-			this.bufferByteLength -= removed.length;
-		}
+	cli: cliRouter,
+	opsx: opsxRouter,
+	kv: kvRouter,
+	search: searchRouter
+});
+
+//#endregion
+//#region src/search-documents.ts
+function joinParts(parts) {
+	return parts.map((part) => part?.trim() ?? "").filter((part) => part.length > 0).join("\n\n");
+}
+async function collectSearchDocuments(adapter) {
+	const docs = [];
+	const specs = await adapter.listSpecsWithMeta();
+	for (const spec of specs) {
+		const raw = await adapter.readSpecRaw(spec.id);
+		if (!raw) continue;
+		docs.push({
+			id: `spec:${spec.id}`,
+			kind: "spec",
+			title: spec.name,
+			href: `/specs/${encodeURIComponent(spec.id)}`,
+			path: `openspec/specs/${spec.id}/spec.md`,
+			content: raw,
+			updatedAt: spec.updatedAt
+		});
 	}
-	getBuffer() {
-		return this.buffer.join("");
+	const changes = await adapter.listChangesWithMeta();
+	for (const change of changes) {
+		const raw = await adapter.readChangeRaw(change.id);
+		if (!raw) continue;
+		docs.push({
+			id: `change:${change.id}`,
+			kind: "change",
+			title: change.name,
+			href: `/changes/${encodeURIComponent(change.id)}`,
+			path: `openspec/changes/${change.id}`,
+			content: joinParts([
+				raw.proposal,
+				raw.tasks,
+				raw.design,
+				...raw.deltaSpecs.map((deltaSpec) => deltaSpec.content)
+			]),
+			updatedAt: change.updatedAt
+		});
 	}
-	write(data) {
-		if (!this.isExited) this.process.write(data);
+	const archives = await adapter.listArchivedChangesWithMeta();
+	for (const archive of archives) {
+		const raw = await adapter.readArchivedChangeRaw(archive.id);
+		if (!raw) continue;
+		docs.push({
+			id: `archive:${archive.id}`,
+			kind: "archive",
+			title: archive.name,
+			href: `/archive/${encodeURIComponent(archive.id)}`,
+			path: `openspec/changes/archive/${archive.id}`,
+			content: joinParts([
+				raw.proposal,
+				raw.tasks,
+				raw.design,
+				...raw.deltaSpecs.map((deltaSpec) => deltaSpec.content)
+			]),
+			updatedAt: archive.updatedAt
+		});
 	}
-	resize(cols, rows) {
-		if (!this.isExited) this.process.resize(cols, rows);
+	return docs;
+}
+
+//#endregion
+//#region src/search-service.ts
+const REBUILD_DEBOUNCE_MS = 250;
+var SearchService = class {
+	provider;
+	initialized = false;
+	initPromise = null;
+	rebuildPromise = null;
+	rebuildTimer = null;
+	constructor(adapter, watcher, provider = new NodeWorkerSearchProvider()) {
+		this.adapter = adapter;
+		this.provider = provider;
+		watcher?.on("change", () => {
+			this.scheduleRebuild();
+		});
 	}
-	close() {
-		if (this.titleInterval) {
-			clearInterval(this.titleInterval);
-			this.titleInterval = null;
-		}
+	async init() {
+		if (this.initialized) return;
+		if (this.initPromise) return this.initPromise;
+		this.initPromise = this.rebuildIndex(true);
 		try {
-			this.process.kill();
-		} catch {}
-		this.removeAllListeners();
-	}
-	toInfo() {
-		return {
-			id: this.id,
-			title: this.lastTitle,
-			command: this.command,
-			args: this.args,
-			platform: this.platform,
-			isExited: this.isExited,
-			exitCode: this.exitCode,
-			createdAt: this.createdAt
-		};
-	}
-};
-var PtyManager = class {
-	sessions = /* @__PURE__ */ new Map();
-	idCounter = 0;
-	platform;
-	constructor(defaultCwd) {
-		this.defaultCwd = defaultCwd;
-		this.platform = detectPtyPlatform();
+			await this.initPromise;
+		} finally {
+			this.initPromise = null;
+		}
 	}
-	create(opts) {
-		const id = `pty-${++this.idCounter}`;
-		const session = new PtySession(id, {
-			cols: opts.cols,
-			rows: opts.rows,
-			command: opts.command,
-			args: opts.args,
-			cwd: this.defaultCwd,
-			scrollback: opts.scrollback,
-			maxBufferBytes: opts.maxBufferBytes,
-			platform: this.platform
-		});
-		this.sessions.set(id, session);
-		return session;
+	async query(input) {
+		const parsed = SearchQuerySchema.parse(input);
+		await this.init();
+		return this.provider.search(parsed);
 	}
-	get(id) {
-		return this.sessions.get(id);
+	async queryReactive(input) {
+		const parsed = SearchQuerySchema.parse(input);
+		await this.rebuildIndex();
+		return this.provider.search(parsed);
 	}
-	list() {
-		const result = [];
-		for (const session of this.sessions.values()) result.push(session.toInfo());
-		return result;
+	async dispose() {
+		this.cancelRebuild();
+		await this.provider.dispose();
 	}
-	write(id, data) {
-		this.sessions.get(id)?.write(data);
+	scheduleRebuild() {
+		this.cancelRebuild();
+		this.rebuildTimer = setTimeout(() => {
+			this.rebuildTimer = null;
+			this.rebuildIndex().catch(() => {});
+		}, REBUILD_DEBOUNCE_MS);
 	}
-	resize(id, cols, rows) {
-		this.sessions.get(id)?.resize(cols, rows);
+	cancelRebuild() {
+		if (!this.rebuildTimer) return;
+		clearTimeout(this.rebuildTimer);
+		this.rebuildTimer = null;
 	}
-	close(id) {
-		const session = this.sessions.get(id);
-		if (session) {
-			session.close();
-			this.sessions.delete(id);
+	async rebuildIndex(forceInit = false) {
+		if (!forceInit && !this.initialized) return;
+		if (this.rebuildPromise) return this.rebuildPromise;
+		this.rebuildPromise = (async () => {
+			const docs = await collectSearchDocuments(this.adapter);
+			if (this.initialized) await this.provider.replaceAll(docs);
+			else {
+				await this.provider.init(docs);
+				this.initialized = true;
+			}
+		})();
+		try {
+			await this.rebuildPromise;
+		} finally {
+			this.rebuildPromise = null;
 		}
 	}
-	closeAll() {
-		for (const session of this.sessions.values()) session.close();
-		this.sessions.clear();
-	}
 };
 
-//#endregion
-//#region src/pty-websocket.ts
-function createPtyWebSocketHandler(ptyManager) {
-	return (ws) => {
-		const cleanups = /* @__PURE__ */ new Map();
-		const send = (msg) => {
-			if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(msg));
-		};
-		const sendError = (code, message, opts) => {
-			send({
-				type: "error",
-				code,
-				message,
-				sessionId: opts?.sessionId
-			});
-		};
-		const attachToSession = (session, opts) => {
-			const sessionId = session.id;
-			cleanups.get(sessionId)?.();
-			if (opts?.cols && opts?.rows && !session.isExited) session.resize(opts.cols, opts.rows);
-			const onData = (data) => {
-				send({
-					type: "output",
-					sessionId,
-					data
-				});
-			};
-			const onExit = (exitCode) => {
-				send({
-					type: "exit",
-					sessionId,
-					exitCode
-				});
-			};
-			const onTitle = (title) => {
-				send({
-					type: "title",
-					sessionId,
-					title
-				});
-			};
-			session.on("data", onData);
-			session.on("exit", onExit);
-			session.on("title", onTitle);
-			cleanups.set(sessionId, () => {
-				session.removeListener("data", onData);
-				session.removeListener("exit", onExit);
-				session.removeListener("title", onTitle);
-				cleanups.delete(sessionId);
-			});
-		};
-		ws.on("message", (raw) => {
-			let parsed;
-			try {
-				parsed = JSON.parse(String(raw));
-			} catch {
-				sendError("INVALID_JSON", "Invalid JSON payload");
-				return;
-			}
-			const parsedMessage = PtyClientMessageSchema.safeParse(parsed);
-			if (!parsedMessage.success) {
-				const firstIssue = parsedMessage.error.issues[0]?.message;
-				sendError("INVALID_MESSAGE", firstIssue ?? "Invalid PTY message");
-				return;
-			}
-			const msg = parsedMessage.data;
-			switch (msg.type) {
-				case "create":
-					try {
-						const session = ptyManager.create({
-							cols: msg.cols,
-							rows: msg.rows,
-							command: msg.command,
-							args: msg.args
-						});
-						send({
-							type: "created",
-							requestId: msg.requestId,
-							sessionId: session.id,
-							platform: session.platform
-						});
-						attachToSession(session);
-					} catch (err) {
-						sendError("PTY_CREATE_FAILED", err instanceof Error ? err.message : String(err), { sessionId: msg.requestId });
-					}
-					break;
-				case "attach": {
-					const session = ptyManager.get(msg.sessionId);
-					if (!session) {
-						sendError("SESSION_NOT_FOUND", `Session not found: ${msg.sessionId}`, { sessionId: msg.sessionId });
-						send({
-							type: "exit",
-							sessionId: msg.sessionId,
-							exitCode: -1
-						});
-						break;
-					}
-					attachToSession(session, {
-						cols: msg.cols,
-						rows: msg.rows
-					});
-					const buffer = session.getBuffer();
-					if (buffer) send({
-						type: "buffer",
-						sessionId: session.id,
-						data: buffer
-					});
-					if (session.title) send({
-						type: "title",
-						sessionId: session.id,
-						title: session.title
-					});
-					if (session.isExited) send({
-						type: "exit",
-						sessionId: session.id,
-						exitCode: session.exitCode ?? -1
-					});
-					break;
-				}
-				case "list":
-					send({
-						type: "list",
-						sessions: ptyManager.list().map((s) => ({
-							id: s.id,
-							title: s.title,
-							command: s.command,
-							args: s.args,
-							platform: s.platform,
-							isExited: s.isExited,
-							exitCode: s.exitCode
-						}))
-					});
-					break;
-				case "input": {
-					const session = ptyManager.get(msg.sessionId);
-					if (!session) {
-						sendError("SESSION_NOT_FOUND", `Session not found: ${msg.sessionId}`, { sessionId: msg.sessionId });
-						break;
-					}
-					session.write(msg.data);
-					break;
-				}
-				case "resize": {
-					const session = ptyManager.get(msg.sessionId);
-					if (!session) {
-						sendError("SESSION_NOT_FOUND", `Session not found: ${msg.sessionId}`, { sessionId: msg.sessionId });
-						break;
-					}
-					session.resize(msg.cols, msg.rows);
-					break;
-				}
-				case "close": {
-					const session = ptyManager.get(msg.sessionId);
-					if (!session) {
-						sendError("SESSION_NOT_FOUND", `Session not found: ${msg.sessionId}`, { sessionId: msg.sessionId });
-						break;
-					}
-					cleanups.get(msg.sessionId)?.();
-					ptyManager.close(session.id);
-					break;
-				}
-			}
-		});
-		ws.on("close", () => {
-			for (const cleanup of cleanups.values()) cleanup();
-			cleanups.clear();
-		});
-	};
-}
-
 //#endregion
 //#region src/server.ts
 /**
@@ -1514,6 +1488,7 @@ function createServer(config) {
 	const cliExecutor = new CliExecutor(configManager, config.projectDir);
 	const kernel = config.kernel;
 	const watcher = config.enableWatcher !== false ? new OpenSpecWatcher(config.projectDir) : void 0;
+	const searchService = new SearchService(adapter, watcher);
 	const app = new Hono();
 	const corsOrigins = config.corsOrigins ?? ["http://localhost:5173", "http://localhost:3000"];
 	app.use("*", cors({
@@ -1537,6 +1512,7 @@ function createServer(config) {
 				configManager,
 				cliExecutor,
 				kernel,
+				searchService,
 				watcher,
 				projectDir: config.projectDir
 			})
@@ -1547,6 +1523,7 @@ function createServer(config) {
 		configManager,
 		cliExecutor,
 		kernel,
+		searchService,
 		watcher,
 		projectDir: config.projectDir
 	});
@@ -1556,6 +1533,7 @@ function createServer(config) {
 		configManager,
 		cliExecutor,
 		kernel,
+		searchService,
 		watcher,
 		createContext,
 		port: config.port ?? 3100
@@ -1597,6 +1575,7 @@ async function createWebSocketServer(server, httpServer, config) {
 			ptyWss.close();
 			wss.close();
 			server.watcher?.stop();
+			server.searchService.dispose().catch(() => {});
 		}
 	};
 }
@@ -1629,6 +1608,9 @@ async function startServer(config, setupApp) {
 	kernel.warmup().catch((err) => {
 		console.error("Kernel warmup failed:", err);
 	});
+	server.searchService.init().catch((err) => {
+		console.error("Search service warmup failed:", err);
+	});
 	return {
 		url,
 		port,