zidane 7.2.5 → 8.0.4

package/dist/shell-path-DfdXrGg9.js

@@ -1,1549 +0,0 @@
-import { Fn as serializedPayloadBytes, Pn as createExtensionBus, ct as discoverAndBuildExtensionRegistry, st as createExtensionHud, vt as createExtensionHostRuntimeBridge } from "./agent-D0zZnGbt.js";
-import { S as resolveInlineSuggestion, b as createPathAutocompleteProvider } from "./src-CkNQKFKr.js";
-import { l as normalizeArtifactInput } from "./artifacts-CV2hUKnL.js";
-import { t as writeFileAtomic } from "./atomic-write-B7zr1ddF.js";
-import { p as resolveStorageDirs } from "./plugins-gbI7SBA6.js";
-import { a as successResponse, i as errorResponse, n as JsonRpcRemoteError, r as createJsonRpcConnection } from "./json-rpc-rSWMUh9b.js";
-import { Vt as isMainSession } from "./turn-operations-DrbJlpq9.js";
-import { c as searchSessionHistoryIndexAsync, n as buildSessionSearchIndexAsync, u as searchSessionIndexAsync } from "./history-search-C4bk1Wz_.js";
-import { Bn as resolveConfig, Di as deriveSessionTitle, Ft as toTodosSnapshot, Jt as createFileMcpCredentialStore, Kt as sessionModelFallbacks, Oi as eventsFromTurns, Pt as createChatHost, fn as DEFAULT_SETTINGS, gn as SETTINGS_TOGGLES, yn as enforceSettingsInvariants } from "./approvals-DKaJZYlm.js";
-import { h as BUILTIN_PROVIDERS, n as applyApiKeyEnv, r as credentialsPath } from "./auth-BG2rVKSt.js";
-import { basename, delimiter, dirname, join } from "node:path";
-import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync } from "node:fs";
-import { userInfo } from "node:os";
-import { spawn, spawnSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import { connect, createServer } from "node:net";
-import process$1 from "node:process";
-//#endregion
-//#region src/version.ts
-/**
-* The version of the zidane code this process is running — `package.json`
-* inlined at build time (Bun `--compile`, tsdown for `dist/`, and Vite for
-* the GUI main all fold JSON imports into the bundle, so this never reads
-* the filesystem at runtime and cannot report a NEIGHBOUR package's version
-* the way a `require('../package.json')` from a bundled chunk can).
-*
-* Used by the daemon handshake: a client running newer code than the daemon
-* retires it, so an upgrade can never leave windows silently executing on a
-* process started from the previous release.
-*/
-const ZIDANE_VERSION = "7.2.5";
-/**
-* Compare two dotted versions (`7.0.19`, `7.1.0-beta.1`): negative when `a`
-* is older, positive when newer, 0 when equal. Pre-release tags are ignored
-* — same release train, same code as far as the daemon fence is concerned.
-* Unparseable input compares equal (never fences on garbage).
-*/
-function compareVersions(a, b) {
-	const pa = parse(a);
-	const pb = parse(b);
-	if (!pa || !pb) return 0;
-	for (let i = 0; i < 3; i++) {
-		const d = (pa[i] ?? 0) - (pb[i] ?? 0);
-		if (d !== 0) return d;
-	}
-	return 0;
-}
-function parse(v) {
-	const m = /^v?(\d+)\.(\d+)\.(\d+)/.exec(v.trim());
-	return m ? [
-		Number(m[1]),
-		Number(m[2]),
-		Number(m[3])
-	] : null;
-}
-//#endregion
-//#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";
-	}
-})();
-/**
-* Socket file name. Dev builds (`ZIDANE_DEV=1`, set by every `dev` script
-* in the repo) get their OWN socket so a checkout's TUI, GUI and `zidane
-* daemon` pair up among themselves and never attach to — or get refused by
-* — the installed daemon. Without this, a protocol bump in the working
-* tree turned the dev GUI's dot red against the stable daemon, and a dev
-* daemon could drain the one the installed TUI relies on.
-*/
-function daemonSocketName(env = process.env) {
-	return env.ZIDANE_DEV && env.ZIDANE_DEV !== "0" ? "dev.sock" : "daemon.sock";
-}
-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", daemonSocketName());
-}
-/**
-* 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`.
-*/
-const pendingStarts = /* @__PURE__ */ new Map();
-function ensureDaemonRunning(options = {}) {
-	const socketPath = options.socketPath ?? defaultSocketPath();
-	const pending = pendingStarts.get(socketPath);
-	if (pending) return pending;
-	const start = startDaemon({
-		...options,
-		socketPath
-	}).finally(() => pendingStarts.delete(socketPath));
-	pendingStarts.set(socketPath, start);
-	return start;
-}
-async function startDaemon(options) {
-	const socketPath = options.socketPath;
-	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. It also accepts `effort` / `modelOptions` and resets
-*     both when omitted (a pick is atomic — no stale per-model knobs).
-*   - 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.
-*   - ADDITIVE (no version bump — `optional()` swallows "method not
-*     found" on an older daemon, which then simply keeps its stale
-*     registries as before): `runtime.reload` RPC drops the daemon's
-*     cached extension registries and retires live agents after a window
-*     reloaded its extensions.
-*/
-const IPC_PROTOCOL_VERSION = 9;
-/**
-* 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
-function daemonRelease(hello) {
-	for (const value of [hello.codeVersion, hello.appVersion]) {
-		if (typeof value !== "string") continue;
-		const match = /^(?:zidane-gui\/)?(v?\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?)$/.exec(value.trim());
-		if (match) return match[1];
-	}
-}
-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: 9,
-			appVersion: options.appVersion ?? "dev",
-			pid: process.pid,
-			buildId: options.drainOnMismatch === false ? "unknown" : IPC_BUILD_ID,
-			codeVersion: ZIDANE_VERSION
-		}), 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) {
-			const daemon = err.data?.daemon;
-			const daemonIsOlderRelease = typeof daemon?.codeVersion === "string" && compareVersions(daemon.codeVersion, ZIDANE_VERSION) < 0;
-			const release = daemon && daemonRelease(daemon);
-			if (!(release !== void 0 && compareVersions(release, ZIDANE_VERSION) > 0) && (options.drainOnMismatch !== false || daemonIsOlderRelease)) await Promise.race([connection.sendRequest("daemon.shutdown", {}).catch(() => void 0), new Promise((resolve) => setTimeout(resolve, 1500))]);
-			close();
-			throw new IpcVersionMismatchError(err.message, daemon);
-		}
-		close();
-		throw err;
-	} finally {
-		clearTimeout(helloTimer);
-	}
-	const release = daemonRelease(hello);
-	if (release !== void 0 && compareVersions(release, ZIDANE_VERSION) < 0) {
-		close();
-		throw new IpcVersionMismatchError(`Daemon release ${release} is older than client ${ZIDANE_VERSION}. Restart the daemon when active runs have finished.`, hello);
-	}
-	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();
-	const hostRuntime = createExtensionHostRuntimeBridge();
-	/**
-	* 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,
-					hostRuntime,
-					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,
-		hostRuntime,
-		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;
-	/** Wire-supplied limit → sane positive integer capped at 1000, else `undefined` (no limit). */
-	function boundedLimit(raw) {
-		return Number.isInteger(raw) && raw > 0 ? Math.min(raw, 1e3) : void 0;
-	}
-	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 = {}) {
-		await host.patchSessionMeta(sessionId, patch, opts);
-		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 asCommand = typeof p.asCommand === "string" ? p.asCommand.slice(0, 128) : void 0;
-			const result = await host.queueAdd(p.sessionId, text, activatedSkills, attachments, asCommand);
-			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.update": (p) => host.queueUpdate(p.sessionId, p.id, typeof p.text === "string" ? p.text.slice(0, 64 * 1024) : ""),
-		"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),
-		"runtime.reload": () => {
-			env.invalidateRuntime();
-			host.rebuildAllAgents();
-		},
-		"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) => {
-			await host.setSessionModel(p.sessionId, {
-				providerKey: p.providerKey,
-				modelId: p.modelId,
-				...p.fallbacks ? { fallbacks: p.fallbacks } : {},
-				...p.effort ? { effort: p.effort } : {},
-				...p.modelOptions ? { modelOptions: p.modelOptions } : {}
-			});
-			broadcast({
-				kind: "sessions:changed",
-				op: "update",
-				sessionId: 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),
-		"sessions.artifacts": async (p) => {
-			if (!store.listArtifacts) return [];
-			return store.listArtifacts({
-				sessionId: p.sessionId,
-				...typeof p.kind === "string" ? { kind: p.kind } : {},
-				...boundedLimit(p.limit) !== void 0 ? { limit: boundedLimit(p.limit) } : {}
-			});
-		},
-		"artifacts.list": async (p) => {
-			if (!store.listArtifacts) return [];
-			return store.listArtifacts({
-				...p.projectRoot === null || typeof p.projectRoot === "string" ? { projectRoot: p.projectRoot } : {},
-				...typeof p.kind === "string" ? { kind: p.kind } : {},
-				...typeof p.uri === "string" ? { uri: p.uri } : {},
-				...typeof p.since === "number" && Number.isFinite(p.since) ? { since: p.since } : {},
-				...boundedLimit(p.limit) !== void 0 ? { limit: boundedLimit(p.limit) } : {}
-			});
-		},
-		"artifacts.delete": async (p) => {
-			if (!store.deleteArtifact) return false;
-			await store.deleteArtifact(p.sessionId, p.artifactId);
-			broadcast({
-				kind: "artifact:changed",
-				sessionId: p.sessionId,
-				op: "delete",
-				artifactId: p.artifactId
-			});
-			return true;
-		},
-		"artifacts.upsert": async (p) => {
-			if (!store.upsertArtifact) return null;
-			const normalized = normalizeArtifactInput(p.artifact);
-			if (!normalized || typeof p.artifact?.sessionId !== "string" || typeof p.artifact?.id !== "string") return null;
-			const now = Date.now();
-			const stored = await store.upsertArtifact({
-				...normalized,
-				id: p.artifact.id,
-				sessionId: p.artifact.sessionId,
-				...typeof p.artifact.runId === "string" ? { runId: p.artifact.runId } : {},
-				...typeof p.artifact.turnId === "string" ? { turnId: p.artifact.turnId } : {},
-				createdAt: typeof p.artifact.createdAt === "number" ? p.artifact.createdAt : now,
-				updatedAt: now
-			});
-			if (stored) broadcast({
-				kind: "artifact:changed",
-				sessionId: stored.sessionId,
-				op: "upsert",
-				artifactId: stored.id,
-				artifact: stored
-			});
-			return stored;
-		},
-		"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: 9,
-			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;
-					const staleRelease = typeof params.codeVersion === "string" && compareVersions(params.codeVersion, ZIDANE_VERSION) > 0;
-					if (params.protocolVersion !== 9 || staleBuild || staleRelease) return errorResponse(message.id, IpcErrorCode.VersionMismatch, staleRelease ? `Stale daemon: it runs zidane ${ZIDANE_VERSION} but the client runs ${params.codeVersion}. Draining for respawn.` : 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 v9, client sent v${params.protocolVersion ?? "?"}.`, { daemon: {
-						protocolVersion: 9,
-						appVersion,
-						pid: process.pid,
-						startedAt,
-						buildId: IPC_BUILD_ID,
-						codeVersion: ZIDANE_VERSION
-					} });
-					peer.ready = true;
-					const result = {
-						protocolVersion: 9,
-						appVersion,
-						pid: process.pid,
-						startedAt,
-						buildId: IPC_BUILD_ID,
-						codeVersion: ZIDANE_VERSION
-					};
-					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);
-		await host.drain();
-		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
-//#region src/ipc/daemon/shell-path.ts
-/**
-* Login-shell PATH for processes not started from a terminal.
-*
-* A Dock/Finder-launched GUI, or a daemon it spawns, inherits launchd's PATH
-* (`/usr/bin:/bin:/usr/sbin:/sbin`), so `node` / `bun` / `yarn` are invisible
-* to agent shell commands. Ask the user's login shell for its PATH and merge
-* it into `process.env.PATH`.
-*
-* Merge, don't replace: a terminal launch may have prepended entries the rc
-* files know nothing about (`nvm use`, direnv, `PATH=... zidane`), and those
-* must survive. Idempotent, so every surface (GUI, daemon) can call it and a
-* daemon spawned by an already-fixed GUI ends up with the same PATH.
-*/
-const DELIMITER = "_ZIDANE_SHELL_ENV_";
-/** A slow rc file costs startup time; a prompting one must never hang the process. */
-const DEFAULT_TIMEOUT_MS = 3e3;
-function defaultShell(env) {
-	try {
-		const { shell } = userInfo();
-		if (shell) return shell;
-	} catch {}
-	return env.SHELL || (process$1.platform === "darwin" ? "/bin/zsh" : "/bin/sh");
-}
-function parsePath(stdout) {
-	const body = stdout.split(DELIMITER)[1];
-	if (body === void 0) return void 0;
-	const clean = body.replace(/\u001B\[[0-9;]*[A-Z]/gi, "");
-	for (const line of clean.split("\n")) if (line.startsWith("PATH=")) return line.slice(5) || void 0;
-}
-/**
-* PATH as seen by an interactive login shell, or `undefined` when no shell
-* answers in time. Tries the user's shell first, then POSIX fallbacks for
-* non-POSIX defaults (nushell, xonsh) whose `-ilc` differs. An explicit
-* `shell` is tried alone.
-*/
-function shellPath(options = {}) {
-	if (process$1.platform === "win32") return void 0;
-	const env = options.env ?? process$1.env;
-	const timeout = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-	const shells = options.shell ? [options.shell] : [.../* @__PURE__ */ new Set([
-		defaultShell(env),
-		"/bin/zsh",
-		"/bin/bash"
-	])];
-	for (const shell of shells) {
-		const result = spawnSync(shell, ["-ilc", `echo -n "${DELIMITER}"; command env; echo -n "${DELIMITER}"; exit`], {
-			encoding: "utf8",
-			timeout,
-			stdio: [
-				"ignore",
-				"pipe",
-				"ignore"
-			],
-			env: {
-				...env,
-				DISABLE_AUTO_UPDATE: "true",
-				ZSH_TMUX_AUTOSTARTED: "true",
-				ZSH_TMUX_AUTOSTART: "false"
-			}
-		});
-		if (result.error || result.status !== 0) continue;
-		const path = parsePath(result.stdout);
-		if (path) return path;
-	}
-}
-/**
-* Entries of `current` the shell doesn't know about (ad-hoc prepends from the
-* launching terminal) stay in front; then the shell's PATH in its own order.
-* From the Dock every launchd entry is already in the shell PATH, so the
-* result is exactly the shell PATH, with the shell's precedence intact.
-*/
-function mergePath(current, shell) {
-	const split = (path) => (path ?? "").split(delimiter).filter(Boolean);
-	const fromShell = split(shell);
-	const known = new Set(fromShell);
-	return [.../* @__PURE__ */ new Set([...split(current).filter((entry) => !known.has(entry)), ...fromShell])].join(delimiter);
-}
-/** Merge the login shell's PATH into `process.env.PATH`. No-op on Windows or when no shell answers. */
-function fixPath() {
-	const extra = shellPath();
-	if (extra) process$1.env.PATH = mergePath(process$1.env.PATH, extra);
-}
-//#endregion
-export { selfDaemonSpawnCommand as _, createDaemonEnvironment as a, connectIpcClient as c, IpcErrorCode as d, IPC_BUILD_ID as f, probeSocket as g, ensureDaemonRunning as h, startIpcDaemon as i, connectOrSpawnDaemon as l, defaultSocketPath as m, mergePath as n, createFileApprovalsStore as o, daemonSocketName as p, shellPath as r, IpcVersionMismatchError as s, fixPath as t, IPC_PROTOCOL_VERSION as u };
-
-//# sourceMappingURL=shell-path-DfdXrGg9.js.map