zidane 6.6.4 → 7.0.0

package/dist/server-DJqp9dIR.js

@@ -0,0 +1,1317 @@
+import { Mn as serializedPayloadBytes, at as createExtensionHud, jn as createExtensionBus, ot as discoverAndBuildExtensionRegistry } from "./agent-C-camKQW.js";
+import { S as resolveInlineSuggestion, b as createPathAutocompleteProvider } from "./src-DzzhE2YO.js";
+import { t as writeFileAtomic } from "./atomic-write-B7zr1ddF.js";
+import { p as resolveStorageDirs } from "./plugins-B531Tz5b.js";
+import { a as successResponse, i as errorResponse, n as JsonRpcRemoteError, r as createJsonRpcConnection } from "./json-rpc-rSWMUh9b.js";
+import { Pt as isMainSession } from "./turn-operations-CZLsNgw-.js";
+import { c as searchSessionHistoryIndexAsync, n as buildSessionSearchIndexAsync, u as searchSessionIndexAsync } from "./history-search-C4bk1Wz_.js";
+import { Gt as modelChainMetadata, In as resolveConfig, It as createChatHost, Kt as sessionModelFallbacks, Lt as toTodosSnapshot, ai as eventsFromTurns, cn as DEFAULT_SETTINGS, fn as SETTINGS_TOGGLES, ft as createFileMcpCredentialStore, hn as enforceSettingsInvariants, ii as deriveSessionTitle } from "./approvals-CqqxE5Vh.js";
+import { d as BUILTIN_PROVIDERS, n as applyApiKeyEnv, r as credentialsPath } from "./auth-BdwDROYg.js";
+import { basename, dirname, join } from "node:path";
+import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { connect, createServer } from "node:net";
+//#region src/ipc/daemon/lifecycle.ts
+/**
+* Daemon lifecycle: socket-path resolution, liveness probing, stale-socket
+* cleanup, and spawn-on-demand.
+*
+* The socket lives in a dedicated daemon subdir of the resolved state dir
+* (`~/.zidane/daemon/daemon.sock` by default, honoring the same
+* `ZIDANE_STORAGE_DIR` / `ZIDANE_PREFIX` env knobs every other surface
+* uses), overridable via `ZIDANE_DAEMON_SOCKET` for parallel installs and
+* tests.
+*/
+/**
+* Build fingerprint for the handshake — the mtime of this module's file
+* at import time. Client and daemon load the same file from disk, so a
+* daemon spawned before a rebuild (or a source edit in dev) reports a
+* different id than a freshly-started client, and the client drains +
+* respawns it. This closes the "same protocol version, different code"
+* gap that a hand-bumped version constant can't: during development the
+* daemon process is frozen at spawn while the tree keeps moving.
+*
+* Compiled binaries (`/$bunfs/…` virtual paths) can't be stat'ed and
+* report `'unknown'`; the check is skipped when EITHER side is unknown,
+* so released builds rely on `IPC_PROTOCOL_VERSION` alone — correct,
+* since their code only changes when the version does.
+*/
+const IPC_BUILD_ID = (() => {
+	try {
+		const selfPath = fileURLToPath(import.meta.url);
+		const ipcRoot = dirname(dirname(selfPath));
+		if (!existsSync(join(ipcRoot, "protocol.ts"))) return String(Math.floor(statSync(selfPath).mtimeMs));
+		const srcRoot = dirname(ipcRoot);
+		let newest = 0;
+		const walk = (dir) => {
+			for (const entry of readdirSync(dir, { withFileTypes: true })) {
+				const full = join(dir, entry.name);
+				if (entry.isDirectory()) walk(full);
+				else newest = Math.max(newest, statSync(full).mtimeMs);
+			}
+		};
+		try {
+			walk(srcRoot);
+		} catch {
+			newest = statSync(selfPath).mtimeMs;
+		}
+		return String(Math.floor(newest));
+	} catch {
+		return "unknown";
+	}
+})();
+function defaultSocketPath() {
+	const explicit = process.env.ZIDANE_DAEMON_SOCKET;
+	if (explicit) return explicit;
+	return join(resolveStorageDirs({ ...process.env.ZIDANE_PREFIX !== void 0 ? { prefix: process.env.ZIDANE_PREFIX } : {} }).stateDir, "daemon", "daemon.sock");
+}
+/**
+* Pre-v6 socket location for the given (v6) socket path, or null when the
+* path isn't the default `<stateDir>/daemon/daemon.sock` layout (explicit
+* `ZIDANE_DAEMON_SOCKET` users never had a migration to run). A daemon
+* still serving the old path would be ORPHANED by the move — new clients
+* never probe it, and a service-style `--idle-exit 0` daemon would hold
+* agents and run-guard markers against the same sessions.db forever —
+* so daemon startup probes this path and drains any survivor.
+*/
+function legacySocketPath(socketPath) {
+	const dir = dirname(socketPath);
+	if (basename(socketPath) !== "daemon.sock" || basename(dir) !== "daemon") return null;
+	return join(dirname(dir), "daemon.sock");
+}
+/**
+* Spawn command that re-enters the CURRENT zidane program as `… daemon`.
+*
+* Three launch shapes:
+*   - compiled Bun binary — `Bun.main` is the virtual `/$bunfs/…` entry the
+*     binary self-inserts as argv[1], so the spawn must NOT repeat it
+*     (verified: repeating it makes the child parse the junk path as its
+*     subcommand and boot the full TUI instead of the daemon).
+*   - dev (`bun run cli.ts`) — the script path must ride along.
+*   - Node hosts (no `Bun` global) — fall back to the published bin.
+*/
+function selfDaemonSpawnCommand() {
+	const bunMain = globalThis.Bun?.main;
+	if (bunMain?.startsWith("/$bunfs")) return [process.execPath, "daemon"];
+	if (bunMain && /(?:^|[/\\])cli\.[cm]?[jt]s$/.test(bunMain)) return [
+		process.execPath,
+		bunMain,
+		"daemon"
+	];
+	return ["zidane-daemon"];
+}
+/**
+* True when something accepts connections on `socketPath`. Distinguishes a
+* live daemon from a stale socket file left by a crashed one.
+*/
+function probeSocket(socketPath, timeoutMs = 1e3) {
+	return new Promise((resolve) => {
+		try {
+			if (!existsSync(socketPath) || !statSync(socketPath).isSocket()) {
+				resolve(false);
+				return;
+			}
+		} catch {
+			resolve(false);
+			return;
+		}
+		let socket;
+		try {
+			socket = connect(socketPath);
+		} catch {
+			resolve(false);
+			return;
+		}
+		const done = (alive) => {
+			socket.destroy();
+			resolve(alive);
+		};
+		socket.once("connect", () => done(true));
+		socket.once("error", () => done(false));
+		socket.setTimeout(timeoutMs, () => done(false));
+	});
+}
+/**
+* Make sure a daemon is listening, spawning one if needed. Resolves with
+* the socket path once a connection succeeds; rejects when the daemon
+* failed to come up within `timeoutMs`.
+*/
+async function ensureDaemonRunning(options = {}) {
+	const socketPath = options.socketPath ?? defaultSocketPath();
+	if (await probeSocket(socketPath)) return socketPath;
+	const [cmd, ...args] = options.spawnCommand ?? ["zidane-daemon"];
+	const child = spawn(cmd, args, {
+		detached: true,
+		stdio: "ignore",
+		env: {
+			...process.env,
+			ZIDANE_DAEMON_SOCKET: socketPath
+		}
+	});
+	let spawnError;
+	child.once("error", (err) => {
+		spawnError = err;
+	});
+	child.unref();
+	const deadline = Date.now() + (options.timeoutMs ?? 8e3);
+	for (;;) {
+		if (spawnError !== void 0) throw new Error(`Failed to spawn zidane daemon (${cmd}): ${spawnError.message}`);
+		if (await probeSocket(socketPath)) return socketPath;
+		if (Date.now() > deadline) throw new Error(`zidane daemon did not come up on ${socketPath} within ${options.timeoutMs ?? 8e3}ms.`);
+		await new Promise((r) => setTimeout(r, 150));
+	}
+}
+//#endregion
+//#region src/ipc/protocol.ts
+/**
+* v6 (changes since v5):
+*   - `event` signals carry an optional `echo` flag marking host-generated
+*     SEND/STEER echoes of the user's own message.
+*   - `chat.pushQueued` result gained the `'queued'` delivered variant.
+*   - `sessions.setModel` now honors `fallbacks`: it persists the canonical
+*     `metadata.modelChain` and CLEARS a previously persisted chain when
+*     omitted/empty.
+*   - additive: `extension.emit` notification + `extension:signal` fan-out
+*     (the permission-gated per-extension cross-window bus, `ctx.bus`).
+*     Older daemons ignore the unknown notification; older clients drop the
+*     unknown signal kind — no version bump needed.
+*   - additive: `extension.emit` / `extension:signal` carry an optional
+*     `nonce` (the emitter's per-process random id) so receivers dedupe on
+*     `(extensionId, nonce, seq)` instead of the collision-prone
+*     `(extensionId, seq)`. Older peers omit it and fall back to the
+*     seq-only key — no version bump needed.
+*   - `SessionRow.modelFallbacks` is now populated from the session's
+*     persisted `metadata.modelChain`.
+*   - Default socket path moved from `<stateDir>/daemon.sock` to the
+*     dedicated `<stateDir>/daemon/daemon.sock` (dir chmod'd 0700) so the
+*     daemon can harden its socket dir without touching shared state files.
+*   - ADDITIVE (no version bump — older daemons answer "method not
+*     found", clients degrade to local compute): `suggest.resolve` RPC
+*     resolves inline ghost-text autocomplete daemon-side, and the
+*     `suggest:changed` signal fans the result out to every OTHER peer
+*     on the session so mirroring windows paint the same ghost without
+*     recomputing.
+*   - ADDITIVE (no version bump — optional field, older daemons simply
+*     omit it and clients fall back to the single `suggestion`):
+*     `suggest.resolve` results and `suggest:changed` signals carry the
+*     resolver's full ordered `candidates` list so daemon mode keeps
+*     ↑/↓ candidate rotation instead of degrading to one suggestion.
+*/
+const IPC_PROTOCOL_VERSION = 8;
+/**
+* JSON-RPC error codes specific to the zidane daemon. Lives here (not in
+* `daemon/server.ts`) so clients can import the codes without pulling the
+* server's module graph.
+*/
+const IpcErrorCode = {
+	VersionMismatch: -32010,
+	NotHandshaken: -32011
+};
+//#endregion
+//#region src/ipc/client.ts
+var IpcVersionMismatchError = class extends Error {
+	daemon;
+	constructor(message, daemon) {
+		super(message);
+		this.daemon = daemon;
+		this.name = "IpcVersionMismatchError";
+	}
+};
+async function connectIpcClient(options) {
+	const socket = await new Promise((resolvePromise, reject) => {
+		const s = connect(options.socketPath);
+		s.once("connect", () => {
+			s.off("error", reject);
+			resolvePromise(s);
+		});
+		s.once("error", reject);
+	});
+	const listeners = /* @__PURE__ */ new Set();
+	let closed = false;
+	const connection = createJsonRpcConnection({
+		input: socket,
+		output: socket,
+		onRequest: (message) => errorResponse(message.id, -32601, "Clients do not accept requests."),
+		onNotification: (message) => {
+			if (message.method !== "ipc.signal") return;
+			const signal = message.params;
+			if (!signal) return;
+			for (const cb of listeners) cb(signal);
+		}
+	});
+	connection.start();
+	const close = () => {
+		if (closed) return;
+		closed = true;
+		connection.close();
+		socket.destroy();
+	};
+	socket.on("close", () => {
+		if (closed) return;
+		closed = true;
+		connection.close();
+		options.onClose?.();
+	});
+	socket.on("error", () => {});
+	const HELLO_TIMEOUT_MS = 5e3;
+	const REQUEST_TIMEOUT_MS = 3e4;
+	const LONG_REQUEST_TIMEOUT_MS = 600 * 1e3;
+	/** RPCs that legitimately run long — full compaction, index-backed cross-session search. */
+	const LONG_REQUEST_METHODS = /* @__PURE__ */ new Set([
+		"sessions.compact",
+		"history.searchAll",
+		"history.searchSession"
+	]);
+	let helloTimer;
+	let hello;
+	try {
+		hello = await Promise.race([connection.sendRequest("ipc.hello", {
+			protocolVersion: 8,
+			appVersion: options.appVersion ?? "dev",
+			pid: process.pid,
+			buildId: options.drainOnMismatch === false ? "unknown" : IPC_BUILD_ID
+		}), new Promise((_, reject) => {
+			helloTimer = setTimeout(() => reject(/* @__PURE__ */ new Error(`Daemon handshake timed out after ${HELLO_TIMEOUT_MS}ms on ${options.socketPath}.`)), HELLO_TIMEOUT_MS);
+		})]);
+	} catch (err) {
+		if (err instanceof JsonRpcRemoteError && err.code === IpcErrorCode.VersionMismatch) {
+			if (options.drainOnMismatch !== false) await Promise.race([connection.sendRequest("daemon.shutdown", {}).catch(() => void 0), new Promise((resolve) => setTimeout(resolve, 1500))]);
+			const daemon = err.data?.daemon;
+			close();
+			throw new IpcVersionMismatchError(err.message, daemon);
+		}
+		close();
+		throw err;
+	} finally {
+		clearTimeout(helloTimer);
+	}
+	return {
+		hello,
+		notify: (method, params) => {
+			try {
+				connection.sendNotification(method, params);
+			} catch {}
+		},
+		request: async (method, params) => {
+			const timeoutMs = LONG_REQUEST_METHODS.has(method) ? LONG_REQUEST_TIMEOUT_MS : REQUEST_TIMEOUT_MS;
+			let timer;
+			try {
+				return await Promise.race([connection.sendRequest(method, params), new Promise((_, reject) => {
+					timer = setTimeout(() => {
+						reject(/* @__PURE__ */ new Error(`Daemon request ${method} timed out after ${timeoutMs}ms — tearing the connection down.`));
+						socket.destroy();
+					}, timeoutMs);
+					timer.unref?.();
+				})]);
+			} finally {
+				clearTimeout(timer);
+			}
+		},
+		onSignal: (cb) => {
+			listeners.add(cb);
+			return () => listeners.delete(cb);
+		},
+		close
+	};
+}
+/**
+* One-call convenience for windows: make sure a daemon is up (spawning if
+* needed), connect, and — when the running daemon speaks an older protocol
+* — drain it and spawn a fresh one before retrying once.
+*/
+async function connectOrSpawnDaemon(options = {}) {
+	const socketPath = await ensureDaemonRunning(options);
+	try {
+		return await connectIpcClient({
+			...options,
+			socketPath
+		});
+	} catch (err) {
+		if (!(err instanceof IpcVersionMismatchError)) throw err;
+		const drainDeadline = Date.now() + 2e3;
+		while (await probeSocket(socketPath)) {
+			if (Date.now() > drainDeadline) break;
+			await new Promise((r) => setTimeout(r, 100));
+		}
+		const retryPath = await ensureDaemonRunning(options);
+		return connectIpcClient({
+			...options,
+			socketPath: retryPath
+		});
+	}
+}
+//#endregion
+//#region src/ipc/daemon/environment.ts
+/**
+* File-backed pending-approvals persistence (`pending-approvals.json` next
+* to `state.json`). Small, rewritten atomically enough for its purpose —
+* the queue holds at most a handful of rows.
+*/
+function createFileApprovalsStore(path) {
+	function read() {
+		if (!existsSync(path)) return [];
+		try {
+			const parsed = JSON.parse(readFileSync(path, "utf8"));
+			return Array.isArray(parsed) ? parsed : [];
+		} catch {
+			return [];
+		}
+	}
+	function write(rows) {
+		if (rows.length === 0) {
+			try {
+				unlinkSync(path);
+			} catch {}
+			return;
+		}
+		mkdirSync(dirname(path), { recursive: true });
+		writeFileAtomic(path, JSON.stringify(rows, null, 2));
+	}
+	return {
+		insert(request) {
+			const rows = read().filter((r) => r.id !== request.id);
+			rows.push(request);
+			write(rows);
+		},
+		delete(id) {
+			write(read().filter((r) => r.id !== id));
+		},
+		clear() {
+			write([]);
+		},
+		list() {
+			return read();
+		}
+	};
+}
+async function createDaemonEnvironment(options) {
+	const { createTuiStore } = await import("./session/sqlite.js");
+	const config = resolveConfig({
+		...options.cwd !== void 0 ? { cwd: options.cwd } : {},
+		store: (resolved) => createTuiStore(resolved.db)
+	});
+	const store = config.store;
+	if (config.paths.projectDir) process.stderr.write(`[zidane-daemon] warning: project-DB mode is active — this daemon is bound to ${config.paths.db}. Windows opened in other projects will share this project's sessions. Run a per-project daemon (ZIDANE_DAEMON_SOCKET) to isolate them.\n`);
+	const readSettings = () => ({
+		...DEFAULT_SETTINGS,
+		...config.initialSettings,
+		...config.stateStore.load().settings ?? {}
+	});
+	/**
+	* Fields the invariant forced (only ever `false`), so the stored file records
+	* them too — otherwise a later read of `state.settings` would resurrect the
+	* value the invariant just rejected.
+	*/
+	const pickInvariantFields = (merged, patch) => {
+		const out = {};
+		for (const row of SETTINGS_TOGGLES) if (row.requires && merged[row.key] === false && patch[row.key] !== false) out[row.key] = false;
+		return out;
+	};
+	const writeSettings = (patch) => {
+		const state = config.stateStore.load();
+		const merged = enforceSettingsInvariants({
+			...DEFAULT_SETTINGS,
+			...config.initialSettings,
+			...state.settings ?? {},
+			...patch
+		});
+		const next = {
+			...state.settings ?? {},
+			...patch,
+			...pickInvariantFields(merged, patch)
+		};
+		config.stateStore.save({
+			...state,
+			settings: next
+		});
+		return merged;
+	};
+	const hud = createExtensionHud();
+	hud.subscribe(() => {
+		const state = hud.getState();
+		options.broadcast({
+			kind: "hud:state",
+			statuses: Object.fromEntries(Object.entries(state.statuses).map(([name, s]) => [name, {
+				text: s.text,
+				loader: s.loader
+			}])),
+			banners: Object.fromEntries(Object.entries(state.banners).map(([name, lines]) => [name, [...lines]]))
+		});
+	});
+	hud.onNotify((n) => {
+		options.broadcast({
+			kind: "hud:notify",
+			extension: n.extension,
+			text: n.text,
+			tone: n.tone
+		});
+	});
+	const extensionBus = createExtensionBus();
+	extensionBus.onEmit((envelope) => {
+		options.broadcast({
+			kind: "extension:signal",
+			...envelope
+		});
+	});
+	const RUNTIME_CACHE_MAX = 16;
+	const runtimeCache = /* @__PURE__ */ new Map();
+	/**
+	* Best-effort release of an evicted entry's extension registry
+	* (teardown hooks, HUD writers — `registry.dispose()` is idempotent).
+	* Fire-and-forget: eviction must never block or throw on a broken
+	* extension teardown, and a rejected resolve has nothing to release.
+	*/
+	const disposeRuntime = (promise) => {
+		promise.then((config) => config.extensions.dispose()).catch(() => void 0);
+	};
+	const runtimeConfig = (cwd) => {
+		const settings = readSettings();
+		const key = [
+			cwd,
+			JSON.stringify(settings.enabledExtensions ?? null),
+			String(settings.loadProjectExtensions === true)
+		].join("\0");
+		const existing = runtimeCache.get(key);
+		if (existing) {
+			runtimeCache.delete(key);
+			runtimeCache.set(key, existing);
+			return existing;
+		}
+		const promise = (async () => {
+			return resolveConfig({
+				cwd,
+				extensionRegistry: await discoverAndBuildExtensionRegistry({
+					cwd,
+					hud,
+					bus: extensionBus,
+					prefix: config.prefix,
+					...settings.enabledExtensions !== void 0 ? { enabledAllowlist: [...settings.enabledExtensions] } : {},
+					trustProjectExtensions: settings.loadProjectExtensions === true,
+					readSettings
+				}),
+				store: () => store
+			});
+		})();
+		runtimeCache.set(key, promise);
+		while (runtimeCache.size > RUNTIME_CACHE_MAX) {
+			const oldest = runtimeCache.keys().next().value;
+			if (oldest === void 0) break;
+			const evicted = runtimeCache.get(oldest);
+			runtimeCache.delete(oldest);
+			if (evicted) disposeRuntime(evicted);
+		}
+		promise.catch(() => {
+			if (runtimeCache.get(key) === promise) runtimeCache.delete(key);
+		});
+		return promise;
+	};
+	const userDataDir = () => config.paths.userDir;
+	const applyAuthEnv = () => {
+		const dir = userDataDir();
+		process.env.ZIDANE_CREDENTIALS_PATH = credentialsPath(dir);
+		applyApiKeyEnv(dir, BUILTIN_PROVIDERS);
+	};
+	return {
+		multiProcess: true,
+		broadcast: options.broadcast,
+		store,
+		readSettings,
+		writeSettings,
+		runtimeConfig,
+		userDataDir,
+		applyAuthEnv,
+		mcpCredentialStore: () => createFileMcpCredentialStore(userDataDir()),
+		approvalsPersistence: createFileApprovalsStore(join(dirname(config.paths.state), "pending-approvals.json")),
+		...options.debugStream !== void 0 ? { debugStream: options.debugStream } : {},
+		invalidateRuntime: () => {
+			for (const entry of runtimeCache.values()) disposeRuntime(entry);
+			runtimeCache.clear();
+		},
+		config,
+		extensionBus
+	};
+}
+//#endregion
+//#region src/ipc/daemon/server.ts
+/**
+* Per-peer write backpressure bound. A wedged peer (e.g. a SIGSTOP'd
+* terminal) stops reading its socket, so fan-out writes pile up in
+* `socket.writableLength` without bound and can OOM the daemon. A peer
+* buffering more than this is destroyed — the protocol supports re-attach
+* + backfill, so killing a wedged peer is safe and self-healing.
+*/
+const PEER_WRITE_HIGH_WATERMARK = 8 * 1024 * 1024;
+async function startIpcDaemon(options) {
+	const { socketPath } = options;
+	const log = options.onLog ?? (() => void 0);
+	const startedAt = Date.now();
+	const appVersion = options.appVersion ?? "dev";
+	const peers = /* @__PURE__ */ new Set();
+	/** Sessions with a run in flight, tracked from the run signals themselves. */
+	const runningSessions = /* @__PURE__ */ new Set();
+	const broadcast = (signal) => {
+		broadcastExcept(null, signal);
+		switch (signal.kind) {
+			case "run:start":
+				runningSessions.add(signal.sessionId);
+				broadcastPresence();
+				break;
+			case "run:end":
+				runningSessions.delete(signal.sessionId);
+				broadcastPresence();
+				break;
+			case "approval:request":
+			case "approval:resolved":
+			case "interaction:request":
+			case "interaction:resolved":
+				broadcastPresence();
+				break;
+			default: break;
+		}
+	};
+	/**
+	* Fan out to every handshaken peer except `origin`. Draft signals use
+	* this so a window's own keystrokes never bounce back and fight its
+	* cursor — echo-safety by construction, no client-side dedupe.
+	*/
+	function broadcastExcept(origin, signal) {
+		for (const peer of peers) {
+			if (!peer.ready || peer === origin) continue;
+			if (peer.socket.writableLength > PEER_WRITE_HIGH_WATERMARK) {
+				console.warn(`[ipc-daemon] peer buffered ${peer.socket.writableLength} bytes (> ${PEER_WRITE_HIGH_WATERMARK}) — destroying wedged connection`);
+				peer.socket.destroy();
+				continue;
+			}
+			try {
+				peer.connection.sendNotification("ipc.signal", signal);
+			} catch {}
+		}
+	}
+	/**
+	* Shared per-session prompt drafts. Ephemeral by design — in-memory
+	* only, cleared when any window submits, gone on daemon restart.
+	*/
+	const drafts = /* @__PURE__ */ new Map();
+	/**
+	* Bound a peer-supplied attachment list: shape-guarded entries only,
+	* 24 MiB of base64 per list. Shared by `queue.add` and
+	* `drafts.setAttachments`.
+	*/
+	function boundAttachments(list) {
+		let budget = 24 * 1024 * 1024;
+		const out = [];
+		for (const entry of list) {
+			const a = entry;
+			if (typeof a?.mediaType !== "string" || typeof a?.data !== "string") continue;
+			budget -= a.data.length;
+			if (budget < 0) break;
+			out.push({
+				mediaType: a.mediaType,
+				data: a.data,
+				...typeof a.name === "string" ? { name: a.name.slice(0, 256) } : {}
+			});
+		}
+		return out;
+	}
+	/** Total base64 bytes currently pinned by ALL draft attachments. */
+	function draftAttachmentBytes() {
+		let total = 0;
+		for (const entry of drafts.values()) for (const attachment of entry.attachments ?? []) total += attachment.data.length;
+		return total;
+	}
+	/** Consume the draft after a submit — every window except the sender clears. */
+	function clearDraft(sessionId, origin) {
+		const entry = drafts.get(sessionId);
+		if (!entry) return;
+		drafts.delete(sessionId);
+		if (entry.text) broadcastExcept(origin, {
+			kind: "draft:changed",
+			sessionId,
+			text: ""
+		});
+		if (entry.attachments?.length) broadcastExcept(origin, {
+			kind: "draft:attachments",
+			sessionId,
+			attachments: []
+		});
+	}
+	/**
+	* Shared inline-autocomplete state — per-session latest-wins
+	* coalescing for `suggest.resolve`. `seq` is the newest sequence seen
+	* (stale requests return without computing); `controller` aborts an
+	* in-flight compute when a newer request supersedes it (the GUI's
+	* controller-map pattern, daemon-side). Bounded like `drafts`: keys
+	* only evict on session delete, so cap the map at 256 sessions.
+	*/
+	const suggests = /* @__PURE__ */ new Map();
+	/** Drop empty draft entries so the map only holds live composing state. */
+	function compactDraft(sessionId, entry) {
+		if (!entry.text && !entry.shell && !entry.attachments?.length && !entry.search?.active) drafts.delete(sessionId);
+		else drafts.set(sessionId, entry);
+	}
+	const env = await (options.createEnvironment ? options.createEnvironment(broadcast) : createDaemonEnvironment({ broadcast }));
+	const host = createChatHost(env);
+	/**
+	* Live presence: which sessions have attached windows, and their
+	* run / awaiting-input state. Union of watched, live-agent, and
+	* pending-HITL sessions — small by construction.
+	*/
+	function computePresence() {
+		const windowCounts = /* @__PURE__ */ new Map();
+		for (const peer of peers) if (peer.ready && peer.watching) windowCounts.set(peer.watching, (windowCounts.get(peer.watching) ?? 0) + 1);
+		const attention = /* @__PURE__ */ new Set();
+		for (const request of host.approvals.listPending()) attention.add(request.sessionId);
+		for (const pending of host.interactions.list()) attention.add(pending.sessionId);
+		const live = new Map(host.listLiveSessions().map((entry) => [entry.sessionId, entry.running]));
+		return [.../* @__PURE__ */ new Set([
+			...windowCounts.keys(),
+			...attention,
+			...live.keys(),
+			...runningSessions
+		])].map((sessionId) => ({
+			sessionId,
+			windows: windowCounts.get(sessionId) ?? 0,
+			running: runningSessions.has(sessionId) || live.get(sessionId) === true,
+			attention: attention.has(sessionId)
+		}));
+	}
+	function broadcastPresence() {
+		broadcastExcept(null, {
+			kind: "presence:changed",
+			sessions: computePresence()
+		});
+	}
+	const SEARCH_INDEX_CACHE_MAX = 64;
+	/** Latest `history.searchAll` generation per peer — see the handler. */
+	const searchGenerations = /* @__PURE__ */ new WeakMap();
+	const searchIndexCache = /* @__PURE__ */ new Map();
+	async function sessionSearchIndex(sessionId) {
+		const liveTurns = host.getLiveTurns(sessionId);
+		let turns;
+		let key;
+		if (liveTurns) {
+			turns = [...liveTurns];
+			key = `live:${turns.length}:${turns.at(-1)?.id ?? ""}`;
+		} else {
+			const data = await env.store.load(sessionId);
+			if (!data) return null;
+			turns = data.turns;
+			key = `store:${data.updatedAt}:${data.turns.length}`;
+		}
+		const cached = searchIndexCache.get(sessionId);
+		if (cached?.key === key) {
+			searchIndexCache.delete(sessionId);
+			searchIndexCache.set(sessionId, cached);
+			return cached.index;
+		}
+		const index = await buildSessionSearchIndexAsync(turns);
+		searchIndexCache.set(sessionId, {
+			key,
+			index
+		});
+		while (searchIndexCache.size > SEARCH_INDEX_CACHE_MAX) {
+			const oldest = searchIndexCache.keys().next().value;
+			if (oldest === void 0) break;
+			searchIndexCache.delete(oldest);
+		}
+		return index;
+	}
+	host.approvals.rehydrate();
+	const store = env.store;
+	function toRow(data) {
+		const meta = data.metadata ?? {};
+		const title = deriveSessionTitle(data.turns, meta);
+		return {
+			id: data.id,
+			title,
+			...isMainSession(meta) ? { isMain: true } : {},
+			projectRoot: data.projectRoot ?? null,
+			cwd: typeof meta.cwd === "string" ? meta.cwd : data.projectRoot ?? "",
+			...typeof data.agentId === "string" ? { agentId: data.agentId } : {},
+			status: host.isSessionRunning(data.id) ? "running" : data.status === "running" && Date.now() - data.updatedAt >= 3e5 ? "idle" : data.status,
+			createdAt: data.createdAt,
+			updatedAt: data.updatedAt,
+			archived: meta.archived === true,
+			...typeof meta.providerKey === "string" ? { providerKey: meta.providerKey } : {},
+			...typeof meta.modelId === "string" ? { modelId: meta.modelId } : {},
+			...typeof meta.effort === "string" ? { effort: meta.effort } : {},
+			...meta.modelOptions && typeof meta.modelOptions === "object" ? { modelOptions: meta.modelOptions } : {},
+			...(() => {
+				const fallbacks = sessionModelFallbacks(meta);
+				return fallbacks ? { modelFallbacks: fallbacks } : {};
+			})()
+		};
+	}
+	async function loadOrThrow(sessionId) {
+		const data = await store.load(sessionId);
+		if (!data) throw new Error(`Session "${sessionId}" not found.`);
+		return data;
+	}
+	/**
+	* Apply a metadata-only patch. Prefers the host's live-session path (safe
+	* mid-run — routes through the in-memory `Session` whose turns are the
+	* source of truth); only falls back to a store-level full-document
+	* `save()` when the session is idle, where no run is appending turns so
+	* `load → mutate → save` can't drop concurrently-persisted turns.
+	*
+	* `bumpUpdatedAt: false` skips the recency bump so a rename doesn't yank
+	* the row to the top of recency-sorted lists (mirrors the GUI).
+	*/
+	async function patchSessionMeta(sessionId, patch, opts = {}) {
+		if (await host.patchLiveSessionMeta(sessionId, patch)) {
+			broadcast({
+				kind: "sessions:changed",
+				op: "update",
+				sessionId
+			});
+			return;
+		}
+		const data = await loadOrThrow(sessionId);
+		for (const [key, value] of Object.entries(patch)) data.metadata[key] = value;
+		if (opts.bumpUpdatedAt !== false) data.updatedAt = Date.now();
+		await store.save(data);
+		broadcast({
+			kind: "sessions:changed",
+			op: "update",
+			sessionId
+		});
+	}
+	async function patchSession(sessionId, mutate) {
+		const data = await loadOrThrow(sessionId);
+		mutate(data);
+		data.updatedAt = Date.now();
+		await store.save(data);
+		broadcast({
+			kind: "sessions:changed",
+			op: "update",
+			sessionId
+		});
+	}
+	async function createSessionRow(params) {
+		const id = await host.createSession(params);
+		const data = await loadOrThrow(id);
+		broadcast({
+			kind: "sessions:changed",
+			op: "create",
+			sessionId: id
+		});
+		return toRow(data);
+	}
+	const methods = {
+		"chat.send": async (p, peer) => {
+			const { wake: _stripped, ...params } = p;
+			const result = await host.sendPrompt(params);
+			clearDraft(p.sessionId, peer);
+			return result;
+		},
+		"chat.interrupt": (p) => host.interrupt(p.sessionId),
+		"chat.steer": (p) => host.steer(p.sessionId, p.message),
+		"chat.followUp": (p) => host.followUp(p.sessionId, p.message),
+		"chat.pushQueued": async (p, peer) => {
+			const result = await host.pushQueued(p.sessionId, p.message, p.activatedSkills);
+			clearDraft(p.sessionId, peer);
+			return result;
+		},
+		"commands.list": (p) => host.listCommands(p.cwd),
+		"commands.completeArgs": (p) => host.completeCommandArgs(p.cwd, p.name, p.argsPrefix),
+		"queue.list": (p) => host.queueList(p.sessionId),
+		"sessions.systemMd": (p) => host.sessionSystemMd(p.sessionId),
+		"queue.add": async (p, peer) => {
+			const text = typeof p.text === "string" ? p.text.slice(0, 64 * 1024) : "";
+			const activatedSkills = Array.isArray(p.activatedSkills) ? p.activatedSkills.filter((name) => typeof name === "string") : void 0;
+			const attachments = Array.isArray(p.attachments) ? boundAttachments(p.attachments) : void 0;
+			const result = await host.queueAdd(p.sessionId, text, activatedSkills, attachments);
+			clearDraft(p.sessionId, peer);
+			return result;
+		},
+		"sessions.contextSegments": (p) => host.getContextSegments(p.sessionId),
+		"sessions.createSystemOverride": (p) => host.createSystemOverride(p.sessionId),
+		"queue.remove": (p) => host.queueRemove(p.sessionId, p.id),
+		"queue.pushNow": (p) => host.queuePushNow(p.sessionId, p.id),
+		"drafts.get": (p) => {
+			const entry = drafts.get(p.sessionId);
+			return {
+				text: entry?.text ?? "",
+				...entry?.shell ? { shell: true } : {},
+				...entry?.attachments?.length ? { attachments: entry.attachments } : {},
+				...entry?.search?.active ? { search: entry.search } : {}
+			};
+		},
+		"drafts.set": (p, peer) => {
+			const text = typeof p.text === "string" ? p.text.slice(0, 64 * 1024) : "";
+			const truncated = typeof p.text === "string" && p.text.length > text.length;
+			if (!drafts.has(p.sessionId) && drafts.size >= 256) return;
+			const entry = drafts.get(p.sessionId) ?? {};
+			entry.text = text.length > 0 ? text : void 0;
+			entry.shell = p.shell === true ? true : void 0;
+			compactDraft(p.sessionId, entry);
+			broadcastExcept(truncated ? null : peer, {
+				kind: "draft:changed",
+				sessionId: p.sessionId,
+				text,
+				...p.shell === true ? { shell: true } : {}
+			});
+		},
+		"search.set": (p, peer) => {
+			const active = p.active === true;
+			const query = typeof p.query === "string" ? p.query.slice(0, 4 * 1024) : "";
+			if (!drafts.has(p.sessionId) && drafts.size >= 256) return;
+			const entry = drafts.get(p.sessionId) ?? {};
+			entry.search = active || query.length > 0 ? {
+				active,
+				query
+			} : void 0;
+			compactDraft(p.sessionId, entry);
+			broadcastExcept(peer, {
+				kind: "search:changed",
+				sessionId: p.sessionId,
+				active,
+				query
+			});
+		},
+		"extension.emit": async (p, peer) => {
+			const extensionId = typeof p.extensionId === "string" ? p.extensionId : "";
+			if (extensionId.length === 0 || extensionId.length > 256) return;
+			if (typeof p.seq !== "number" || !Number.isFinite(p.seq)) return;
+			const sessionId = typeof p.sessionId === "string" ? p.sessionId : void 0;
+			const bytes = serializedPayloadBytes(p.payload);
+			if (bytes === null || bytes > 65536) return;
+			let registry = env.config.extensions;
+			if (sessionId !== void 0) try {
+				const data = await loadOrThrow(sessionId);
+				const meta = data.metadata ?? {};
+				const cwd = typeof meta.cwd === "string" ? meta.cwd : data.projectRoot ?? "";
+				registry = (await env.runtimeConfig(cwd)).extensions;
+			} catch {
+				return;
+			}
+			if (!registry.loaded.some((ext) => !ext.error && ext.name === extensionId && ext.definition?.permissions?.includes("ipc") === true)) return;
+			const nonce = typeof p.nonce === "string" ? p.nonce : void 0;
+			const envelope = {
+				extensionId,
+				...sessionId !== void 0 ? { sessionId } : {},
+				payload: p.payload,
+				seq: p.seq,
+				...nonce !== void 0 ? { nonce } : {}
+			};
+			env.extensionBus?.deliver(envelope);
+			broadcastExcept(peer, {
+				kind: "extension:signal",
+				...envelope
+			});
+		},
+		"suggest.resolve": async (p, peer) => {
+			const sessionId = String(p.sessionId);
+			const seq = typeof p.seq === "number" ? p.seq : 0;
+			const text = typeof p.text === "string" ? p.text.slice(0, 64 * 1024) : "";
+			const caret = typeof p.caret === "number" ? Math.max(0, Math.min(Math.floor(p.caret), text.length)) : text.length;
+			const prev = suggests.get(sessionId);
+			if (prev && seq < prev.seq) return {
+				suggestion: null,
+				seq
+			};
+			if (!prev && suggests.size >= 256) return {
+				suggestion: null,
+				seq
+			};
+			prev?.controller?.abort();
+			const controller = new AbortController();
+			const entry = {
+				seq,
+				controller
+			};
+			suggests.set(sessionId, entry);
+			try {
+				const data = await loadOrThrow(sessionId);
+				const meta = data.metadata ?? {};
+				const cwd = typeof meta.cwd === "string" ? meta.cwd : data.projectRoot ?? "";
+				const config = await env.runtimeConfig(cwd);
+				const result = await resolveInlineSuggestion([createPathAutocompleteProvider({ cwd: () => cwd }), ...config.extensions.inlineAutocompleteProviders], {
+					text,
+					cursor: caret,
+					cwd,
+					signal: controller.signal
+				});
+				if (controller.signal.aborted || suggests.get(sessionId) !== entry) return {
+					suggestion: null,
+					seq
+				};
+				const candidates = result ? [...result.suffixes] : [];
+				const suggestion = candidates[0] ?? null;
+				broadcastExcept(peer, {
+					kind: "suggest:changed",
+					sessionId,
+					seq,
+					basis: text,
+					caret,
+					suggestion,
+					...candidates.length > 0 ? { candidates } : {}
+				});
+				return {
+					suggestion,
+					seq,
+					...candidates.length > 0 ? { candidates } : {}
+				};
+			} finally {
+				if (suggests.get(sessionId) === entry) entry.controller = null;
+			}
+		},
+		"drafts.setAttachments": (p, peer) => {
+			const bounded = Array.isArray(p.attachments) ? boundAttachments(p.attachments) : [];
+			if (!drafts.has(p.sessionId) && drafts.size >= 256) return;
+			const currentBytes = (drafts.get(p.sessionId)?.attachments ?? []).reduce((sum, a) => sum + a.data.length, 0);
+			const incomingBytes = bounded.reduce((sum, a) => sum + a.data.length, 0);
+			if (draftAttachmentBytes() - currentBytes + incomingBytes > 96 * 1024 * 1024) return;
+			const entry = drafts.get(p.sessionId) ?? {};
+			entry.attachments = bounded.length > 0 ? bounded : void 0;
+			compactDraft(p.sessionId, entry);
+			broadcastExcept(peer, {
+				kind: "draft:attachments",
+				sessionId: p.sessionId,
+				attachments: bounded
+			});
+		},
+		"chat.isRunning": (p) => host.isSessionRunning(p.sessionId),
+		"chat.rebuildAgent": (p) => host.disposeAgentForRebuild(p.sessionId),
+		"chat.listWork": (p) => host.listRunningWork(p.sessionId),
+		"chat.cancelWork": (p) => host.cancelRunningWork(p.sessionId, p.id, p.reason),
+		"sessions.list": async (p) => {
+			const filter = p?.projectRoot !== void 0 ? { projectRoot: p.projectRoot } : void 0;
+			const applyArchive = (rows) => {
+				const filtered = rows.filter((row) => {
+					if (p?.archive === "active") return !row.archived;
+					if (p?.archive === "archived") return row.archived;
+					return true;
+				});
+				filtered.sort((a, b) => b.updatedAt - a.updatedAt);
+				return filtered;
+			};
+			if (store.listMeta) return applyArchive((await store.listMeta(filter)).map((meta) => {
+				const md = meta.metadata;
+				const title = deriveSessionTitle(meta.firstUserTurn ? [meta.firstUserTurn] : [], md);
+				return {
+					id: meta.id,
+					title,
+					projectRoot: meta.projectRoot ?? null,
+					cwd: typeof md.cwd === "string" ? md.cwd : meta.projectRoot ?? "",
+					...meta.agentId ? { agentId: meta.agentId } : {},
+					status: host.isSessionRunning(meta.id) ? "running" : meta.status === "running" && Date.now() - meta.updatedAt >= 3e5 ? "idle" : meta.status ?? "idle",
+					createdAt: meta.createdAt ?? 0,
+					updatedAt: meta.updatedAt,
+					archived: md.archived === true,
+					...typeof md.providerKey === "string" ? { providerKey: md.providerKey } : {},
+					...typeof md.modelId === "string" ? { modelId: md.modelId } : {},
+					...typeof md.effort === "string" ? { effort: md.effort } : {},
+					...md.modelOptions && typeof md.modelOptions === "object" ? { modelOptions: md.modelOptions } : {},
+					...(() => {
+						const fallbacks = sessionModelFallbacks(md);
+						return fallbacks ? { modelFallbacks: fallbacks } : {};
+					})()
+				};
+			}));
+			const ids = await store.list(filter);
+			const rows = [];
+			for (const id of ids) {
+				const data = await store.load(id);
+				if (!data) continue;
+				rows.push(toRow(data));
+			}
+			return applyArchive(rows);
+		},
+		"sessions.create": (p) => createSessionRow(p),
+		"sessions.delete": async (p) => {
+			drafts.delete(p.sessionId);
+			suggests.get(p.sessionId)?.controller?.abort();
+			suggests.delete(p.sessionId);
+			host.disposeSession(p.sessionId);
+			await store.delete(p.sessionId);
+			broadcast({
+				kind: "sessions:changed",
+				op: "delete",
+				sessionId: p.sessionId
+			});
+		},
+		"sessions.setTitle": (p) => patchSessionMeta(p.sessionId, { title: p.title }, { bumpUpdatedAt: false }),
+		"sessions.setArchived": (p) => patchSessionMeta(p.sessionId, { archived: p.archived }),
+		"sessions.setAgentId": async (p) => {
+			if (await host.setLiveSessionAgentId(p.sessionId, p.agentId)) broadcast({
+				kind: "sessions:changed",
+				op: "update",
+				sessionId: p.sessionId
+			});
+			else await patchSession(p.sessionId, (d) => {
+				d.agentId = p.agentId;
+			});
+			host.disposeAgentForRebuild(p.sessionId);
+		},
+		"sessions.setEffort": (p) => patchSessionMeta(p.sessionId, { effort: p.effort }),
+		"sessions.setModel": async (p) => {
+			const chainPatch = p.fallbacks === void 0 ? {} : { modelChain: modelChainMetadata(p.providerKey, p.modelId, p.fallbacks) };
+			await patchSessionMeta(p.sessionId, {
+				providerKey: p.providerKey,
+				modelId: p.modelId,
+				...chainPatch
+			});
+			host.disposeAgentForRebuild(p.sessionId);
+		},
+		"sessions.setModelOptions": (p) => patchSessionMeta(p.sessionId, { modelOptions: p.options }),
+		"sessions.loadEvents": async (p) => {
+			const data = await loadOrThrow(p.sessionId);
+			return eventsFromTurns(data.turns, data.runs);
+		},
+		"sessions.getTurn": async (p) => {
+			return (await store.load(p.sessionId))?.turns.find((t) => t.id === p.turnId) ?? null;
+		},
+		"sessions.contextBreakdown": (p) => host.getContextBreakdown(p.sessionId),
+		"history.searchSession": async (p) => {
+			const index = await sessionSearchIndex(p.sessionId);
+			if (!index) return [];
+			const limit = Number.isInteger(p.limit) && p.limit > 0 ? Math.min(p.limit, index.turns.length) : index.turns.length;
+			const matches = await searchSessionIndexAsync(index, p.query, { limit });
+			const order = new Map(index.turns.map((entry, i) => [entry.turn.id, i]));
+			matches.sort((a, b) => (order.get(a.turn.id) ?? 0) - (order.get(b.turn.id) ?? 0));
+			return matches;
+		},
+		"history.searchAll": async (p, peer) => {
+			const generation = (searchGenerations.get(peer) ?? 0) + 1;
+			searchGenerations.set(peer, generation);
+			const results = {};
+			const ids = Array.isArray(p.sessionIds) ? p.sessionIds.slice(0, 500) : [];
+			for (const sessionId of ids) {
+				if (searchGenerations.get(peer) !== generation) break;
+				try {
+					const index = await sessionSearchIndex(sessionId);
+					if (!index) continue;
+					const match = await searchSessionHistoryIndexAsync(index, p.query, p.excerptLimit ?? 3);
+					if (match) results[sessionId] = match;
+				} catch {}
+			}
+			return results;
+		},
+		"sessions.touch": (p) => {
+			broadcast({
+				kind: "sessions:changed",
+				op: "update",
+				sessionId: p.sessionId
+			});
+		},
+		"sessions.compact": (p) => host.compactSessionNow(p.sessionId),
+		"todos.get": (p) => {
+			const state = host.getTodosSnapshot(p.sessionId);
+			return state ? toTodosSnapshot(state) : null;
+		},
+		"todos.set": async (p) => {
+			const state = await host.setTodos(p.sessionId, p.items);
+			return state ? toTodosSnapshot(state) : null;
+		},
+		"orchestration.main": () => host.orchestration.ensureMain(),
+		"orchestration.createWorker": ({ mainId, ...params }) => host.orchestration.createWorker(mainId, params),
+		"orchestration.list": (p) => host.orchestration.list(p.mainId, p.limit),
+		"orchestration.read": async (p) => await host.orchestration.canOrchestrate(p.mainId, p.sessionId) ? host.orchestration.read(p.sessionId) : null,
+		"orchestration.send": (p) => host.orchestration.send(p.mainId, p.sessionId, p.prompt, p.wake),
+		"orchestration.steer": (p) => host.orchestration.steer(p.mainId, p.sessionId, p.message),
+		"orchestration.cancel": (p) => host.orchestration.cancel(p.mainId, p.sessionId),
+		"orchestration.transcript": (p) => host.orchestration.transcript(p.mainId, p.sessionId, p.limit),
+		"interactions.list": (p) => host.interactions.list(p?.sessionId),
+		"interactions.respond": (p) => host.interactions.respond(p.requestId, p.response),
+		"interactions.cancel": (p) => host.interactions.cancel(p.requestId, p.reason),
+		"interactions.rehydrate": (p) => host.interactions.rehydrate(p.sessionId),
+		"approvals.resolve": (p) => host.approvals.resolve(p.requestId, p.decision),
+		"approvals.denyAll": (p) => host.approvals.denyAll(p?.sessionId),
+		"approvals.listPending": () => host.approvals.listPending(),
+		"settings.get": () => env.readSettings(),
+		"settings.set": (p) => {
+			const before = env.readSettings();
+			const next = env.writeSettings(p.patch);
+			const changed = (key) => JSON.stringify(before[key]) !== JSON.stringify(next[key]);
+			if (changed("enabledExtensions") || changed("loadProjectExtensions")) {
+				env.invalidateRuntime();
+				host.shutdown();
+			} else if (changed("enabledMcps") || changed("disabledMcpTools") || changed("enabledSkills") || changed("enabledPlugins") || changed("importForeignConfigs") || changed("importRulerConfigs")) host.shutdown();
+			if (changed("interactionMode") && next.interactionMode === "skip") host.interactions.resolveAutomatically();
+			broadcast({
+				kind: "settings:changed",
+				settings: next
+			});
+			return next;
+		},
+		"presence.list": () => computePresence(),
+		"presence.watch": (p, peer) => {
+			peer.watching = p.sessionId;
+			broadcastPresence();
+			store.load(p.sessionId).then((data) => {
+				if (!data) return;
+				const meta = data.metadata ?? {};
+				const cwd = typeof meta.cwd === "string" ? meta.cwd : data.projectRoot ?? "";
+				return env.runtimeConfig(cwd);
+			}).catch(() => void 0);
+		},
+		"daemon.info": () => ({
+			protocolVersion: 8,
+			appVersion,
+			pid: process.pid,
+			startedAt
+		}),
+		"daemon.shutdown": async () => {
+			setImmediate(() => {
+				close().then(() => options.onIdle?.());
+			});
+		}
+	};
+	let idleTimer;
+	function armIdleTimer() {
+		if (!options.idleShutdownMs || !options.onIdle) return;
+		clearTimeout(idleTimer);
+		idleTimer = setTimeout(() => {
+			if (peers.size > 0) return;
+			if (host.hasActiveWork()) {
+				armIdleTimer();
+				return;
+			}
+			options.onIdle?.();
+		}, options.idleShutdownMs);
+	}
+	function handleConnection(socket) {
+		const peer = {
+			socket,
+			connection: void 0,
+			ready: false,
+			watching: null
+		};
+		const connection = createJsonRpcConnection({
+			input: socket,
+			output: socket,
+			onRequest: async (message) => {
+				if (message.method === "ipc.hello") {
+					const params = message.params ?? {};
+					const clientBuild = Number(params.buildId);
+					const daemonBuild = Number(IPC_BUILD_ID);
+					const staleBuild = params.buildId !== void 0 && params.buildId !== "unknown" && IPC_BUILD_ID !== "unknown" && Number.isFinite(clientBuild) && Number.isFinite(daemonBuild) && clientBuild > daemonBuild;
+					if (params.protocolVersion !== 8 || staleBuild) return errorResponse(message.id, IpcErrorCode.VersionMismatch, staleBuild ? `Build mismatch: the daemon was started from an older build (daemon ${IPC_BUILD_ID}, client ${params.buildId}). Draining for respawn.` : `Protocol version mismatch: daemon speaks v8, client sent v${params.protocolVersion ?? "?"}.`, { daemon: {
+						protocolVersion: 8,
+						appVersion,
+						pid: process.pid,
+						startedAt,
+						buildId: IPC_BUILD_ID
+					} });
+					peer.ready = true;
+					const result = {
+						protocolVersion: 8,
+						appVersion,
+						pid: process.pid,
+						startedAt,
+						buildId: IPC_BUILD_ID
+					};
+					return successResponse(message.id, result);
+				}
+				if (!peer.ready && message.method !== "daemon.shutdown" && message.method !== "daemon.info") return errorResponse(message.id, IpcErrorCode.NotHandshaken, "Handshake required: send ipc.hello first.");
+				const handler = methods[message.method];
+				if (!handler) return errorResponse(message.id, -32601, `Unknown method "${message.method}".`);
+				try {
+					const result = await handler(message.params, peer);
+					return successResponse(message.id, result ?? null);
+				} catch (err) {
+					return errorResponse(message.id, -32e3, err instanceof Error ? err.message : String(err));
+				}
+			},
+			onNotification: async (message) => {
+				if (!peer.ready) return;
+				const handler = methods[message.method];
+				if (!handler) return;
+				try {
+					await handler(message.params, peer);
+				} catch {}
+			},
+			onError: (err) => log(`[ipc-daemon] peer error: ${err.message}`)
+		});
+		peer.connection = connection;
+		peers.add(peer);
+		connection.start();
+		log(`[ipc-daemon] peer connected (${peers.size} total)`);
+		const drop = () => {
+			if (!peers.delete(peer)) return;
+			connection.close();
+			log(`[ipc-daemon] peer disconnected (${peers.size} left)`);
+			if (peer.watching) broadcastPresence();
+			if (peers.size === 0) armIdleTimer();
+		};
+		socket.on("close", drop);
+		socket.on("error", drop);
+	}
+	if (existsSync(socketPath)) {
+		if (await probeSocket(socketPath)) throw new Error(`A zidane daemon is already listening on ${socketPath}.`);
+		if (await probeSocket(socketPath)) throw new Error(`A zidane daemon is already listening on ${socketPath}.`);
+		unlinkSync(socketPath);
+	}
+	const socketDir = dirname(socketPath);
+	const dedicatedSocketDir = basename(socketDir) === "daemon" || !existsSync(socketDir);
+	mkdirSync(socketDir, {
+		recursive: true,
+		mode: 448
+	});
+	if (dedicatedSocketDir) try {
+		chmodSync(socketDir, 448);
+	} catch {}
+	const server = createServer(handleConnection);
+	await new Promise((resolvePromise, reject) => {
+		server.once("error", reject);
+		server.listen(socketPath, () => {
+			server.off("error", reject);
+			resolvePromise();
+		});
+	});
+	try {
+		chmodSync(socketPath, 384);
+	} catch {}
+	log(`[ipc-daemon] listening on ${socketPath}`);
+	let ownsSocketFile = true;
+	armIdleTimer();
+	const legacyPath = legacySocketPath(socketPath);
+	if (legacyPath) (async () => {
+		if (!await probeSocket(legacyPath)) return;
+		log(`[ipc-daemon] draining legacy daemon on ${legacyPath}`);
+		try {
+			const survivor = await connectIpcClient({
+				socketPath: legacyPath,
+				appVersion: `${appVersion}/legacy-drain`,
+				drainOnMismatch: true
+			});
+			await survivor.request("daemon.shutdown", {}).catch(() => void 0);
+			survivor.close();
+		} catch {}
+	})();
+	async function doClose() {
+		clearTimeout(idleTimer);
+		host.shutdown();
+		for (const peer of peers) {
+			peer.connection.close();
+			peer.socket.destroy();
+		}
+		peers.clear();
+		await new Promise((resolvePromise) => {
+			server.close(() => resolvePromise());
+		});
+		if (ownsSocketFile) {
+			ownsSocketFile = false;
+			try {
+				unlinkSync(socketPath);
+			} catch {}
+		}
+	}
+	let closePromise = null;
+	function close() {
+		closePromise ??= doClose();
+		return closePromise;
+	}
+	return {
+		socketPath,
+		host,
+		peerCount: () => peers.size,
+		close
+	};
+}
+//#endregion
+export { connectIpcClient as a, IpcErrorCode as c, ensureDaemonRunning as d, probeSocket as f, IpcVersionMismatchError as i, IPC_BUILD_ID as l, createDaemonEnvironment as n, connectOrSpawnDaemon as o, selfDaemonSpawnCommand as p, createFileApprovalsStore as r, IPC_PROTOCOL_VERSION as s, startIpcDaemon as t, defaultSocketPath as u };
+
+//# sourceMappingURL=server-DJqp9dIR.js.map