zidane 7.2.4 → 8.0.4

package/dist/dispatcher-BMlu2BmZ.js

@@ -0,0 +1,4941 @@
+import { Mn as createExtensionBus, Nn as serializedPayloadBytes, Tt as createExtensionHostRuntimeBridge, at as ExtensionInstallError, bt as filterRegistryPlugins, dt as removeInstalledExtension, ft as updateInstalledExtension, mt as discoverAndBuildExtensionRegistry, pt as createExtensionHud, st as installExtensionFromSpec } from "./agent-DSLNmBp0.js";
+import { d as abortableInstallIo, o as installSkillFromSpec } from "./skills-DKqZJm4X.js";
+import { l as normalizeArtifactInput } from "./artifacts-CV2hUKnL.js";
+import { t as projectUserPaths } from "./project-user-paths-BSgtrRxl.js";
+import { i as writeJsonFileAtomic, n as writeFileAtomic, t as OWNER_ONLY } from "./atomic-write-Ijgf2Mhc.js";
+import { c as setExtensionSessionState, o as loadSession, r as deleteExtensionSessionState } from "./session-xh9JXu6i.js";
+import { a as loginMcpServer, c as resolveInlineSuggestion, s as createPathAutocompleteProvider } from "./src-BRMYRJib.js";
+import { a as canSignInRemotely } from "./xai-CvJTeLrI.js";
+import { a as errorResponse, r as createJsonRpcConnection } from "./json-rpc--HXQti1E.js";
+import { M as selectActiveTodos, N as setTodosForRun, c as sessionModelFallbacks, i as describeForkFailure } from "./session-factory-BUGY5P40.js";
+import { $t as MachineErrorCode, X as enabledMcpsWith, Yt as remoteHostsGate, Z as enabledMcpsWithout, in as toMachineName } from "./tool-formatters-IQFDrdrs.js";
+import { c as isMainSession } from "./orchestration-BCGmB8Ps.js";
+import { a as KNOWN_TOKEN, c as looksLikeSecret, o as isSecretName, s as isSecretPathSegment, u as DEFAULT_SETTINGS } from "./url-D8HCl65b.js";
+import { $ as getSessionMeta, B as parseMcpsFile, Ot as readProjects, P as userSystemMdPath, Q as getSessionHeader, R as discoverProjectMcps, X as deriveSessionTitle, Z as eventsFromTurns, _ as enforceSettingsInvariants, dt as sumRunCosts, et as headerFromData, jt as writeProjects, kt as safelistProjectKey, lt as sessionEnvironmentSummary, mt as toolResultText, nt as listSessionMeta, ot as replayTurns, p as SETTINGS_TOGGLES, s as isWindowOnlySetting, tt as lastContextSizeFromTurns } from "./registry-D6ShBWJU.js";
+import { Jt as createChatHost, Qt as createFileMcpCredentialStore, Tr as createMemoryApprovalsStore, X as createExtensionMcpHost, Xn as insideDeclaredRoots, Yn as machineDiscoveryCwd, _n as pinnedSkillsValue, _t as removeMcpServer, bn as toTodosSnapshot, fr as scopeCwd, gn as PINNED_SKILLS_META_KEY, gt as mcpsWritePath, hn as normalizeLaunchOverrides, j as runOAuthLogin, mr as discoverProjectPlugins, nn as applyEnvironmentSettingsChange, ot as resolveConfig, pn as isInside, pr as buildPluginContributions, vn as readPinnedSkills, vt as upsertMcpServer, zn as discoverProjectSkills } from "./chat-JPJJ8uu5.js";
+import { c as searchSessionHistoryIndexAsync, n as buildSessionSearchIndexAsync, u as searchSessionIndexAsync } from "./history-search-CcYzF8-0.js";
+import { c as removeProviderCredential, f as setProviderCredential, g as BUILTIN_PROVIDERS, l as removeStoredCredential, n as credentialsPath, s as readProviderCredentials, t as applyApiKeyEnv } from "./credentials-JttEuRON.js";
+import { r as detectAuth } from "./cli-shared-C-YCaglL.js";
+import { c as settingField, h as METHOD_NOT_FOUND, n as SYNC_CATEGORIES, o as SYSTEM_MD_FIELD } from "./types-CH5XpIHw.js";
+import { C as IPC_BUILD_ID, E as ensureDaemonRunning, O as probeSocket, S as compareVersions, a as createSignalListeners, c as IpcErrorCode, f as REDACTED, i as IpcVersionMismatchError, l as LOAD_EVENTS_MAX_PAGE_TURNS, n as hashValue, o as openIpcClient, p as SESSION_TURNS_MAX_PAGE, r as isRecord, t as isSyncableSetting, x as ZIDANE_VERSION } from "./settings-keys-Ckf29NeM.js";
+import { Buffer } from "node:buffer";
+import { accessSync, constants, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { basename, delimiter, dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
+import { homedir, hostname } from "node:os";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { connect } from "node:net";
+import process$1 from "node:process";
+//#region src/ipc/transports/paced-writer.ts
+/** Largest slice handed to the socket at once. */
+const SLICE_BYTES = 65536;
+function createPacedWriter(stream) {
+	const queue = [];
+	let queuedBytes = 0;
+	let waiting = false;
+	const pump = () => {
+		waiting = false;
+		while (queue.length > 0) {
+			if (stream.destroyed || stream.writableEnded) {
+				queue.length = 0;
+				queuedBytes = 0;
+				return;
+			}
+			const head = queue[0];
+			const slice = head.length > SLICE_BYTES ? head.subarray(0, SLICE_BYTES) : head;
+			if (slice === head) queue.shift();
+			else queue[0] = head.subarray(SLICE_BYTES);
+			queuedBytes -= slice.length;
+			if (!stream.write(slice)) {
+				waiting = true;
+				stream.once("drain", pump);
+				return;
+			}
+		}
+	};
+	return {
+		write(text) {
+			const bytes = Buffer.from(text);
+			queue.push(bytes);
+			queuedBytes += bytes.length;
+			if (!waiting) pump();
+		},
+		buffered: () => queuedBytes + stream.writableLength
+	};
+}
+//#endregion
+//#region src/ipc/client.ts
+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 signals = createSignalListeners();
+	let closed = false;
+	const writer = createPacedWriter(socket);
+	const connection = createJsonRpcConnection({
+		input: socket,
+		output: socket,
+		send: (json) => writer.write(`${json}\n`),
+		onRequest: (message) => errorResponse(message.id, METHOD_NOT_FOUND, "Clients do not accept requests."),
+		onNotification: signals.onNotification
+	});
+	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 passive = options.drainOnMismatch === false;
+	return openIpcClient({
+		rpc: connection,
+		close,
+		abort: () => socket.destroy(),
+		where: options.socketPath
+	}, signals.listeners, {
+		...options.appVersion ? { appVersion: options.appVersion } : {},
+		drain: passive ? "stale-only" : "always",
+		buildFence: !passive
+	});
+}
+/**
+* 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;
+		}
+		writeJsonFileAtomic(path, rows, OWNER_ONLY);
+	}
+	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();
+		}
+	};
+}
+/** The daemon's environment: its own config, per-cwd extension discovery, multi-process. */
+function createDaemonEnvironment(options) {
+	return createHostEnvironment(options);
+}
+/**
+* Disk-backed host environment: the daemon's, or (with `shared`) a host
+* sharing the window's process and setup.
+*/
+async function createHostEnvironment(options) {
+	const { shared } = options;
+	const config = shared?.config ?? await resolveOwnConfig(options.cwd);
+	const store = config.store;
+	if (!shared && config.paths.projectDir) process.stderr.write(`[zidane-daemon] warning: project-DB mode is on, so this daemon uses ${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 userDataDir = () => config.paths.userDir;
+	const applyAuthEnv = () => {
+		const dir = userDataDir();
+		process.env.ZIDANE_CREDENTIALS_PATH = credentialsPath(dir);
+		applyApiKeyEnv(dir, shared ? config.providers : BUILTIN_PROVIDERS);
+	};
+	const base = {
+		multiProcess: shared ? shared.multiProcess === true : true,
+		broadcast: options.broadcast,
+		store,
+		readSettings,
+		writeSettings,
+		userDataDir,
+		applyAuthEnv,
+		mcpCredentialStore: () => createFileMcpCredentialStore(userDataDir()),
+		approvalsPersistence: shared ? createMemoryApprovalsStore() : createFileApprovalsStore(join(dirname(config.paths.state), "pending-approvals.json")),
+		...options.debugStream !== void 0 ? { debugStream: options.debugStream } : {},
+		config
+	};
+	if (shared) {
+		const { resolve, invalidate, forget } = shared.runtimeConfig;
+		return {
+			...base,
+			cacheDir: () => config.paths.cacheDir,
+			runtimeConfig: resolve,
+			...shared.hostRuntime ? { hostRuntime: shared.hostRuntime } : {},
+			...shared.extensionBus ? { extensionBus: shared.extensionBus } : {},
+			...shared.instrumentAgent ? { instrumentAgent: shared.instrumentAgent } : {},
+			...shared.terminals !== void 0 ? { terminals: shared.terminals } : {},
+			invalidateRuntime: () => invalidate?.(),
+			forgetRuntime: () => forget?.() ?? (() => void 0)
+		};
+	}
+	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();
+	const mcpHost = createExtensionMcpHost({
+		prefix: config.prefix,
+		readSettings,
+		credentialStore: () => createFileMcpCredentialStore(userDataDir())
+	});
+	/**
+	* 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 () => {
+			const extensionRegistry = await discoverAndBuildExtensionRegistry({
+				cwd,
+				hud,
+				bus: extensionBus,
+				hostRuntime,
+				mcp: mcpHost,
+				prefix: config.prefix,
+				...settings.enabledExtensions !== void 0 ? { enabledAllowlist: [...settings.enabledExtensions] } : {},
+				trustProjectExtensions: settings.loadProjectExtensions === true,
+				readSettings
+			});
+			return resolveConfig({
+				cwd,
+				extensionRegistry,
+				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;
+	};
+	return {
+		...base,
+		runtimeConfig,
+		hostRuntime,
+		invalidateRuntime: () => {
+			for (const entry of runtimeCache.values()) disposeRuntime(entry);
+			runtimeCache.clear();
+		},
+		forgetRuntime: () => {
+			const dropped = [...runtimeCache.values()];
+			runtimeCache.clear();
+			return () => {
+				for (const entry of dropped) disposeRuntime(entry);
+			};
+		},
+		extensionBus
+	};
+}
+/** The daemon's own boot config: paths + store + state, from `cwd`. */
+async function resolveOwnConfig(cwd) {
+	const { createTuiStore } = await import("./session/sqlite.js");
+	return resolveConfig({
+		...cwd !== void 0 ? { cwd } : {},
+		store: (resolved) => createTuiStore(resolved.db)
+	});
+}
+//#endregion
+//#region src/ipc/daemon/handlers/params.ts
+/**
+* Shape checks for request params: they arrive as untrusted JSON (the
+* `IpcMethods` types are not a runtime guarantee). The dispatcher runs
+* {@link checkParams} on every request and notification before its handler;
+* handlers use the field checks for what they require. A failed check is an
+* {@link InvalidParamsError}, answered as JSON-RPC "invalid params".
+*/
+var InvalidParamsError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "InvalidParamsError";
+	}
+};
+/** Longest session id accepted (minted ids are under 64 characters). */
+const MAX_SESSION_ID_LENGTH = 1024;
+/**
+* A session id: a non-empty string that is one plain path segment. Ids name
+* directories on disk (`<data dir>/sessions/<id>/`, removed recursively on
+* delete), so `..`, separators and NUL are refused.
+*/
+function checkSessionId(value, name = "sessionId") {
+	if (typeof value !== "string" || value.length === 0 || value.length > MAX_SESSION_ID_LENGTH) throw new InvalidParamsError(`${name} must be a non-empty string of at most ${MAX_SESSION_ID_LENGTH} characters.`);
+	if (value === "." || value === ".." || /[/\\\0]/.test(value)) throw new InvalidParamsError(`${name} must not be a path (no "/", "\\", "." or "..").`);
+	return value;
+}
+/** The required `sessionId` of `params`. */
+function sessionIdOf(params) {
+	return checkSessionId(params?.sessionId);
+}
+/** An optional non-negative integer; `undefined` when absent. */
+function nonNegativeInt(value, name) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw new InvalidParamsError(`${name} must be a non-negative integer.`);
+	return value;
+}
+/** An optional string; `undefined` when absent. */
+function optionalString(value, name) {
+	if (value !== void 0 && typeof value !== "string") throw new InvalidParamsError(`${name} must be a string.`);
+	return value;
+}
+/**
+* What every method's params must be: absent, `null`, or an object (never an
+* array or a scalar), whose `sessionId` / `sessionIds`, when present, name
+* sessions ({@link checkSessionId}).
+*/
+function checkParams(params) {
+	if (params === void 0 || params === null) return;
+	if (typeof params !== "object" || Array.isArray(params)) throw new InvalidParamsError("params must be an object.");
+	const { sessionId, sessionIds } = params;
+	if (sessionId !== void 0) checkSessionId(sessionId);
+	if (sessionIds !== void 0) {
+		if (!Array.isArray(sessionIds)) throw new InvalidParamsError("sessionIds must be an array.");
+		for (const id of sessionIds) checkSessionId(id, "sessionIds[]");
+	}
+}
+//#endregion
+//#region src/ipc/daemon/handlers/machine-links.ts
+const GATE_POLL_MS = 2e3;
+const EMPTY = {
+	shares: [],
+	uses: []
+};
+/** A server's: no links, nothing loaded or resumed. */
+function serverLinkHandlers() {
+	const refuse = () => {
+		throw new Error("A zidane-server has no machine links: share a computer with it from that computer (zidane machine share, or its Hosts page).");
+	};
+	return {
+		"machines.share.start": refuse,
+		"machines.share.stop": refuse,
+		"machines.useServer": refuse,
+		"machines.links.status": refuse
+	};
+}
+function createMachineLinkHandlers(options) {
+	if (options.server) return serverLinkHandlers();
+	const { host, env, broadcast } = options;
+	let links;
+	let gateTimer;
+	const gateOn = () => remoteHostsGate.isEnabled(env.readSettings());
+	const stop = () => {
+		const current = links;
+		links = void 0;
+		clearInterval(gateTimer);
+		gateTimer = void 0;
+		current?.then((l) => l.close()).catch(() => void 0);
+		broadcast({
+			kind: "machine:links",
+			links: EMPTY
+		});
+	};
+	const load = () => {
+		links ??= import("./links-j8rED1sR.js").then(({ startMachineLinks }) => startMachineLinks({
+			dataDir: env.userDataDir(),
+			machines: host.machines,
+			hostId: options.hostId,
+			appVersion: options.appVersion,
+			settings: () => env.readSettings(),
+			onChange: (status) => broadcast({
+				kind: "machine:links",
+				links: status
+			}),
+			...options.pacing
+		}));
+		gateTimer ??= setInterval(() => {
+			if (!gateOn()) stop();
+		}, options.pacing?.pollMs ?? GATE_POLL_MS);
+		gateTimer.unref?.();
+		return links;
+	};
+	const required = () => {
+		if (!gateOn()) throw new Error(`Remote hosts are off${remoteHostsGate.isKilled() ? ` (${remoteHostsGate.killSwitchEnv}=1)` : ""}: machines are part of them.`);
+		return load();
+	};
+	const str = (value, name) => {
+		if (typeof value !== "string" || value === "") throw new InvalidParamsError(`"${name}" must be a non-empty string.`);
+		return value;
+	};
+	if (gateOn() && existsSync(join(env.userDataDir(), "machine-links.json"))) load().catch(() => void 0);
+	host.machines.onClose(() => {
+		const current = links;
+		links = void 0;
+		clearInterval(gateTimer);
+		current?.then((l) => l.close()).catch(() => void 0);
+	});
+	return {
+		"machines.share.start": async (p) => {
+			if (!Array.isArray(p.roots)) throw new InvalidParamsError("\"roots\" must be a list of folders.");
+			if (host.workspace.confined) for (const root of p.roots) host.workspace.resolveFolder(String(root));
+			return (await required()).startShare({
+				hostId: str(p.hostId, "hostId"),
+				name: str(p.name, "name"),
+				roots: p.roots,
+				...typeof p.token === "string" ? { token: p.token } : {}
+			});
+		},
+		"machines.share.stop": async (p) => (await required()).stopShare(str(p.hostId, "hostId")),
+		"machines.useServer": async (p) => {
+			if (typeof p.enabled !== "boolean") throw new InvalidParamsError("\"enabled\" must be a boolean.");
+			return (await required()).setUse(str(p.hostId, "hostId"), p.enabled);
+		},
+		"machines.links.status": async () => gateOn() ? (await load()).status() : EMPTY
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/machines.ts
+/** Folders listed per call at most. */
+const MAX_DIRS = 2e3;
+function createMachineHandlers({ host, broadcast }) {
+	return {
+		"machines.list": () => host.machines.list(),
+		"machines.forget": (p) => {
+			if (typeof p.machineId !== "string") throw new InvalidParamsError("machines.forget: \"machineId\" must be a string.");
+			const machine = host.machines.get(p.machineId);
+			const forgotten = host.machines.forget(p.machineId);
+			if (forgotten && machine) broadcast({
+				kind: "machine:status",
+				machineId: machine.id,
+				name: machine.name,
+				status: "offline"
+			});
+			return { forgotten };
+		},
+		"machines.listDirs": async (p) => {
+			if (typeof p.machineId !== "string") throw new InvalidParamsError("machines.listDirs: \"machineId\" must be a string.");
+			const machine = host.machines.get(p.machineId);
+			const link = host.machines.link(p.machineId);
+			if (!machine || !link) throw new Error(`Unknown machine "${p.machineId}".`);
+			const roots = machine.roots.map((root) => root.path);
+			const asked = p.path === void 0 || p.path === "" ? roots[0] : p.path;
+			if (typeof asked !== "string" || !insideDeclaredRoots(machine.roots, asked)) throw new Error(`${String(asked)} is outside ${machine.name}'s roots.`);
+			const path = posix.normalize(asked);
+			const root = roots.find((r) => insideDeclaredRoots([{ path: r }], path));
+			const { entries } = await link.call("fs.list", {
+				handle: {
+					id: "host-list-dirs",
+					cwd: root
+				},
+				path
+			}, { wait: false });
+			return {
+				path,
+				dirs: entries.map((entry) => typeof entry === "string" ? entry : entry.path).filter((name) => name.endsWith("/")).map((name) => posix.join(path, name.slice(0, -1))).sort().slice(0, MAX_DIRS),
+				roots
+			};
+		}
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/transcript-page.ts
+/**
+* A run longer than this many pages is split (by `limit`, so the client's
+* halving retry on a reply too large still converges).
+*/
+const WHOLE_RUN_PAGES = 5;
+function isPagedLoad(p) {
+	return p?.before !== void 0 || p?.limit !== void 0;
+}
+/** Per turn: does a run start there (a parent-run user turn carrying no tool result)? */
+function exchangeBoundaries(turns, runs) {
+	const childRuns = new Set(runs.filter((run) => (run.depth ?? 0) > 0 || run.parentRunId !== void 0).map((run) => run.id));
+	return turns.map((turn) => turn.role === "user" && !(turn.runId !== void 0 && childRuns.has(turn.runId)) && !turn.content.some((block) => block.type === "tool_result"));
+}
+/** Per turn: can a page start there without leaving a tool call's result behind (not a tool-result turn)? */
+function turnCutPoints(turns) {
+	return turns.map((turn) => !(turn.role === "user" && turn.content.some((block) => block.type === "tool_result")));
+}
+/**
+* `[from, to)` of the page, and the cursor of the one before it, over the
+* turns' {@link exchangeBoundaries} (run starts) and {@link turnCutPoints}
+* (where a run too long to send whole may be split; run starts when absent).
+*/
+function transcriptPage(boundaries, paging, cuts = boundaries) {
+	const before = nonNegativeInt(paging.before, "before");
+	const limit = Math.min(Math.max(nonNegativeInt(paging.limit, "limit") ?? 200, 1), LOAD_EVENTS_MAX_PAGE_TURNS);
+	const to = Math.min(before ?? boundaries.length, boundaries.length);
+	if (to === 0) return {
+		from: 0,
+		to: 0
+	};
+	/** Where the run holding turn `end - 1` starts (0 when no run start precedes it). */
+	const runStart = (end) => {
+		let i = end - 1;
+		while (i > 0 && !boundaries[i]) i--;
+		return i;
+	};
+	let from = runStart(to);
+	const ceiling = limit * 5;
+	if (to - from > ceiling) {
+		from = to - ceiling;
+		while (from < to - 1 && !cuts[from]) from++;
+	} else while (from > 0) {
+		const previous = runStart(from);
+		if (to - previous > limit) break;
+		from = previous;
+	}
+	return {
+		from,
+		to,
+		...from > 0 ? { cursor: from } : {}
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/artifacts.ts
+/** 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 createArtifactHandlers({ store, broadcast }) {
+	return {
+		"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;
+		}
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/auth.ts
+/** Longest API key accepted (keys are well under 1 KiB; this bounds a mistaken paste). */
+const MAX_KEY_LENGTH = 8192;
+/** The host's providers and their credentials: lookups, statuses, and applying a change. */
+function createProviderAuth({ host, env }) {
+	const registry = () => env.config.providers;
+	const dataDir = () => env.userDataDir();
+	const descriptorOf = (provider) => {
+		const descriptor = typeof provider === "string" ? registry()[provider] : void 0;
+		if (!descriptor) throw new Error(`Unknown provider "${String(provider)}".`);
+		return descriptor;
+	};
+	const statusOf = (key) => {
+		const auth = detectAuth(dataDir(), { [key]: registry()[key] })[0];
+		return {
+			key: auth.key,
+			label: auth.label,
+			configured: auth.available,
+			oauth: registry()[key]?.oauthProvider !== void 0,
+			...auth.envKey ? { envKey: auth.envKey } : {},
+			methods: auth.methods.map((m) => ({
+				source: m.source,
+				active: m.active === true,
+				...m.key !== void 0 ? { key: m.key } : {},
+				...m.label !== void 0 ? { label: m.label } : {},
+				detail: m.detail
+			}))
+		};
+	};
+	/** The stored API key values of a provider (to clear them from the environment once removed). */
+	const storedKeys = (descriptor) => readProviderCredentials(dataDir(), descriptor).flatMap((s) => s.credential.kind === "apikey" && s.credential.value ? [s.credential.value] : []);
+	/** Make the change take effect: env re-applied, a removed key out of it, agents rebuilt. */
+	const applied = (descriptor, removedKeys = []) => {
+		if (env.applyAuthEnv) env.applyAuthEnv();
+		else applyApiKeyEnv(dataDir(), registry(), { log: () => void 0 });
+		const envKey = descriptor.envKey;
+		if (envKey && removedKeys.includes(process.env[envKey] ?? "") && !storedKeys(descriptor).includes(process.env[envKey])) delete process.env[envKey];
+		host.rebuildAllAgents().catch(() => void 0);
+	};
+	return {
+		registry,
+		dataDir,
+		descriptorOf,
+		statusOf,
+		storedKeys,
+		applied
+	};
+}
+function createAuthHandlers({ auth }) {
+	const { registry, dataDir, descriptorOf, statusOf, storedKeys, applied } = auth;
+	return {
+		"auth.status": () => ({ providers: Object.keys(registry()).map(statusOf) }),
+		"auth.setApiKey": (p) => {
+			const descriptor = descriptorOf(p.provider);
+			const key = typeof p.key === "string" ? p.key.trim() : "";
+			if (!key) throw new Error("The API key is empty.");
+			if (key.length > MAX_KEY_LENGTH) throw new Error(`The API key is longer than ${MAX_KEY_LENGTH} characters.`);
+			setProviderCredential(dataDir(), descriptor, {
+				kind: "apikey",
+				value: key
+			});
+			applied(descriptor);
+			return statusOf(descriptor.key);
+		},
+		"auth.remove": (p) => {
+			const descriptor = descriptorOf(p.provider);
+			const before = storedKeys(descriptor);
+			let removed;
+			if (typeof p.account === "string") removed = removeStoredCredential(dataDir(), descriptor, p.account);
+			else {
+				removed = readProviderCredentials(dataDir(), descriptor).length > 0;
+				removeProviderCredential(dataDir(), descriptor);
+			}
+			if (removed) applied(descriptor, before.filter((k) => !storedKeys(descriptor).includes(k)));
+			return {
+				removed,
+				provider: statusOf(descriptor.key)
+			};
+		}
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/browser.ts
+function createBrowserHandlers({ host }) {
+	return {
+		methods: {
+			"browser.registerHost": (p, peer) => {
+				(peer.browserHosts ??= /* @__PURE__ */ new Set()).add(p.hostId);
+				host.browser.registerHost(p.hostId);
+				return { ok: true };
+			},
+			"browser.unregisterHost": (p, peer) => {
+				peer.browserHosts?.delete(p.hostId);
+				host.browser.unregisterHost(p.hostId);
+				return { ok: true };
+			},
+			"browser.respond": (p, peer) => host.browser.respond(p.requestId, p.response, peer.browserHosts ?? /* @__PURE__ */ new Set())
+		},
+		releasePeer(peer) {
+			for (const hostId of peer.browserHosts ?? []) host.browser.unregisterHost(hostId);
+		}
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/catalog-install.ts
+const DEFAULT_TIMEOUT_MS = 3e5;
+const MAX_SPEC_LENGTH = 500;
+const MAX_MCP_CONFIG_BYTES = 65536;
+const NAME_RE$1 = /^[\w@.-]{1,100}$/;
+const MCP_TRANSPORTS = /* @__PURE__ */ new Set([
+	"stdio",
+	"sse",
+	"streamable-http"
+]);
+const OFF_MESSAGE = "Installs from clients are off on this server (allowRemoteInstalls is off).";
+/** A spec a server may fetch: GitHub or npm. Anything path-like is refused before the parsers see it. */
+function checkSpec(spec) {
+	if (typeof spec !== "string" || spec.trim() === "") throw new InvalidParamsError("spec must be a non-empty string.");
+	const value = spec.trim();
+	if (value.length > MAX_SPEC_LENGTH) throw new InvalidParamsError(`spec is longer than ${MAX_SPEC_LENGTH} characters.`);
+	const segments = value.split(/[/:#@]/);
+	if (/^(?:[./~\\]|file:)/i.test(value) || value.includes("\\") || segments.includes(".") || segments.includes("..")) throw new InvalidParamsError(`"${value}" is a path: a server installs from GitHub (owner/repo, a GitHub URL) or npm only.`);
+	return value;
+}
+function checkName(name, what) {
+	if (typeof name !== "string" || !NAME_RE$1.test(name) || name === "." || name === "..") throw new InvalidParamsError(`${what} must be a plain name (letters, digits, ., _, -, @).`);
+	return name;
+}
+function checkKind(kind) {
+	if (kind !== "skill" && kind !== "extension") throw new InvalidParamsError("kind must be \"skill\" or \"extension\".");
+	return kind;
+}
+function isStringRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((v) => typeof v === "string");
+}
+function checkMcpConfig(config) {
+	if (typeof config !== "object" || config === null || Array.isArray(config)) throw new InvalidParamsError("config must be an MCP server object.");
+	if (JSON.stringify(config).length > MAX_MCP_CONFIG_BYTES) throw new InvalidParamsError(`config is larger than ${MAX_MCP_CONFIG_BYTES} bytes.`);
+	const c = config;
+	checkName(c.name, "name");
+	if (c.transport !== void 0 && !MCP_TRANSPORTS.has(c.transport)) throw new InvalidParamsError("transport must be stdio, sse or streamable-http.");
+	const hasCommand = typeof c.command === "string" && c.command.trim() !== "";
+	let hasUrl = false;
+	if (typeof c.url === "string") {
+		try {
+			hasUrl = ["http:", "https:"].includes(new URL(c.url).protocol);
+		} catch {}
+		if (!hasUrl) throw new InvalidParamsError("url must be an http(s) URL.");
+	}
+	if (!hasCommand && !hasUrl) throw new InvalidParamsError("An MCP server needs a command (stdio) or a url.");
+	if (c.args !== void 0 && (!Array.isArray(c.args) || !c.args.every((a) => typeof a === "string"))) throw new InvalidParamsError("args must be strings.");
+	for (const key of ["env", "headers"]) if (c[key] !== void 0 && !isStringRecord(c[key])) throw new InvalidParamsError(`${key} must map names to strings.`);
+	return c;
+}
+/** How long a stopped install may take to roll back before the refusal is answered anyway. */
+const ROLLBACK_GRACE_MS = 1e4;
+/**
+* `run` bounded by `ms`: past it, its signal fires (children killed, no next
+* step: `abortableInstallIo`) and the refusal waits for the installer's own
+* rollback (staging dir, transactional target), up to {@link ROLLBACK_GRACE_MS}.
+*/
+async function bounded(run, ms, what) {
+	const controller = new AbortController();
+	const work = run(controller.signal);
+	let timer;
+	try {
+		return await Promise.race([work, new Promise((_, reject) => {
+			timer = setTimeout(() => {
+				controller.abort();
+				reject(/* @__PURE__ */ new Error(`${what} took longer than ${Math.round(ms / 1e3)}s and was stopped.`));
+			}, ms);
+		})]);
+	} catch (err) {
+		if (controller.signal.aborted) {
+			let grace;
+			await Promise.race([work.catch(() => void 0), new Promise((resolve) => {
+				grace = setTimeout(resolve, ROLLBACK_GRACE_MS);
+			})]);
+			clearTimeout(grace);
+		}
+		throw err;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+function createCatalogInstallHandlers({ host, env, broadcast, setSettings, options }) {
+	const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+	const io = options?.io;
+	const prefix = () => env.config.prefix;
+	/** The host user's roots for `subPath` (`~/.agents/<sub>`, `~/.<prefix>/<sub>`), read at call time. */
+	const userRoots = (subPath) => projectUserPaths({
+		subPath,
+		cwd: homedir(),
+		home: homedir(),
+		prefix: prefix()
+	}).filter((p) => p.source === "user").map((p) => p.path);
+	/** Gate, run, audit: every attempt leaves one line, refusals and failures included. */
+	async function guarded(peer, event, fields, run) {
+		if (!options) throw new Error("This host takes no installs from clients (a zidane-server does, with allowRemoteInstalls on).");
+		if (!options.allowed()) {
+			options.audit?.(peer, {
+				event,
+				...fields,
+				ok: false,
+				refused: "allowRemoteInstalls is off"
+			});
+			throw new Error(OFF_MESSAGE);
+		}
+		try {
+			const result = await run();
+			options.audit?.(peer, {
+				event,
+				...fields,
+				ok: true
+			});
+			return result;
+		} catch (err) {
+			options.audit?.(peer, {
+				event,
+				...fields,
+				ok: false,
+				error: err instanceof Error ? err.message : String(err)
+			});
+			throw err;
+		}
+	}
+	const changed = (catalog) => broadcast({
+		kind: "catalog:changed",
+		catalog
+	});
+	/** Skills and MCP servers are read when an agent is built. */
+	const rebuild = () => {
+		host.rebuildAllAgents({ rediscover: true }).catch(() => void 0);
+	};
+	/** Extensions live in the runtime registry: forget it, rebuild, dispose the old one once idle (as `runtime.reload`). */
+	const reloadExtensions = () => {
+		const disposeOld = env.forgetRuntime();
+		host.rebuildAllAgents({ rediscover: true }).then(disposeOld, disposeOld);
+	};
+	/** `name` dropped from (or added to) an explicit allowlist; an absent list means "all", left alone. */
+	const allowlist = (key, name, present) => {
+		const list = env.readSettings()[key];
+		if (list === void 0 || list.includes(name) === present) return false;
+		setSettings({ [key]: present ? [...list, name] : list.filter((n) => n !== name) });
+		return true;
+	};
+	/** The user-scope install directory named `name` under `subPath`, if any. */
+	const userDir = (subPath, name, marker) => userRoots(subPath).map((root) => join(root, name)).find((dir) => existsSync(marker ? join(dir, marker) : dir));
+	return {
+		"catalog.install": (p, peer) => guarded(peer, "catalog.install", {
+			kind: p.kind,
+			spec: typeof p.spec === "string" ? p.spec.slice(0, MAX_SPEC_LENGTH) : void 0
+		}, async () => {
+			const kind = checkKind(p.kind);
+			const spec = checkSpec(p.spec);
+			if (p.scope !== void 0 && p.scope !== "user") throw new InvalidParamsError("A server installs in its user scope only (scope: \"user\").");
+			const progress = [];
+			const onProgress = (line) => {
+				if (progress.length < 200) progress.push(line);
+			};
+			const home = homedir();
+			if (kind === "skill") {
+				const result = await bounded((signal) => installSkillFromSpec({
+					source: spec,
+					scope: "user",
+					cwd: home,
+					home,
+					prefix: prefix(),
+					onProgress,
+					io: abortableInstallIo(io, signal),
+					...Array.isArray(p.skills) ? { skills: p.skills.filter((s) => typeof s === "string") } : {},
+					...p.all === true ? { all: true } : {},
+					...p.overwrite === true ? { overwrite: true } : {}
+				}), timeoutMs, `Installing ${spec}`);
+				rebuild();
+				changed("skills");
+				const skipped = result.skipped?.length ? `. Skipped existing: ${result.skipped.join(", ")}` : "";
+				return {
+					installed: [...result.installed],
+					message: `installed ${result.installed.join(", ")} (${result.provenance ?? result.engine})${skipped}`,
+					progress
+				};
+			}
+			let result;
+			try {
+				result = await bounded((signal) => installExtensionFromSpec({
+					source: spec,
+					scope: "user",
+					cwd: home,
+					home,
+					prefix: prefix(),
+					onProgress,
+					io: abortableInstallIo(io, signal),
+					...typeof p.extension === "string" ? { extension: p.extension } : {},
+					...p.overwrite === true ? { overwrite: true } : {}
+				}), timeoutMs, `Installing ${spec}`);
+			} catch (err) {
+				if (err instanceof ExtensionInstallError && err.code === "exists") throw new Error("already installed on the server: update or remove it first.");
+				throw err;
+			}
+			if (!allowlist("enabledExtensions", result.name, true)) reloadExtensions();
+			changed("extensions");
+			const warn = result.warnings.length > 0 ? `. ${result.warnings.join(". ")}` : "";
+			return {
+				installed: [result.name],
+				message: `installed "${result.name}" (${result.provenance})${warn}`,
+				progress
+			};
+		}),
+		"catalog.remove": (p, peer) => guarded(peer, "catalog.remove", {
+			kind: p.kind,
+			name: p.name
+		}, async () => {
+			const kind = checkKind(p.kind);
+			const name = checkName(p.name, "name");
+			if (kind === "skill") {
+				const dir = userDir("skills", name, "SKILL.md");
+				if (!dir) throw new Error(`No user-scope skill "${name}" on this server (project skills are files in their folder).`);
+				rmSync(dir, {
+					recursive: true,
+					force: true
+				});
+				allowlist("enabledSkills", name, false);
+				rebuild();
+				changed("skills");
+				return {
+					removed: name,
+					message: `deleted "${name}"`
+				};
+			}
+			const dir = userDir("extensions", name);
+			if (!dir) throw new Error(`No user-scope extension "${name}" on this server.`);
+			removeInstalledExtension({
+				dir,
+				cwd: homedir(),
+				home: homedir(),
+				prefix: prefix()
+			});
+			if (!allowlist("enabledExtensions", name, false)) reloadExtensions();
+			changed("extensions");
+			return {
+				removed: name,
+				message: `removed "${name}"`
+			};
+		}),
+		"catalog.update": (p, peer) => guarded(peer, "catalog.update", {
+			kind: p.kind,
+			name: p.name
+		}, async () => {
+			const kind = checkKind(p.kind);
+			const name = checkName(p.name, "name");
+			if (kind === "skill") throw new Error("Skills are not updated in place: install again with overwrite.");
+			const dir = userDir("extensions", name);
+			if (!dir) throw new Error(`No user-scope extension "${name}" on this server.`);
+			const result = await bounded((signal) => updateInstalledExtension({
+				dir,
+				cwd: homedir(),
+				home: homedir(),
+				prefix: prefix(),
+				io: abortableInstallIo(io, signal)
+			}), timeoutMs, `Updating ${name}`);
+			if (result.upToDate) return {
+				updated: result.name,
+				upToDate: true,
+				message: `"${result.name}" is already up to date${result.commit ? ` (${result.commit.slice(0, 7)})` : ""}`
+			};
+			reloadExtensions();
+			changed("extensions");
+			return {
+				updated: result.name,
+				upToDate: false,
+				message: `updated "${result.name}" → ${result.provenance}`
+			};
+		}),
+		"mcp.upsert": (p, peer) => guarded(peer, "mcp.upsert", { name: p.config?.name }, () => {
+			const config = checkMcpConfig(p.config);
+			const result = upsertMcpServer(mcpsWritePath("user", {
+				home: homedir(),
+				cwd: homedir(),
+				prefix: prefix()
+			}), config);
+			const enabled = result.action === "added" ? enabledMcpsWith(env.readSettings().enabledMcps, config.name) : void 0;
+			if (enabled) setSettings({ enabledMcps: enabled });
+			rebuild();
+			changed("mcps");
+			return {
+				name: config.name,
+				created: result.action === "added"
+			};
+		}),
+		"mcp.remove": (p, peer) => guarded(peer, "mcp.remove", { name: p.name }, () => {
+			const name = checkName(p.name, "name");
+			const path = mcpsWritePath("user", {
+				home: homedir(),
+				cwd: homedir(),
+				prefix: prefix()
+			});
+			try {
+				removeMcpServer(path, name);
+			} catch (err) {
+				if (!existsSync(path) || /no entry named/.test(err instanceof Error ? err.message : "")) return { removed: false };
+				throw err;
+			}
+			const enabled = enabledMcpsWithout(env.readSettings().enabledMcps, name);
+			if (enabled) setSettings({ enabledMcps: enabled });
+			rebuild();
+			changed("mcps");
+			return { removed: true };
+		})
+	};
+}
+/** For `ipc.hello`: installs are offered when the server allows them. */
+function remoteInstallsAllowed(options) {
+	return options?.allowed() === true;
+}
+//#endregion
+//#region src/ipc/daemon/redact.ts
+/**
+* Secret redaction for what a host shows about its MCP servers
+* (`catalog.mcps`): command-line arguments and URLs, which config files
+* routinely fill with tokens. Over-redacting an ordinary argument is a
+* cosmetic loss; under-redacting leaks a credential to every client, so the
+* rules lean wide, but stay off file paths, package names and plain words.
+*
+* - URLs (`scheme://…`, as an argument or inside one): userinfo, query values,
+*   fragment values, and secret-looking path segments.
+* - Values of secret-looking flags (`--token x`, `--api-key=x`), of header
+*   flags (`-H "Name: value"`, `--header=Name: value`), of secret-looking
+*   headers anywhere (`Authorization: Bearer …`), and of secret-looking
+*   `KEY=VALUE` pairs (`-e GITHUB_TOKEN=…`, `env API_KEY=…`, `--pass x`).
+* - JSON arguments (`--config '{"apiKey":"…"}'`): the value of every
+*   secret-named key at any depth; the other strings as values.
+* - Connection strings and form bodies (`Server=x;Password=…`,
+*   `a=1&token=…`): each secret-named pair's value.
+* - Known token shapes anywhere in an argument (`sk-…`, `ghp_…`, `xoxb-…`,
+*   `AKIA…`, `glpat-…`, `zds_…`), and whole high-entropy arguments.
+*
+* What counts as secret-looking is shared (`src/chat/secret-shapes`): the
+* remote host URL check refuses the same shapes in a URL's path.
+*/
+const HEADER_FLAGS = /* @__PURE__ */ new Set([
+	"-H",
+	"--header",
+	"--headers"
+]);
+const URL_SHAPED = /^[a-z][a-z0-9+.-]*:\/\//i;
+const HEADER = /^([\w-]+):(\s*)\S.*$/s;
+const KEY_VALUE = /^([A-Z_][\w.-]*)=(.*)$/is;
+/** `k=v` pairs joined by `;` or `&` (a connection string, a form body): `Server=x;Password=y`, `a=1&token=x`. */
+const DELIMITED_PAIRS = /^[a-z_][\w .-]*=[^;&]*(?:[;&][a-z_][\w .-]*=[^;&]*)+[;&]?$/i;
+/** A JSON object or array argument (`--config '{"apiKey":"…"}'`). */
+const JSON_SHAPED = /^\s*[{[][\s\S]*[}\]]\s*$/;
+const scrubKnownTokens = (value) => value.replace(KNOWN_TOKEN, REDACTED);
+function redactPairs(text) {
+	return text.split("&").map((pair) => {
+		const eq = pair.indexOf("=");
+		return eq < 0 ? pair : `${pair.slice(0, eq)}=${REDACTED}`;
+	}).join("&");
+}
+/**
+* `https://user:pw@host/p/<key>/sse?k=v#t=x` → `https://<redacted>@host/p/<redacted>/sse?k=<redacted>#t=<redacted>`;
+* an unparsable URL is redacted whole.
+*/
+function redactUrl(raw) {
+	let url;
+	try {
+		url = new URL(raw);
+	} catch {
+		return REDACTED;
+	}
+	const credentials = url.username !== "" || url.password !== "" ? `${REDACTED}@` : "";
+	const path = url.pathname.split("/").map((segment) => isSecretPathSegment(segment) ? REDACTED : segment).join("/");
+	const keys = [...url.searchParams.keys()];
+	const query = keys.length > 0 ? `?${keys.map((key) => `${encodeURIComponent(key)}=${REDACTED}`).join("&")}` : "";
+	const fragment = url.hash.slice(1);
+	const hash = fragment === "" ? "" : fragment.includes("=") ? `#${redactPairs(fragment)}` : looksLikeSecret(fragment) ? `#${REDACTED}` : `#${fragment}`;
+	const authority = url.host !== "" || raw.includes("//") ? `//${credentials}${url.host}` : "";
+	return scrubKnownTokens(`${url.protocol}${authority}${path}${query}${hash}`);
+}
+function redactHeader(value) {
+	const match = HEADER.exec(value);
+	return match ? `${match[1]}:${match[2]}${REDACTED}` : REDACTED;
+}
+/** One value standing on its own (a positional argument, or what follows `--flag=`). */
+function redactValue(value) {
+	if (URL_SHAPED.test(value)) return redactUrl(value);
+	const header = HEADER.exec(value);
+	if (header && isSecretName(header[1])) return redactHeader(value);
+	const json = JSON_SHAPED.test(value) ? redactJson(value) : null;
+	if (json !== null) return json;
+	if (DELIMITED_PAIRS.test(value)) return redactDelimitedPairs(value);
+	const pair = KEY_VALUE.exec(value);
+	if (pair) return `${pair[1]}=${isSecretName(pair[1]) ? REDACTED : redactValue(pair[2])}`;
+	if (looksLikeSecret(value)) return REDACTED;
+	return scrubKnownTokens(value);
+}
+/** `Server=x;Password=y` → `Server=x;Password=<redacted>`: each secret-named pair's value, the others' as values. */
+function redactDelimitedPairs(value) {
+	return value.split(/([;&])/).map((part) => {
+		const eq = part.indexOf("=");
+		if (eq < 0) return part;
+		const name = part.slice(0, eq);
+		return `${name}=${isSecretName(name.trim()) ? REDACTED : redactValue(part.slice(eq + 1))}`;
+	}).join("");
+}
+/** A JSON argument with every secret-named key's value redacted (any depth), the other strings as values; `null` when not JSON. */
+function redactJson(value) {
+	let parsed;
+	try {
+		parsed = JSON.parse(value);
+	} catch {
+		return null;
+	}
+	if (parsed === null || typeof parsed !== "object") return null;
+	const walk = (node) => {
+		if (typeof node === "string") return redactValue(node);
+		if (Array.isArray(node)) return node.map(walk);
+		if (node !== null && typeof node === "object") return Object.fromEntries(Object.entries(node).map(([key, child]) => [key, isSecretName(key) ? REDACTED : walk(child)]));
+		return node;
+	};
+	return JSON.stringify(walk(parsed));
+}
+/** An MCP server's arguments with every secret-looking value replaced by {@link REDACTED}. */
+function redactArgs(args) {
+	const out = [];
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (!arg.startsWith("-")) {
+			out.push(redactValue(arg));
+			continue;
+		}
+		const eq = arg.indexOf("=");
+		const flag = eq > 0 ? arg.slice(0, eq) : arg;
+		if (eq > 0) {
+			const value = arg.slice(eq + 1);
+			out.push(`${flag}=${HEADER_FLAGS.has(flag) ? redactHeader(value) : isSecretName(flag) ? REDACTED : redactValue(value)}`);
+			continue;
+		}
+		out.push(scrubKnownTokens(arg));
+		const next = args[i + 1];
+		if (next === void 0 || next.startsWith("-")) continue;
+		if (HEADER_FLAGS.has(flag)) {
+			out.push(redactHeader(next));
+			i++;
+		} else if (isSecretName(flag)) {
+			out.push(REDACTED);
+			i++;
+		}
+	}
+	return out;
+}
+//#endregion
+//#region src/ipc/daemon/catalog-entries.ts
+const allows = (list, name) => list === void 0 || list.includes(name);
+/**
+* Disk skills (gated by `enabledSkills`), then plugin and extension skills
+* (gated by their plugin / extension, so always on here), later ones winning
+* a name like the agent's own merge (`mergeSkillCatalog`).
+*/
+function skillEntries(input) {
+	const byName = /* @__PURE__ */ new Map();
+	const add = (skill, origin) => {
+		const contributedBy = origin === "plugin" ? skill.metadata?.["zidane.plugin"] : origin === "extension" ? skill.metadata?.["zidane.extension"] : void 0;
+		byName.set(skill.name, {
+			name: skill.name,
+			description: skill.description,
+			...skill.source ? { source: skill.source } : {},
+			...skill.location ? { location: skill.location } : {},
+			origin,
+			...contributedBy ? { contributedBy } : {},
+			enabled: origin === "disk" ? allows(input.settings.enabledSkills, skill.name) : true,
+			toggleable: origin === "disk"
+		});
+	};
+	for (const skill of input.disk) add(skill, "disk");
+	for (const skill of input.plugin) add(skill, "plugin");
+	for (const skill of input.extension) add(skill, "extension");
+	return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+function redactValues(record) {
+	if (!record) return void 0;
+	return Object.fromEntries(Object.keys(record).map((key) => [key, REDACTED]));
+}
+function mcpEntries(servers, errors, settings) {
+	return {
+		servers: servers.map(({ config, source, path }) => {
+			const env = redactValues(config.env);
+			const headers = redactValues(config.headers);
+			return {
+				name: config.name,
+				transport: config.transport,
+				source,
+				path,
+				enabled: allows(settings.enabledMcps, config.name),
+				toggleable: true,
+				...config.command !== void 0 ? { command: config.command } : {},
+				...config.args ? { args: redactArgs(config.args) } : {},
+				...config.url !== void 0 ? { url: redactUrl(config.url) } : {},
+				...config.cwd !== void 0 ? { cwd: config.cwd } : {},
+				...config.scope !== void 0 ? { scope: config.scope } : {},
+				...config.auth !== void 0 ? { auth: config.auth } : {},
+				...env ? { env } : {},
+				...headers ? { headers } : {}
+			};
+		}),
+		errors: errors.map((e) => ({
+			path: e.path,
+			source: e.source,
+			message: e.message,
+			...e.informational ? { informational: true } : {}
+		}))
+	};
+}
+function capabilities(contributions) {
+	const labels = [];
+	const add = (label, present) => {
+		if (present) labels.push(label);
+	};
+	add("agents", Object.keys(contributions.agents).length > 0);
+	add("providers", Object.keys(contributions.providers).length > 0);
+	add("tools", Object.keys(contributions.tools).length > 0);
+	add("hooks", Object.values(contributions.hooks).some((handlers) => handlers !== void 0 && handlers.length > 0));
+	add("mcps", contributions.mcpServers.length > 0);
+	add("skills", contributions.skills.length > 0);
+	add("commands", contributions.commands.length > 0);
+	add("completions", contributions.completionProviders.length > 0);
+	add("themes", Object.keys(contributions.themes).length > 0);
+	add("system", contributions.systemFragments.length > 0);
+	return labels;
+}
+/** Loaded, then inactive (disabled or broken), first one of a name wins. */
+function extensionEntries(loaded, inactive, settings) {
+	const rows = /* @__PURE__ */ new Map();
+	for (const ext of [...loaded, ...inactive]) {
+		if (rows.has(ext.name)) continue;
+		rows.set(ext.name, {
+			name: ext.name,
+			source: ext.source,
+			enabled: !ext.error && allows(settings.enabledExtensions, ext.name),
+			toggleable: !ext.error,
+			...ext.definition?.version ? { version: ext.definition.version } : {},
+			...ext.definition?.description ? { description: ext.definition.description } : {},
+			...ext.dir ? { dir: ext.dir } : {},
+			...ext.error ? { error: ext.error } : {},
+			...ext.contributions ? { capabilities: capabilities(ext.contributions) } : {}
+		});
+	}
+	return [...rows.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+/** Disk plugins, then the ones extensions loaded (a name on disk wins, as the agent's gate decides). */
+function pluginEntries(disk, fromExtensions, settings) {
+	const sources = [...disk.map((p) => ({
+		plugin: p.plugin,
+		name: p.name,
+		origin: {
+			kind: "disk",
+			scope: p.source,
+			dir: p.path
+		}
+	})), ...fromExtensions.map((r) => ({
+		plugin: r.plugin,
+		name: r.name,
+		origin: {
+			kind: "extension",
+			extensionName: r.extensionName,
+			dir: r.dir
+		}
+	}))];
+	const rows = /* @__PURE__ */ new Map();
+	for (const { plugin, name, origin } of sources) {
+		if (rows.has(name)) continue;
+		const error = plugin.ok ? void 0 : plugin.diagnostics.find((d) => d.severity === "error")?.message;
+		rows.set(name, {
+			name,
+			origin,
+			ok: plugin.ok,
+			enabled: plugin.ok && allows(settings.enabledPlugins, name),
+			toggleable: plugin.ok,
+			...plugin.manifest?.version !== void 0 ? { version: plugin.manifest.version } : {},
+			...plugin.manifest?.description !== void 0 ? { description: plugin.manifest.description } : {},
+			skills: plugin.skills.map((s) => s.name),
+			mcpServers: plugin.mcpServers.map((s) => s.name),
+			...error ? { error } : {}
+		});
+	}
+	return [...rows.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+//#endregion
+//#region src/ipc/daemon/handlers/catalogs.ts
+const kindOf = (kind) => typeof kind === "string" ? kind : void 0;
+/**
+* The folder a catalog scans: `cwd` (inside the roots on a server), else the
+* host user's home. A machine's folder (`docs/MACHINES.md` § Folders) is
+* never read here: a folder of this host's stands in for the user scope.
+*/
+function catalogFolder({ env, host }, cwd, kind) {
+	if (cwd !== void 0 && typeof cwd !== "string") throw new Error("cwd must be a string.");
+	if (!cwd) return scopeCwd("");
+	const folder = host.resolveFolder(cwd, kindOf(kind));
+	return folder.machine ? machineDiscoveryCwd(env.userDataDir()) : scopeCwd(folder.cwd);
+}
+function createCatalogHandlers({ env, host }) {
+	const folderOf = (cwd, kind) => catalogFolder({
+		env,
+		host
+	}, cwd, kind);
+	/** User scope here, project scope read on the machine for a machine's folder. */
+	const catalogOf = async (cwd, kind, prefix) => {
+		if (typeof cwd !== "string" || !cwd || !host.resolveFolder(cwd, kindOf(kind)).machine) return { dir: folderOf(cwd, kind) };
+		const { discoveryCwd, project } = await host.folderCatalog(cwd, kindOf(kind), prefix);
+		return {
+			dir: discoveryCwd,
+			...project ? { project } : {}
+		};
+	};
+	const scanFlags = () => {
+		const settings = env.readSettings();
+		return {
+			settings,
+			foreignAgents: settings.importForeignConfigs === true,
+			ruler: settings.importRulerConfigs !== false
+		};
+	};
+	const plugins = async (dir, config) => {
+		const { plugins: found } = await discoverProjectPlugins({
+			cwd: dir,
+			prefix: config.prefix,
+			...config.pluginScanPaths.length > 0 ? { extraRoots: config.pluginScanPaths } : {}
+		});
+		return found;
+	};
+	return {
+		"catalog.skills": async (p) => {
+			const { dir, project } = await catalogOf(p?.cwd, p?.kind, env.config.prefix);
+			const config = await env.runtimeConfig(dir);
+			const { settings, foreignAgents, ruler } = scanFlags();
+			const [found, discovered] = await Promise.all([discoverProjectSkills({
+				cwd: dir,
+				prefix: config.prefix,
+				foreignAgents,
+				ruler
+			}), plugins(dir, config)]);
+			const machineNames = new Set((project?.skills ?? []).map((skill) => skill.name));
+			const disk = [...project?.skills ?? [], ...found.filter((skill) => !machineNames.has(skill.name))];
+			const pluginSkills = buildPluginContributions({
+				discovered,
+				...settings.enabledPlugins !== void 0 ? { enabled: settings.enabledPlugins } : {}
+			}).skills;
+			return { skills: skillEntries({
+				disk,
+				plugin: pluginSkills,
+				extension: filterRegistryPlugins(config.extensions, settings.enabledPlugins, new Set(discovered.map((d) => d.name))).skills,
+				settings
+			}) };
+		},
+		"catalog.mcps": async (p) => {
+			const { dir, project } = await catalogOf(p?.cwd, p?.kind, env.config.prefix);
+			const config = await env.runtimeConfig(dir);
+			const { settings, foreignAgents, ruler } = scanFlags();
+			const { servers: found, errors } = discoverProjectMcps({
+				cwd: dir,
+				prefix: config.prefix,
+				foreignAgents,
+				ruler
+			});
+			const machineNames = new Set((project?.mcps ?? []).map((server) => server.config.name));
+			return mcpEntries([...project?.mcps ?? [], ...found.filter((server) => !machineNames.has(server.config.name))], errors, settings);
+		},
+		"catalog.extensions": async (p) => {
+			const config = await env.runtimeConfig(folderOf(p?.cwd, p?.kind));
+			return { extensions: extensionEntries(config.extensions.loaded, config.extensions.inactive, env.readSettings()) };
+		},
+		"catalog.plugins": async (p) => {
+			const dir = folderOf(p?.cwd, p?.kind);
+			const config = await env.runtimeConfig(dir);
+			return { plugins: pluginEntries(await plugins(dir, config), config.extensions.plugins, env.readSettings()) };
+		},
+		"models.list": async (p) => {
+			const config = p?.cwd ? await env.runtimeConfig(folderOf(p.cwd, p.kind)) : env.config;
+			return { providers: detectAuth(env.userDataDir(), config.providers).filter((auth) => auth.available).map((auth) => ({
+				key: auth.key,
+				label: config.providers[auth.key]?.label ?? auth.label,
+				models: JSON.parse(JSON.stringify(config.modelsFor(auth.key)))
+			})) };
+		}
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/chat.ts
+function createChatHandlers({ host, clearDraft }) {
+	return {
+		"chat.send": async (p, peer) => {
+			const { wake: _stripped, keepDraft, ...params } = p;
+			const result = await host.sendPrompt(params);
+			if (!keepDraft) 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);
+			if (!p.keepDraft) clearDraft(p.sessionId, peer);
+			return result;
+		},
+		"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),
+		"commands.list": (p) => host.listCommands(p.cwd, typeof p.kind === "string" ? p.kind : void 0),
+		"commands.completeArgs": (p) => host.completeCommandArgs(p.cwd, p.name, p.argsPrefix, typeof p.kind === "string" ? p.kind : void 0)
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/context.ts
+function createContextHandlers({ host }) {
+	return {
+		"sessions.systemMd": (p) => host.sessionSystemMd(p.sessionId),
+		"sessions.contextSegments": (p) => host.getContextSegments(p.sessionId),
+		"sessions.createSystemOverride": (p) => host.createSystemOverride(p.sessionId),
+		"sessions.contextBreakdown": (p) => host.getContextBreakdown(p.sessionId)
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/daemon.ts
+function createDaemonHandlers({ host, appVersion, startedAt, lifecycle, identity }) {
+	return {
+		"daemon.info": () => ({
+			protocolVersion: 13,
+			appVersion,
+			pid: process.pid,
+			startedAt,
+			...identity
+		}),
+		"daemon.shutdown": async (p) => {
+			if (p?.whenIdle === true && host.hasActiveWork()) {
+				lifecycle.retireWhenIdle();
+				return { deferred: true };
+			}
+			setImmediate(lifecycle.shutdown);
+		}
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/drafts.ts
+/**
+* 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 = 25165824;
+	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;
+}
+function createDraftHandlers({ broadcastExcept }) {
+	/**
+	* 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();
+	/** 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;
+	}
+	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: []
+		});
+	}
+	/** 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);
+	}
+	return {
+		methods: {
+			"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, 65536) : "";
+				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, 4096) : "";
+				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
+				});
+			},
+			"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 > 100663296) 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
+				});
+			}
+		},
+		clearDraft,
+		forget: (sessionId) => {
+			drafts.delete(sessionId);
+		}
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/sessions.ts
+async function loadOrThrow(store, sessionId) {
+	const data = await store.load(sessionId);
+	if (!data) throw new Error(`Session "${sessionId}" not found.`);
+	return data;
+}
+function createSessionHandlers({ host, store, broadcast, forgetSession, hostId, workspace }) {
+	const stamp = (row) => hostId ? {
+		...row,
+		hostId
+	} : row;
+	/**
+	* 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(store, sessionId);
+		mutate(data);
+		data.updatedAt = Date.now();
+		await store.save(data);
+		broadcast({
+			kind: "sessions:changed",
+			op: "update",
+			sessionId
+		});
+	}
+	async function createSessionRow(params) {
+		const metadata = creationMetadata(params);
+		const onMachine = params.environment?.kind ? host.environments.get(params.environment.kind)?.checkFolder !== void 0 : false;
+		const cwd = workspace?.describe().confined && !onMachine ? workspace.sessionFolder(params.cwd ?? "") : params.cwd;
+		const id = await host.createSession({
+			cwd,
+			...metadata ? { metadata } : {},
+			...params.title ? { title: params.title } : {},
+			...params.agentId ? { agentId: params.agentId } : {},
+			...params.providerKey && params.modelId ? {
+				providerKey: params.providerKey,
+				modelId: params.modelId
+			} : {},
+			...params.fallbacks ? { fallbacks: params.fallbacks } : {},
+			...params.extensionEdit ? { extensionEdit: true } : {},
+			...params.skillEdit?.name ? { skillEdit: { name: params.skillEdit.name } } : {},
+			...params.environment?.kind ? { environment: {
+				kind: params.environment.kind,
+				...params.environment.branch ? { branch: params.environment.branch } : {},
+				...params.environment.base ? { base: params.environment.base } : {}
+			} } : {}
+		});
+		const data = await loadOrThrow(store, id);
+		broadcast({
+			kind: "sessions:changed",
+			op: "create",
+			sessionId: id
+		});
+		return stamp(toRow(host, data));
+	}
+	return {
+		"sessions.list": async (p) => (await listSessionRows(host, store, p)).map(stamp),
+		"sessions.create": (p) => createSessionRow(p),
+		"sessions.delete": async (p) => {
+			forgetSession(p.sessionId);
+			const { environment } = await host.deleteSession(p.sessionId);
+			broadcast({
+				kind: "sessions:changed",
+				op: "delete",
+				sessionId: p.sessionId
+			});
+			return environment.removed && !environment.reason ? {} : { environment };
+		},
+		"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.setFolder": (p) => {
+			const cwd = typeof p.cwd === "string" ? p.cwd : "";
+			return host.setSessionFolder(p.sessionId, cwd);
+		}
+	};
+}
+/** The creation-time metadata a client may stamp: the pick's effort and options, pinned skills. */
+function creationMetadata(params) {
+	const metadata = {};
+	if (typeof params.effort === "string") metadata.effort = params.effort;
+	if (params.modelOptions && typeof params.modelOptions === "object") {
+		const options = Object.fromEntries(Object.entries(params.modelOptions).filter(([, on]) => typeof on === "boolean"));
+		if (Object.keys(options).length > 0) metadata.modelOptions = options;
+	}
+	if (Array.isArray(params.pinnedSkills)) {
+		const pins = readPinnedSkills(params.pinnedSkills.slice(0, 64));
+		if (pins.size > 0) metadata[PINNED_SKILLS_META_KEY] = pinnedSkillsValue(pins);
+	}
+	return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
+async function listSessionRows(host, store, 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,
+			...(() => {
+				const environment = sessionEnvironmentSummary(md);
+				return environment ? { environment } : {};
+			})(),
+			...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(host, data));
+	}
+	return applyArchive(rows);
+}
+function toRow(host, 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,
+		...(() => {
+			const environment = sessionEnvironmentSummary(meta);
+			return environment ? { environment } : {};
+		})(),
+		...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 } : {};
+		})()
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/environments.ts
+function createEnvironmentHandlers({ host, env, setSettings }) {
+	return {
+		"sessions.retryEnvironment": async (p) => {
+			await loadOrThrow(env.store, p.sessionId);
+			await host.retryEnvironment(p.sessionId, { background: true });
+		},
+		"sessions.environmentActions": (p) => host.listEnvironmentActions(p.sessionId),
+		"sessions.runEnvironmentAction": (p) => host.runEnvironmentAction(p.sessionId, p.actionId),
+		"environments.list": (p) => host.listEnvironments(p.cwd ?? "", typeof p.kind === "string" ? p.kind : void 0),
+		"environments.verify": (p) => host.verifyEnvironment(p.kind),
+		"environments.update": async (p, peer) => {
+			const write = applyEnvironmentSettingsChange(host.environments, env.readSettings(), p);
+			for (const secret of write.secrets) host.environmentSecrets.set(p.kind, secret.key, secret.value);
+			await setSettings({ patch: write.settingsPatch }, peer);
+		}
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/extensions.ts
+function createExtensionHandlers({ env, broadcastExcept }) {
+	return { "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(env.store, 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
+		});
+	} };
+}
+//#endregion
+//#region src/ipc/daemon/handlers/fs.ts
+function createFsHandlers({ workspace }) {
+	return {
+		"fs.roots": () => workspace.describe(),
+		"fs.listDirs": (p) => workspace.list(optionalString(p?.path, "path"))
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/history.ts
+const SEARCH_INDEX_CACHE_MAX = 64;
+function createHistoryHandlers({ host, store }) {
+	/** 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 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;
+	}
+	return {
+		"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;
+		}
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/hitl.ts
+function createHitlHandlers({ host }) {
+	return {
+		"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()
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/launch-overrides.ts
+/**
+* A confined host (a server) drops a `cwd` outside its workspace roots
+* itself (`ChatHost.setLaunchOverrides`): a window's own folder is a path on
+* ITS machine, which the session must not move to.
+*/
+function createLaunchOverrideHandlers({ host }) {
+	/**
+	* Each client's launch overrides per session, oldest setter first. The
+	* session runs the most recent connected setter's; a client clearing, or
+	* disconnecting, drops only its own, and the previous setter's apply again.
+	*/
+	const launchOverridesByPeer = /* @__PURE__ */ new Map();
+	/** Run the latest connected setter's overrides (see `launchOverridesByPeer`). */
+	const applyLaunchOverrides = (sessionId) => {
+		const setters = launchOverridesByPeer.get(sessionId);
+		const latest = setters ? [...setters.values()].at(-1) : void 0;
+		if (!latest) launchOverridesByPeer.delete(sessionId);
+		host.setLaunchOverrides(sessionId, latest ?? null);
+	};
+	return {
+		methods: { "sessions.setLaunchOverrides": (p, peer) => {
+			const { sessionId, ...rest } = p;
+			const next = normalizeLaunchOverrides(rest);
+			const setters = launchOverridesByPeer.get(sessionId) ?? /* @__PURE__ */ new Map();
+			setters.delete(peer);
+			if (next) setters.set(peer, next);
+			launchOverridesByPeer.set(sessionId, setters);
+			applyLaunchOverrides(sessionId);
+		} },
+		releasePeer(peer) {
+			for (const [sessionId, setters] of launchOverridesByPeer) if (setters.delete(peer)) applyLaunchOverrides(sessionId);
+		},
+		forget(sessionId) {
+			launchOverridesByPeer.delete(sessionId);
+		}
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/machine-serve.ts
+/**
+* Executors kept between their connections (tasks, terminals), keyed by the
+* token that attached them and the host id it named: a host id is the
+* client's word, so another token naming it gets an executor of its own,
+* never the first one's tasks, terminals or exits. Each token holds at most
+* {@link MAX_PER_PRINCIPAL} and evicts only its own idle ones.
+*/
+const MAX_PER_PRINCIPAL = 4;
+const MAX_ATTACHED_HOSTS = 32;
+var MachineServeError = class extends Error {
+	code = MachineErrorCode.MethodNotAllowed;
+};
+/** A capacity limit: the client retries later (`../../machine/reverse.ts`). */
+var MachineServeBusyError = class extends MachineServeError {
+	code = MachineErrorCode.Busy;
+};
+/** Who attached: the token's id (`''` on a host without auth, a loopback test server). */
+const principalOf = (peer) => peer.principal ?? "";
+function createMachineServeHandlers(input) {
+	const { host } = input;
+	const allowed = () => input.options?.allowed() === true;
+	const served = /* @__PURE__ */ new Map();
+	const byPeer = /* @__PURE__ */ new Map();
+	const roots = () => {
+		const { roots: list, confined } = host.workspace;
+		if (!confined || list.length === 0) throw new MachineServeError("This host has no workspace roots to lend.");
+		return [...list];
+	};
+	/** Make room for one more of `principal`'s: its own idle executor goes, never another token's. */
+	const makeRoom = (principal) => {
+		const own = [...served].filter(([, entry]) => entry.principal === principal);
+		if (own.length < MAX_PER_PRINCIPAL && served.size < MAX_ATTACHED_HOSTS) return;
+		const idle = own.find(([, entry]) => entry.peer === null);
+		if (!idle) throw new MachineServeBusyError(own.length >= MAX_PER_PRINCIPAL ? `This token already has ${MAX_PER_PRINCIPAL} hosts attached here.` : `This server already lends itself to ${MAX_ATTACHED_HOSTS} hosts.`);
+		served.delete(idle[0]);
+		idle[1].executor.close();
+	};
+	async function executorFor(hostId, peer) {
+		const principal = principalOf(peer);
+		const key = `${principal}:${hostId}`;
+		const existing = served.get(key);
+		if (existing) {
+			const previous = existing.peer;
+			if (previous && previous !== peer) byPeer.delete(previous);
+			existing.peer = peer;
+			return existing.executor;
+		}
+		makeRoom(principal);
+		const { createMachineExecutor } = await import("./executor-Cx5-8yqi.js");
+		const entry = {
+			peer,
+			principal,
+			executor: void 0
+		};
+		entry.executor = createMachineExecutor({
+			roots: roots().map((path) => ({ path })),
+			dataDir: join(input.dataDir(), "machine-self"),
+			sandbox: input.settings(),
+			credentialsDataDir: input.dataDir(),
+			notify: (method, params) => {
+				const target = entry.peer;
+				if (!target || !input.isConnected(target)) return false;
+				target.send({
+					kind: "machine:notification",
+					method,
+					params
+				});
+				return true;
+			}
+		});
+		served.set(key, entry);
+		return entry.executor;
+	}
+	const attachedOf = (peer) => {
+		const key = byPeer.get(peer);
+		const entry = key ? served.get(key) : void 0;
+		if (!entry || entry.peer !== peer) throw new MachineServeError("Send machine.attach first on this connection.");
+		return entry;
+	};
+	return {
+		allowed,
+		methods: {
+			"machine.attach": async (p, peer) => {
+				if (!allowed()) throw new MachineServeError("This server does not lend itself as a machine (allowAsMachine is off).");
+				if (typeof p.hostId !== "string" || !/^[\w-]{1,64}$/.test(p.hostId)) throw new MachineServeError("machine.attach: \"hostId\" must be 1 to 64 letters, digits, \"-\" or \"_\".");
+				const executor = await executorFor(p.hostId, peer);
+				byPeer.set(peer, `${principalOf(peer)}:${p.hostId}`);
+				executor.linkUp();
+				const { machineIdentity } = await import("./identity-CwfO8K-t.js").then((n) => n.t);
+				return {
+					machineId: machineIdentity(join(input.dataDir(), "machine-self")),
+					name: toMachineName(input.hostName),
+					roots: roots().map((path) => ({ path })),
+					capabilities: {
+						shell: true,
+						terminals: typeof globalThis.Bun !== "undefined",
+						background: true,
+						worktrees: true,
+						stream: true,
+						sandboxed: executor.sandbox.on
+					},
+					version: ZIDANE_VERSION,
+					protocolVersion: 1
+				};
+			},
+			"machine.call": async (p, peer) => {
+				if (!allowed()) throw new MachineServeError("This server does not lend itself as a machine (allowAsMachine is off).");
+				if (typeof p.method !== "string") throw new MachineServeError("machine.call: \"method\" must be a string.");
+				return await attachedOf(peer).executor.handle(p.method, p.params ?? {});
+			},
+			"machine.detach": (_p, peer) => {
+				const key = byPeer.get(peer);
+				if (!key) return { detached: false };
+				byPeer.delete(peer);
+				const entry = served.get(key);
+				if (entry?.peer === peer) {
+					entry.peer = null;
+					entry.executor.linkLost();
+				}
+				return { detached: true };
+			}
+		},
+		releasePeer(peer) {
+			const key = byPeer.get(peer);
+			if (!key) return;
+			byPeer.delete(peer);
+			const entry = served.get(key);
+			if (entry?.peer === peer) {
+				entry.peer = null;
+				entry.executor.linkLost();
+			}
+		}
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/oauth-flows.ts
+/** How long a flow waits for its code. */
+const OAUTH_FLOW_TTL_MS = 6e5;
+/** Open flows per connection. */
+const MAX_FLOWS_PER_PEER = 4;
+/** How long a login may take to produce its URL. */
+const BEGIN_TIMEOUT_MS = 3e4;
+function stepChannel(signal) {
+	let current;
+	const waiters = [];
+	return {
+		ask: (step) => new Promise((resolve, reject) => {
+			if (signal.aborted) return reject(/* @__PURE__ */ new Error("The sign-in was cancelled."));
+			const full = {
+				...step,
+				id: randomBytes(9).toString("base64url")
+			};
+			current = {
+				step: full,
+				resolve
+			};
+			signal.addEventListener("abort", () => reject(/* @__PURE__ */ new Error("The sign-in was cancelled.")), { once: true });
+			for (const waiter of waiters.splice(0)) waiter(full);
+		}),
+		pending: () => current?.step,
+		next: () => current ? Promise.resolve(current.step) : new Promise((resolve) => waiters.push(resolve)),
+		answer(stepId, value) {
+			const step = current?.step;
+			if (!step || step.id !== stepId) throw new Error("That sign-in is not waiting on this question (answered already, or another one).");
+			if (step.kind === "select" && value !== void 0 && !step.options.some((option) => option.id === value)) throw new InvalidParamsError(`"${value}" is not one of the choices.`);
+			if (step.kind === "prompt" && (value === void 0 || value.trim() === "" && !step.allowEmpty)) throw new InvalidParamsError("That question needs an answer.");
+			const { resolve } = current;
+			current = void 0;
+			resolve(value);
+		}
+	};
+}
+function deferred() {
+	let resolve;
+	return {
+		promise: new Promise((r) => {
+			resolve = r;
+		}),
+		resolve
+	};
+}
+const LOOPBACK_HOSTS = /* @__PURE__ */ new Set([
+	"127.0.0.1",
+	"localhost",
+	"[::1]",
+	"::1"
+]);
+/** `http://<loopback>:<port>/<path>`, nothing else: where an MCP sign-in may send the browser. */
+function loopbackRedirect(raw) {
+	let url;
+	try {
+		url = typeof raw === "string" ? new URL(raw) : void 0;
+	} catch {}
+	if (!url || url.protocol !== "http:" || !LOOPBACK_HOSTS.has(url.hostname) || !url.port || url.username || url.password || url.search || url.hash) throw new InvalidParamsError("redirectUri must be a loopback URL on the client (http://127.0.0.1:<port>/callback).");
+	return url.toString();
+}
+/** `state` in what a user pasted: a callback URL, a `code=…&state=…` query, or Anthropic's `code#state`. */
+function stateIn(input) {
+	const value = input.trim();
+	try {
+		return new URL(value).searchParams.get("state") ?? void 0;
+	} catch {}
+	if (value.includes("#")) return value.split("#", 2)[1];
+	if (value.includes("state=")) return new URLSearchParams(value).get("state") ?? void 0;
+}
+/** The code in a pasted callback URL / query / `code#state`. */
+function codeIn(input) {
+	const value = input.trim();
+	try {
+		return new URL(value).searchParams.get("code") ?? void 0;
+	} catch {}
+	if (value.includes("#")) return value.split("#", 2)[0];
+	if (value.includes("code=")) return new URLSearchParams(value).get("code") ?? void 0;
+	return value || void 0;
+}
+function isLoopbackUrl(raw) {
+	if (!raw) return false;
+	try {
+		const url = new URL(raw);
+		return url.protocol === "http:" && LOOPBACK_HOSTS.has(url.hostname);
+	} catch {
+		return false;
+	}
+}
+/** What a provider's manual-input path reads: the pasted text, or the callback URL rebuilt from a code + state. */
+function manualInput(delivery, redirectUri) {
+	if ("input" in delivery) return delivery.input;
+	const query = new URLSearchParams({
+		code: delivery.code,
+		...delivery.state !== void 0 ? { state: delivery.state } : {}
+	}).toString();
+	return redirectUri ? `${redirectUri}?${query}` : query;
+}
+/** First of: what the login produced, its early end, a timeout, the abort. */
+async function firstOf(started, login, signal) {
+	let timer;
+	try {
+		return await Promise.race([
+			started,
+			login.then(() => {
+				throw new Error("The sign-in finished without a browser step (already signed in?).");
+			}),
+			new Promise((_, reject) => {
+				timer = setTimeout(reject, BEGIN_TIMEOUT_MS, /* @__PURE__ */ new Error(`The sign-in did not produce an authorization URL within ${BEGIN_TIMEOUT_MS / 1e3}s.`));
+				signal.addEventListener("abort", () => reject(/* @__PURE__ */ new Error("The sign-in was cancelled.")), { once: true });
+			})
+		]);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/**
+* A provider's login, running here for a client: its URL (once known), its
+* questions, the code the client delivers, its stored result. Refused for a
+* provider that would listen on this machine (see the module header).
+*/
+function startProviderLogin(auth, provider) {
+	const descriptor = auth.descriptorOf(provider);
+	if (!descriptor.oauthProvider) throw new Error(`OAuth not supported for ${descriptor.label} (${descriptor.key}). Use an API key instead.`);
+	if (!canSignInRemotely(descriptor.oauthProvider)) throw new Error(`${descriptor.label}'s sign-in can't run from another computer: it waits for the browser on a port of the server's own machine. Sign in on the server machine or use an API key.`);
+	const abort = new AbortController();
+	const code = deferred();
+	const steps = stepChannel(abort.signal);
+	const url = deferred();
+	const login = runOAuthLogin(descriptor, {
+		onUrl: (u, instructions) => url.resolve({
+			url: u,
+			...instructions ? { instructions } : {}
+		}),
+		onDeviceCode: (info) => url.resolve({
+			url: info.verificationUri,
+			userCode: info.userCode,
+			device: true
+		}),
+		onManualCodeInput: () => code.promise,
+		onPrompt: (prompt) => steps.ask({
+			kind: "prompt",
+			message: prompt.message,
+			...prompt.placeholder ? { placeholder: prompt.placeholder } : {},
+			...prompt.allowEmpty ? { allowEmpty: true } : {}
+		}).then((value) => value ?? ""),
+		onSelect: (prompt) => steps.ask({
+			kind: "select",
+			message: prompt.message,
+			options: prompt.options.map((option) => ({
+				id: option.id,
+				label: option.label
+			}))
+		}),
+		signal: abort.signal,
+		callbackServer: false,
+		openBrowser: false
+	});
+	login.catch(() => void 0);
+	let redirectUri;
+	const started = url.promise.then((first) => {
+		if (!first.device) {
+			const redirect = new URL(first.url).searchParams.get("redirect_uri");
+			if (isLoopbackUrl(redirect)) redirectUri = redirect;
+		}
+		return {
+			url: first.url,
+			mode: first.device ? "device" : redirectUri ? "loopback" : "browser",
+			...redirectUri ? { redirectUri } : {},
+			...first.userCode ? { userCode: first.userCode } : {},
+			...first.instructions ? { instructions: first.instructions } : {}
+		};
+	});
+	started.catch(() => void 0);
+	return {
+		login,
+		abort,
+		result: login.then((credentials) => {
+			setProviderCredential(auth.dataDir(), descriptor, {
+				kind: "oauth",
+				...credentials
+			});
+			auth.applied(descriptor);
+			return { provider: auth.statusOf(descriptor.key) };
+		}),
+		steps,
+		started,
+		deliver: (delivery) => code.resolve(manualInput(delivery, redirectUri))
+	};
+}
+/** The flow `flowId` names, if it exists and belongs to this connection. */
+function flowOf(flows, flowId, peer) {
+	const flow = typeof flowId === "string" ? flows.get(flowId) : void 0;
+	if (!flow) throw new Error("No sign-in with that id: it finished, expired or was cancelled. Start it again.");
+	if (flow.peer !== peer) throw new Error("That sign-in belongs to another connection.");
+	return flow;
+}
+/** Hand the flow its code (from the client's loopback) or pasted input, once, after checking its `state`. */
+function deliverCode(flow, p, end) {
+	const code = typeof p.code === "string" && p.code !== "" ? p.code : void 0;
+	const input = typeof p.input === "string" && p.input.trim() !== "" ? p.input : void 0;
+	if (code === void 0 && input === void 0) return;
+	if (flow.delivered) throw new Error("That sign-in already received its code.");
+	const state = code !== void 0 ? typeof p.state === "string" ? p.state : void 0 : stateIn(input);
+	if (flow.expectedState !== void 0 && (state !== void 0 || code !== void 0) && state !== flow.expectedState) {
+		end(flow, "OAuth state mismatch.");
+		throw new Error("OAuth state mismatch: the sign-in was refused. Start it again.");
+	}
+	flow.delivered = true;
+	flow.deliver(code !== void 0 ? {
+		code,
+		...state !== void 0 ? { state } : {}
+	} : { input });
+}
+function createOAuthFlowHandlers({ host, env, auth, isConnected, ttlMs = OAUTH_FLOW_TTL_MS }) {
+	const flows = /* @__PURE__ */ new Map();
+	const end = (flow, reason) => {
+		clearTimeout(flow.timer);
+		flows.delete(flow.id);
+		if (!flow.abort.signal.aborted) flow.abort.abort(new Error(reason));
+	};
+	/** Register a flow whose login is already running; it ends at expiry, on cancel, or once settled and collected. */
+	function register(peer, parts) {
+		const id = randomBytes(24).toString("base64url");
+		const flow = {
+			id,
+			peer,
+			expiresAt: Date.now() + ttlMs,
+			delivered: false,
+			...parts,
+			timer: void 0
+		};
+		flow.timer = setTimeout(end, ttlMs, flow, "The sign-in expired.");
+		flow.timer.unref?.();
+		flow.result.catch(() => void 0);
+		flows.set(id, flow);
+		return flow;
+	}
+	const ownFlows = (peer) => [...flows.values()].filter((flow) => flow.peer === peer);
+	/** MCP begins in flight per connection: counted against the cap before their flow registers. */
+	const startingMcp = /* @__PURE__ */ new Map();
+	async function beginProvider(peer, provider) {
+		const { login, ...parts } = startProviderLogin(auth, provider);
+		const flow = register(peer, parts);
+		try {
+			return await stateOf(flow, login);
+		} catch (err) {
+			end(flow, "The sign-in did not start.");
+			throw err;
+		}
+	}
+	/** The flow's URL, or the question it waits on first; its `state` and redirect recorded once the URL is known. */
+	async function stateOf(flow, login) {
+		const steps = flow.steps;
+		const next = await firstOf(Promise.race([flow.started.then((begin) => ({ begin })), steps.next().then((step) => ({ step }))]), login, flow.abort.signal);
+		if ("step" in next) return {
+			flowId: flow.id,
+			url: "",
+			mode: "step",
+			step: next.step,
+			expiresAt: flow.expiresAt
+		};
+		const begin = next.begin;
+		flow.begun = begin;
+		if (begin.mode !== "device") {
+			flow.expectedState = new URL(begin.url).searchParams.get("state") ?? void 0;
+			if (begin.redirectUri) flow.redirectUri = begin.redirectUri;
+		}
+		return {
+			flowId: flow.id,
+			...begin,
+			expiresAt: flow.expiresAt
+		};
+	}
+	async function beginMcp(peer, p) {
+		const redirectUri = loopbackRedirect(p.redirectUri);
+		const dir = catalogFolder({
+			env,
+			host
+		}, p.cwd, p.kind);
+		const config = await env.runtimeConfig(dir);
+		const settings = env.readSettings();
+		const { servers } = discoverProjectMcps({
+			cwd: dir,
+			prefix: config.prefix,
+			foreignAgents: settings.importForeignConfigs === true,
+			ruler: settings.importRulerConfigs !== false
+		});
+		const entry = servers.find((server) => server.config.name === p.mcpServer)?.config;
+		if (!entry) throw new Error(`No MCP server "${p.mcpServer}" in that folder's catalog.`);
+		const abort = new AbortController();
+		const state = randomBytes(24).toString("base64url");
+		const callbackCode = deferred();
+		const started = deferred();
+		const login = loginMcpServer(entry, {
+			store: env.mcpCredentialStore?.() ?? createFileMcpCredentialStore(env.userDataDir()),
+			signal: abort.signal,
+			state,
+			timeoutMs: ttlMs,
+			callback: {
+				redirectUri,
+				promise: callbackCode.promise,
+				close: async () => void 0
+			},
+			onAuthorizationUrl: (url) => started.resolve({ url: url.toString() })
+		});
+		login.catch(() => void 0);
+		const first = await firstOf(started.promise, login, abort.signal).catch((err) => {
+			abort.abort();
+			throw err;
+		});
+		const flow = register(peer, {
+			abort,
+			result: login.then(() => {
+				host.rebuildAllAgents({ rediscover: true }).catch(() => void 0);
+				return { mcpServer: entry.name };
+			}),
+			expectedState: state,
+			redirectUri,
+			deliver: (delivery) => {
+				if ("input" in delivery) {
+					const code = codeIn(delivery.input);
+					const pastedState = stateIn(delivery.input);
+					if (code) callbackCode.resolve({
+						code,
+						...pastedState !== void 0 ? { state: pastedState } : {}
+					});
+					return;
+				}
+				callbackCode.resolve(delivery);
+			}
+		});
+		return {
+			flowId: flow.id,
+			url: first.url,
+			mode: "loopback",
+			redirectUri,
+			expiresAt: flow.expiresAt
+		};
+	}
+	return {
+		methods: {
+			"auth.oauth.begin": async (p, peer) => {
+				const target = [p.provider, p.mcpServer].filter((value) => value !== void 0);
+				if (target.length !== 1 || typeof target[0] !== "string" || target[0] === "") throw new InvalidParamsError("auth.oauth.begin needs exactly one of \"provider\" or \"mcpServer\".");
+				if (ownFlows(peer).length + (startingMcp.get(peer) ?? 0) >= MAX_FLOWS_PER_PEER) throw new Error(`This connection already has ${MAX_FLOWS_PER_PEER} sign-ins open: finish or cancel one first.`);
+				let begun;
+				if (p.provider !== void 0) begun = await beginProvider(peer, p.provider);
+				else {
+					startingMcp.set(peer, (startingMcp.get(peer) ?? 0) + 1);
+					try {
+						begun = await beginMcp(peer, {
+							mcpServer: p.mcpServer,
+							...p.cwd !== void 0 ? { cwd: p.cwd } : {},
+							...p.kind !== void 0 ? { kind: p.kind } : {},
+							...p.redirectUri !== void 0 ? { redirectUri: p.redirectUri } : {}
+						});
+					} finally {
+						const left = (startingMcp.get(peer) ?? 1) - 1;
+						if (left > 0) startingMcp.set(peer, left);
+						else startingMcp.delete(peer);
+					}
+				}
+				if (!isConnected(peer)) {
+					const flow = flows.get(begun.flowId);
+					if (flow) end(flow, "The connection closed.");
+				}
+				return begun;
+			},
+			"auth.oauth.complete": async (p, peer) => {
+				const flow = flowOf(flows, p.flowId, peer);
+				deliverCode(flow, p, end);
+				let asking = false;
+				try {
+					const outcome = await (flow.steps ? Promise.race([flow.result, flow.steps.next().then((step) => ({ step }))]) : flow.result);
+					asking = outcome.step !== void 0;
+					return outcome;
+				} catch (err) {
+					throw new Error(flow.abort.signal.aborted && flow.abort.signal.reason instanceof Error ? flow.abort.signal.reason.message : err instanceof Error ? err.message : String(err));
+				} finally {
+					if (!asking) end(flow, "The sign-in finished.");
+				}
+			},
+			"auth.oauth.respond": async (p, peer) => {
+				const flow = flowOf(flows, p.flowId, peer);
+				if (!flow.steps || typeof p.stepId !== "string") throw new InvalidParamsError("auth.oauth.respond needs the flow's \"stepId\".");
+				if (p.value !== void 0 && typeof p.value !== "string") throw new InvalidParamsError("\"value\" must be a string.");
+				const cancelled = p.value === void 0 && flow.steps.pending()?.kind === "select";
+				flow.steps.answer(p.stepId, p.value);
+				if (cancelled) {
+					end(flow, "The sign-in was cancelled.");
+					throw new Error("The sign-in was cancelled (no choice made).");
+				}
+				return flow.begun ? {
+					flowId: flow.id,
+					...flow.begun,
+					expiresAt: flow.expiresAt
+				} : stateOf(flow, flow.result);
+			},
+			"auth.oauth.cancel": (p, peer) => {
+				const flow = typeof p.flowId === "string" ? flows.get(p.flowId) : void 0;
+				if (!flow || flow.peer !== peer) return { cancelled: false };
+				end(flow, "The sign-in was cancelled.");
+				return { cancelled: true };
+			}
+		},
+		releasePeer(peer) {
+			for (const flow of ownFlows(peer)) end(flow, "The connection closed.");
+		}
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/orchestration.ts
+function createOrchestrationHandlers({ host }) {
+	return {
+		"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)
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/presence.ts
+function createPresenceHandlers({ env, peers }) {
+	return {
+		"presence.list": () => peers.computePresence(),
+		"presence.watch": (p, peer) => {
+			peer.watching = p.sessionId;
+			peers.broadcastPresence();
+			env.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);
+		}
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/queue.ts
+function createQueueHandlers({ host, clearDraft }) {
+	return {
+		"queue.list": (p) => host.queueList(p.sessionId),
+		"queue.add": async (p, peer) => {
+			const text = typeof p.text === "string" ? p.text.slice(0, 65536) : "";
+			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);
+			if (p.keepDraft !== true) clearDraft(p.sessionId, peer);
+			return result;
+		},
+		"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, 65536) : "", updatedAttachments(p.attachments)),
+		"queue.attachments": (p) => host.queueAttachments(p.sessionId, p.id),
+		"queue.pushNow": (p) => host.queuePushNow(p.sessionId, p.id)
+	};
+}
+/**
+* The list `queue.update` stores in place of an entry's attachments. An entry
+* that is malformed or over the budget is refused, not dropped: the list
+* REPLACES what is stored, so a quietly shorter list would delete the rest.
+*/
+function updatedAttachments(list) {
+	if (!Array.isArray(list)) return void 0;
+	const bounded = boundAttachments(list);
+	if (bounded.length !== list.length) throw new InvalidParamsError("attachments: an entry is malformed, or the list is over 24 MiB.");
+	return bounded;
+}
+//#endregion
+//#region src/ipc/daemon/handlers/resume.ts
+function createResumeHandlers({ log }) {
+	return { "sessions.resume": (p) => {
+		if (p.epoch !== log.epoch) return {
+			ok: false,
+			reason: "epoch"
+		};
+		const signals = typeof p.afterSeq === "number" ? log.replay(p.sessionId, p.afterSeq) : null;
+		return signals ? {
+			ok: true,
+			signals
+		} : {
+			ok: false,
+			reason: "gap"
+		};
+	} };
+}
+//#endregion
+//#region src/ipc/daemon/handlers/session-reads.ts
+function pageBound(value, name, fallback, max) {
+	return Math.min(nonNegativeInt(value, name) ?? fallback, max);
+}
+function createSessionReadHandlers({ host, store, snapshots }) {
+	/** The document as the host holds it: the live copy (ahead of the store mid-run, and holding the todos), else the stored one. */
+	const documentOf = async (sessionId) => {
+		const live = host.getLiveSession(sessionId);
+		if (live) return live.toJSON();
+		const loaded = await loadSession(store, sessionId, { persistHeal: false });
+		return loaded ? loaded.toJSON() : null;
+	};
+	return {
+		"sessions.listMeta": (p) => {
+			const projectRoot = p?.projectRoot;
+			if (projectRoot !== void 0 && projectRoot !== null && typeof projectRoot !== "string") throw new InvalidParamsError("projectRoot must be a string or null.");
+			return listSessionMeta(store, projectRoot !== void 0 ? { projectRoot } : void 0);
+		},
+		"sessions.getMeta": (p) => getSessionMeta(store, sessionIdOf(p)),
+		"sessions.get": async (p) => {
+			const sessionId = sessionIdOf(p);
+			if (p.turns !== false) return documentOf(sessionId);
+			const snapshot = await snapshots.document(store, sessionId, host.getLiveSession(sessionId));
+			return snapshot && {
+				...snapshot.data,
+				turns: [],
+				version: snapshot.version
+			};
+		},
+		"sessions.getTurns": async (p) => {
+			const sessionId = sessionIdOf(p);
+			const snapshot = await snapshots.document(store, sessionId, host.getLiveSession(sessionId));
+			if (!snapshot) return null;
+			const from = pageBound(p.from, "from", 0, Number.MAX_SAFE_INTEGER);
+			const limit = Math.max(1, pageBound(p.limit, "limit", 200, SESSION_TURNS_MAX_PAGE));
+			const { turns } = snapshot.data;
+			return {
+				turns: turns.slice(from, from + limit),
+				total: turns.length,
+				version: snapshot.version
+			};
+		},
+		"sessions.getToolResult": async (p) => {
+			const sessionId = sessionIdOf(p);
+			if (typeof p.callId !== "string" || p.callId.length === 0) throw new InvalidParamsError("callId must be a non-empty string.");
+			const data = await documentOf(sessionId);
+			if (!data) return null;
+			const named = typeof p.turnId === "string" ? data.turns.filter((turn) => turn.id === p.turnId) : [];
+			for (const turn of [...named, ...[...data.turns].reverse()]) for (const block of turn.content) if (block.type === "tool_result" && block.callId === p.callId) return toolResultText(block.output);
+			return null;
+		},
+		"sessions.getHeader": async (p) => {
+			const sessionId = sessionIdOf(p);
+			const live = host.getLiveSession(sessionId);
+			if (p.usage !== true) return live ? headerFromData(live.toJSON()) : getSessionHeader(store, sessionId);
+			const data = live ? live.toJSON() : await store.load(sessionId);
+			if (!data) return null;
+			return {
+				...live ? headerFromData(data) : await getSessionHeader(store, sessionId) ?? headerFromData({
+					...data,
+					id: sessionId
+				}),
+				contextTokens: lastContextSizeFromTurns(data.turns, data.runs),
+				costUsd: sumRunCosts(data.runs)
+			};
+		},
+		"sessions.setExtensionState": async (p) => {
+			const sessionId = sessionIdOf(p);
+			if (typeof p.extension !== "string" || typeof p.key !== "string") throw new InvalidParamsError("extension and key must be strings.");
+			const session = host.getLiveSession(sessionId) ?? await loadSession(store, sessionId, { persistHeal: false });
+			if (!session) throw new Error(`Session "${sessionId}" not found.`);
+			if (p.value === void 0) await deleteExtensionSessionState(session, p.extension, p.key);
+			else await setExtensionSessionState(session, p.extension, p.key, p.value);
+		}
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/settings.ts
+/**
+* Settings the host reads when it BUILDS an agent (not per call): changing
+* one rebuilds the live agents. `enabledPlugins` applies the plugin gate;
+* a live agent would otherwise keep a disabled plugin's skills and stdio MCP
+* servers until something unrelated rebuilt it.
+*/
+const AGENT_BUILD_KEYS = [
+	"enabledMcps",
+	"disabledMcpTools",
+	"enabledSkills",
+	"enabledPlugins",
+	"importForeignConfigs",
+	"importRulerConfigs",
+	"artifacts"
+];
+function createSettingsHandlers({ host, env, broadcast }) {
+	return {
+		"runtime.reload": () => {
+			const disposeOld = env.forgetRuntime();
+			host.rebuildAllAgents().then(disposeOld, disposeOld);
+		},
+		"settings.get": () => env.readSettings(),
+		"settings.set": (p) => {
+			const patch = p?.patch;
+			if (typeof patch !== "object" || patch === null || Array.isArray(patch)) throw new InvalidParamsError("patch must be an object of settings.");
+			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")) {
+				const disposeOld = env.forgetRuntime();
+				host.rebuildAllAgents({ rediscover: true }).then(disposeOld, disposeOld);
+			} else if (AGENT_BUILD_KEYS.some(changed)) host.rebuildAllAgents({ rediscover: true }).catch(() => void 0);
+			if (changed("interactionMode") && next.interactionMode === "skip") host.interactions.resolveAutomatically();
+			host.applyAgentSettings(before, next);
+			broadcast({
+				kind: "settings:changed",
+				settings: next
+			});
+			return next;
+		}
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/suggest.ts
+function createSuggestHandlers({ env, broadcastExcept }) {
+	/**
+	* 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). Entries outlive their compute
+	* (the seq high-water mark), so the map is an LRU of 256 sessions:
+	* refusing new keys at the cap instead would switch suggestions off for
+	* every session past the 256th until the daemon restarts.
+	*/
+	const suggests = /* @__PURE__ */ new Map();
+	return {
+		methods: { "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, 65536) : "";
+			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
+			};
+			prev?.controller?.abort();
+			const controller = new AbortController();
+			const entry = {
+				seq,
+				controller
+			};
+			suggests.delete(sessionId);
+			suggests.set(sessionId, entry);
+			if (suggests.size > 256) {
+				const [oldest, evicted] = suggests.entries().next().value;
+				evicted.controller?.abort();
+				suggests.delete(oldest);
+			}
+			try {
+				const data = await loadOrThrow(env.store, sessionId);
+				const meta = data.metadata ?? {};
+				const cwd = typeof meta.cwd === "string" ? meta.cwd : data.projectRoot ?? "";
+				const config = await env.runtimeConfig(cwd);
+				const providers = [createPathAutocompleteProvider({ cwd: () => cwd }), ...config.extensions.inlineAutocompleteProviders];
+				const result = await resolveInlineSuggestion(providers, {
+					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;
+			}
+		} },
+		forget: (sessionId) => {
+			suggests.get(sessionId)?.controller?.abort();
+			suggests.delete(sessionId);
+		}
+	};
+}
+//#endregion
+//#region src/ipc/daemon/sync-apply.ts
+const MAX_SETTINGS_BYTES = 262144;
+const MAX_SYSTEM_MD_BYTES = 262144;
+const MAX_FILE_BYTES = 1048576;
+const MAX_SKILL_BYTES = 4194304;
+const MAX_FILES_BYTES = 16777216;
+const MAX_SKILL_FILES = 200;
+const MAX_SKILLS = 500;
+const MAX_PATH_DEPTH = 8;
+const MAX_SAFELIST_ENTRIES = 1e3;
+const MAX_ENTRY_LENGTH = 1e3;
+const NAME_RE = /^\w[\w@.-]{0,99}$/;
+const SEGMENT_RE = /^[^/\\\0]{1,255}$/;
+/** A skill file's relative path: plain segments, no `..`, bounded depth. */
+function checkRelativePath(path) {
+	if (typeof path !== "string" || path === "" || isAbsolute(path) || path.includes("\\")) return null;
+	const segments = path.split("/");
+	if (segments.length > MAX_PATH_DEPTH || segments.some((s) => s === "." || s === ".." || !SEGMENT_RE.test(s))) return null;
+	return segments.join("/");
+}
+/** Is `command` runnable here (an absolute path, or found on PATH)? Looks, never runs. */
+function commandAvailable(command) {
+	const executable = (path) => {
+		try {
+			accessSync(path, constants.X_OK);
+			return statSync(path).isFile();
+		} catch {
+			return false;
+		}
+	};
+	if (command.includes("/")) return isAbsolute(command) && executable(command);
+	return (process$1.env.PATH ?? "").split(delimiter).filter(Boolean).some((dir) => executable(join(dir, command)));
+}
+/** A folder's files, sorted, as one hash (symlinks hashed by target, never followed). Null when absent. */
+function hashDir(dir) {
+	let stat;
+	try {
+		stat = lstatSync(dir);
+	} catch {
+		return null;
+	}
+	if (!stat.isDirectory()) return `not-a-folder:${stat.mode}`;
+	const hash = createHash("sha256");
+	const walk = (at, depth) => {
+		if (depth > 9) return;
+		for (const name of readdirSync(at).sort()) {
+			const path = join(at, name);
+			const rel = relative(dir, path).split(sep).join("/");
+			const s = lstatSync(path);
+			if (s.isDirectory()) walk(path, depth + 1);
+			else if (s.isFile()) {
+				hash.update(`f:${rel}\0`);
+				hash.update(readFileSync(path));
+				hash.update("\0");
+			} else hash.update(`o:${rel}:${s.mode}\0`);
+		}
+	};
+	walk(dir, 0);
+	return hash.digest("hex");
+}
+/** The hash `hashDir` gives the folder these files make. */
+function hashFiles(files) {
+	const hash = createHash("sha256");
+	const sorted = [...files].sort((a, b) => compareWalkOrder(a.path, b.path));
+	for (const file of sorted) {
+		hash.update(`f:${file.path}\0`);
+		hash.update(file.bytes);
+		hash.update("\0");
+	}
+	return hash.digest("hex");
+}
+/** The order a sorted depth-first walk visits two relative paths. */
+function compareWalkOrder(a, b) {
+	const as = a.split("/");
+	const bs = b.split("/");
+	for (let i = 0; i < Math.min(as.length, bs.length); i++) if (as[i] !== bs[i]) return as[i] < bs[i] ? -1 : 1;
+	return as.length - bs.length;
+}
+function userSkillsRoot(ctx) {
+	return projectUserPaths({
+		subPath: "skills",
+		cwd: ctx.home(),
+		home: ctx.home(),
+		prefix: ctx.prefix()
+	}).find((p) => p.source === "user" && p.path.includes(`.${ctx.prefix().replace(/^\./, "")}`)).path;
+}
+function userMcpsPath(ctx) {
+	return mcpsWritePath("user", {
+		home: ctx.home(),
+		cwd: ctx.home(),
+		prefix: ctx.prefix()
+	});
+}
+function userExtensionDirs(ctx, name) {
+	return projectUserPaths({
+		subPath: "extensions",
+		cwd: ctx.home(),
+		home: ctx.home(),
+		prefix: ctx.prefix()
+	}).filter((p) => p.source === "user").map((p) => join(p.path, name));
+}
+/** Is `field` free to write? An override (now or found by a changed value) is not. */
+function writable(record, field, currentHash, result) {
+	if (record.overrides[field]) {
+		result.skipped.push({
+			field,
+			reason: "override"
+		});
+		return false;
+	}
+	const known = record.fields[field];
+	if (known?.hash !== void 0 && known.hash !== (currentHash ?? "absent")) {
+		record.overrides[field] = { at: Date.now() };
+		result.skipped.push({
+			field,
+			reason: "override"
+		});
+		return false;
+	}
+	return true;
+}
+function mark(record, field, category, fields) {
+	record.fields[field] = {
+		category,
+		syncedAt: Date.now(),
+		...fields
+	};
+}
+function pushSettings(ctx, record, payload, result) {
+	if (!isRecord(payload?.values)) throw new InvalidParamsError("settings: payload.values must be an object.");
+	if (JSON.stringify(payload.values).length > MAX_SETTINGS_BYTES) throw new InvalidParamsError(`settings: larger than ${MAX_SETTINGS_BYTES} bytes.`);
+	const current = ctx.env.readSettings();
+	const patch = {};
+	for (const [key, value] of Object.entries(payload.values)) {
+		const field = settingField(key);
+		if (!Object.hasOwn(DEFAULT_SETTINGS, key)) {
+			result.skipped.push({
+				field,
+				reason: "not a setting"
+			});
+			continue;
+		}
+		if (!isSyncableSetting(key)) {
+			result.skipped.push({
+				field,
+				reason: isWindowOnlySetting(key) ? "window-only setting" : "not synced"
+			});
+			continue;
+		}
+		const currentHash = hashValue(current[key]);
+		if (!writable(record, field, currentHash, result)) continue;
+		if (hashValue(value) === currentHash) {
+			mark(record, field, "settings", {
+				hash: currentHash,
+				sent: currentHash
+			});
+			result.unchanged.push(field);
+			continue;
+		}
+		patch[key] = value;
+	}
+	if (Object.keys(patch).length === 0) return;
+	const next = ctx.setters.setSettings(patch);
+	for (const key of Object.keys(patch)) {
+		mark(record, settingField(key), "settings", {
+			hash: hashValue(next[key]),
+			sent: hashValue(patch[key])
+		});
+		result.applied.push(settingField(key));
+	}
+}
+/** The project here a client's path names: the same folder inside a workspace root, else one folder of that name in a root. */
+function projectHere(ctx, clientPath) {
+	const roots = (ctx.env.workspaceRoots ?? []).map((root) => {
+		try {
+			return realpathSync(root);
+		} catch {
+			return null;
+		}
+	}).filter((r) => r !== null);
+	const inRoot = (path) => roots.some((root) => path === root || path.startsWith(root + sep));
+	const isDir = (path) => statSync(path, { throwIfNoEntry: false })?.isDirectory() === true;
+	if (isAbsolute(clientPath) && isDir(clientPath)) {
+		const real = realpathSync(clientPath);
+		if (inRoot(real)) return safelistProjectKey(real);
+	}
+	const name = basename(clientPath);
+	if (!name || name === "." || name === "..") return null;
+	const found = [...new Set(roots.map((root) => join(root, name)).filter(isDir).map((path) => realpathSync(path)))];
+	return found.length === 1 ? safelistProjectKey(found[0]) : null;
+}
+function pushSafelists(ctx, record, payload, result) {
+	if (!isRecord(payload?.projects)) throw new InvalidParamsError("safelists: payload.projects must map paths to entries.");
+	const dataDir = ctx.env.userDataDir();
+	const file = readProjects(dataDir);
+	let dirty = false;
+	for (const [clientPath, entries] of Object.entries(payload.projects)) {
+		const field = `safelist:${clientPath}`;
+		if (!Array.isArray(entries) || entries.length > MAX_SAFELIST_ENTRIES || !entries.every((e) => typeof e === "string" && e.length <= MAX_ENTRY_LENGTH)) {
+			result.skipped.push({
+				field,
+				reason: "invalid entries"
+			});
+			continue;
+		}
+		const target = projectHere(ctx, clientPath);
+		if (!target) {
+			result.skipped.push({
+				field,
+				reason: "no project of that path or name on this server"
+			});
+			continue;
+		}
+		const previous = record.fields[field]?.target === target ? record.fields[field]?.entries ?? [] : [];
+		const current = file[target]?.safelist ?? [];
+		const next = current.filter((entry) => !previous.includes(entry) || entries.includes(entry));
+		for (const entry of entries) if (!next.includes(entry)) next.push(entry);
+		mark(record, field, "safelists", {
+			target,
+			entries: [...entries]
+		});
+		if (JSON.stringify(next) === JSON.stringify(current)) {
+			result.unchanged.push(field);
+			continue;
+		}
+		file[target] = {
+			...file[target],
+			safelist: next
+		};
+		dirty = true;
+		result.applied.push(field);
+	}
+	if (dirty) writeProjects(dataDir, file);
+}
+/** A skill as checked bytes, or why it is refused. */
+function checkSkill(skill) {
+	const name = isRecord(skill) && typeof skill.name === "string" ? skill.name : "";
+	const field = `skill:${name}`;
+	if (!NAME_RE.test(name)) return {
+		field,
+		reason: "not a plain skill name"
+	};
+	const files = isRecord(skill) && Array.isArray(skill.files) ? skill.files : null;
+	if (!files || files.length === 0 || files.length > MAX_SKILL_FILES) return {
+		field,
+		reason: `needs 1 to ${MAX_SKILL_FILES} files`
+	};
+	const out = [];
+	let total = 0;
+	for (const file of files) {
+		const path = checkRelativePath(isRecord(file) ? file.path : void 0);
+		if (!path) return {
+			field,
+			reason: "a file path is not a plain relative path"
+		};
+		if (typeof file.data !== "string") return {
+			field,
+			reason: `${path}: no data`
+		};
+		const bytes = Buffer.from(file.data, "base64");
+		if (bytes.length > MAX_FILE_BYTES) return {
+			field,
+			reason: `${path} is larger than ${MAX_FILE_BYTES} bytes`
+		};
+		total += bytes.length;
+		if (out.some((f) => f.path === path || f.path.startsWith(`${path}/`) || path.startsWith(`${f.path}/`))) return {
+			field,
+			reason: `${path} appears twice`
+		};
+		out.push({
+			path,
+			bytes
+		});
+	}
+	if (total > MAX_SKILL_BYTES) return {
+		field,
+		reason: `larger than ${MAX_SKILL_BYTES} bytes`
+	};
+	return {
+		name,
+		files: out
+	};
+}
+/** Replace `dir` with exactly these files: staged next to it, then swapped in. */
+function writeSkillDir(root, name, files) {
+	mkdirSync(root, { recursive: true });
+	const dir = join(root, name);
+	const stage = join(root, `.${name}.sync-${process$1.pid}-${Date.now()}`);
+	mkdirSync(stage);
+	try {
+		for (const file of files) {
+			const target = resolve(stage, file.path);
+			if (!target.startsWith(stage + sep)) throw new Error(`${file.path} is outside the skill folder.`);
+			mkdirSync(dirname(target), { recursive: true });
+			writeFileSync(target, file.bytes);
+		}
+		const backup = existsSync(dir) ? `${stage}.old` : null;
+		if (backup) renameSync(dir, backup);
+		renameSync(stage, dir);
+		if (backup) rmSync(backup, {
+			recursive: true,
+			force: true
+		});
+	} finally {
+		rmSync(stage, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+function pushFiles(ctx, record, payload, result) {
+	if (!isRecord(payload) || !Array.isArray(payload.skills) || payload.skills.length > MAX_SKILLS || payload.systemMd !== null && typeof payload.systemMd !== "string") throw new InvalidParamsError("files: payload must be { systemMd: string | null, skills: [...] }.");
+	let touched = false;
+	let total = 0;
+	const mdPath = userSystemMdPath({
+		home: ctx.home(),
+		prefix: ctx.prefix()
+	});
+	const currentMd = existsSync(mdPath) ? readFileSync(mdPath, "utf8") : null;
+	const currentMdHash = currentMd === null ? null : hashValue(currentMd);
+	if (payload.systemMd !== null && Buffer.byteLength(payload.systemMd) > MAX_SYSTEM_MD_BYTES) result.skipped.push({
+		field: SYSTEM_MD_FIELD,
+		reason: `larger than ${MAX_SYSTEM_MD_BYTES} bytes`
+	});
+	else if (payload.systemMd !== null || record.fields["system-md"]) {
+		if (writable(record, "system-md", currentMdHash, result)) {
+			if (payload.systemMd === null) {
+				rmSync(mdPath, { force: true });
+				delete record.fields[SYSTEM_MD_FIELD];
+				result.applied.push(SYSTEM_MD_FIELD);
+				touched = true;
+			} else if (hashValue(payload.systemMd) === currentMdHash) {
+				mark(record, SYSTEM_MD_FIELD, "files", { hash: currentMdHash });
+				result.unchanged.push(SYSTEM_MD_FIELD);
+			} else {
+				total += Buffer.byteLength(payload.systemMd);
+				writeFileAtomic(mdPath, payload.systemMd, { ensureDir: true });
+				mark(record, SYSTEM_MD_FIELD, "files", { hash: hashValue(payload.systemMd) });
+				result.applied.push(SYSTEM_MD_FIELD);
+				touched = true;
+			}
+		}
+	}
+	const root = userSkillsRoot(ctx);
+	const sent = /* @__PURE__ */ new Set();
+	for (const raw of payload.skills) {
+		const skill = checkSkill(raw);
+		if ("reason" in skill) {
+			result.skipped.push(skill);
+			continue;
+		}
+		const field = `skill:${skill.name}`;
+		sent.add(field);
+		const bytes = skill.files.reduce((n, f) => n + f.bytes.length, 0);
+		if (total + bytes > MAX_FILES_BYTES) {
+			result.skipped.push({
+				field,
+				reason: `over the ${MAX_FILES_BYTES}-byte bound of one push`
+			});
+			continue;
+		}
+		const dir = join(root, skill.name);
+		if (existsSync(dir) && lstatSync(dir).isSymbolicLink()) {
+			result.skipped.push({
+				field,
+				reason: "a link on this server, left alone"
+			});
+			continue;
+		}
+		const currentHash = hashDir(dir);
+		if (!writable(record, field, currentHash, result)) continue;
+		const wanted = hashFiles(skill.files);
+		if (wanted === currentHash) {
+			mark(record, field, "files", { hash: wanted });
+			result.unchanged.push(field);
+			continue;
+		}
+		total += bytes;
+		writeSkillDir(root, skill.name, skill.files);
+		mark(record, field, "files", { hash: hashDir(dir) ?? wanted });
+		result.applied.push(field);
+		touched = true;
+	}
+	for (const [field, known] of Object.entries(record.fields)) {
+		if (known.category !== "files" || !field.startsWith("skill:") || sent.has(field)) continue;
+		const dir = join(root, field.slice(6));
+		if (!writable(record, field, hashDir(dir), result)) continue;
+		rmSync(dir, {
+			recursive: true,
+			force: true
+		});
+		delete record.fields[field];
+		result.applied.push(field);
+		touched = true;
+	}
+	return touched;
+}
+function readUserMcps(ctx) {
+	const path = userMcpsPath(ctx);
+	if (!existsSync(path)) return [];
+	try {
+		return parseMcpsFile(readFileSync(path, "utf8"));
+	} catch {
+		return [];
+	}
+}
+async function pushMcps(ctx, record, payload, peer, result) {
+	if (!isRecord(payload) || !Array.isArray(payload.servers)) throw new InvalidParamsError("mcps: payload.servers must be a list.");
+	const hashOf = (name) => {
+		const found = readUserMcps(ctx).find((s) => s.name === name);
+		return found ? hashValue(found) : null;
+	};
+	const sent = /* @__PURE__ */ new Set();
+	for (const config of payload.servers) {
+		const name = isRecord(config) && typeof config.name === "string" ? config.name : "";
+		const field = `mcp:${name}`;
+		if (!NAME_RE.test(name)) {
+			result.skipped.push({
+				field,
+				reason: "not a plain server name"
+			});
+			continue;
+		}
+		sent.add(field);
+		const currentHash = hashOf(name);
+		if (!writable(record, field, currentHash, result)) continue;
+		const wanted = hashValue(config);
+		if (record.fields[field]?.sent === wanted && currentHash !== null) {
+			result.unchanged.push(field);
+			continue;
+		}
+		try {
+			await ctx.setters.mcpUpsert({ config }, peer);
+		} catch (err) {
+			result.skipped.push({
+				field,
+				reason: err instanceof Error ? err.message : String(err)
+			});
+			continue;
+		}
+		mark(record, field, "mcps", {
+			hash: hashOf(name) ?? wanted,
+			sent: wanted
+		});
+		result.applied.push(field);
+		if (typeof config.command === "string" && config.command.trim() !== "" && !commandAvailable(config.command.trim())) result.warnings.push({
+			field,
+			message: `"${config.command}" is not on this server's PATH: the server may not run there.`
+		});
+	}
+	for (const [field, known] of Object.entries(record.fields)) {
+		if (known.category !== "mcps" || sent.has(field)) continue;
+		const name = field.slice(4);
+		if (!writable(record, field, hashOf(name), result)) continue;
+		try {
+			await ctx.setters.mcpRemove({ name }, peer);
+		} catch (err) {
+			result.skipped.push({
+				field,
+				reason: err instanceof Error ? err.message : String(err)
+			});
+			continue;
+		}
+		delete record.fields[field];
+		result.applied.push(field);
+	}
+}
+async function pushExtensions(ctx, record, payload, peer, result) {
+	if (!isRecord(payload) || !Array.isArray(payload.extensions)) throw new InvalidParamsError("extensions: payload.extensions must be a list.");
+	for (const entry of payload.extensions) {
+		const name = isRecord(entry) && typeof entry.name === "string" ? entry.name : "";
+		const field = `extension:${name}`;
+		if (!NAME_RE.test(name) || typeof entry.spec !== "string") {
+			result.skipped.push({
+				field,
+				reason: "needs a plain name and a source spec"
+			});
+			continue;
+		}
+		if (record.overrides[field]) {
+			result.skipped.push({
+				field,
+				reason: "override"
+			});
+			continue;
+		}
+		if (userExtensionDirs(ctx, name).some((dir) => existsSync(dir))) {
+			if (!record.fields[field]) mark(record, field, "extensions", {});
+			result.unchanged.push(field);
+			continue;
+		}
+		try {
+			await ctx.setters.install({
+				kind: "extension",
+				spec: entry.spec,
+				scope: "user",
+				...typeof entry.extension === "string" ? { extension: entry.extension } : {}
+			}, peer);
+		} catch (err) {
+			result.skipped.push({
+				field,
+				reason: err instanceof Error ? err.message : String(err)
+			});
+			continue;
+		}
+		mark(record, field, "extensions", {});
+		result.applied.push(field);
+	}
+}
+function pushKeys(ctx, record, payload, result) {
+	if (!isRecord(payload) || !Array.isArray(payload.keys)) throw new InvalidParamsError("keys: payload.keys must be a list.");
+	for (const entry of payload.keys) {
+		const provider = isRecord(entry) && typeof entry.provider === "string" ? entry.provider : "";
+		const field = `key:${provider}`;
+		if (!record.keys.includes(provider)) {
+			result.skipped.push({
+				field,
+				reason: "not opted in for this key"
+			});
+			continue;
+		}
+		if (record.overrides[field]) {
+			result.skipped.push({
+				field,
+				reason: "override"
+			});
+			continue;
+		}
+		try {
+			if (typeof entry.key !== "string" || entry.key.trim() === "") throw new Error("empty key");
+			if (ctx.auth.storedKeys(ctx.auth.descriptorOf(provider)).includes(entry.key.trim())) {
+				if (!record.fields[field]) mark(record, field, "keys", {});
+				result.unchanged.push(field);
+				continue;
+			}
+			ctx.setters.setApiKey({
+				provider,
+				key: entry.key
+			});
+		} catch (err) {
+			result.skipped.push({
+				field,
+				reason: err instanceof Error ? err.message : String(err)
+			});
+			continue;
+		}
+		mark(record, field, "keys", {});
+		result.applied.push(field);
+	}
+}
+//#endregion
+//#region src/ipc/daemon/sync-store.ts
+const SYNC_FILE = "sync.json";
+function emptySyncRecord() {
+	return {
+		version: 1,
+		source: null,
+		categories: [],
+		keys: [],
+		fields: {},
+		overrides: {}
+	};
+}
+function createSyncStore(dataDir) {
+	const file = join(dataDir, SYNC_FILE);
+	return {
+		file,
+		read: () => {
+			if (!existsSync(file)) return emptySyncRecord();
+			try {
+				const raw = JSON.parse(readFileSync(file, "utf8"));
+				if (!isRecord(raw)) return emptySyncRecord();
+				return {
+					version: 1,
+					source: isRecord(raw.source) && typeof raw.source.deviceId === "string" && typeof raw.source.deviceName === "string" ? raw.source : null,
+					categories: Array.isArray(raw.categories) ? raw.categories.filter((c) => SYNC_CATEGORIES.includes(c)) : [],
+					keys: Array.isArray(raw.keys) ? raw.keys.filter((k) => typeof k === "string") : [],
+					fields: isRecord(raw.fields) ? raw.fields : {},
+					overrides: isRecord(raw.overrides) ? raw.overrides : {},
+					...typeof raw.lastPushAt === "number" ? { lastPushAt: raw.lastPushAt } : {}
+				};
+			} catch {
+				return emptySyncRecord();
+			}
+		},
+		write: (record) => writeJsonFileAtomic(file, record, OWNER_ONLY)
+	};
+}
+/** What `sync.status` says: the record without hashes or safelist entries. */
+function syncStatusOf(record) {
+	return {
+		source: record.source,
+		categories: [...record.categories],
+		keys: [...record.keys],
+		fields: Object.fromEntries(Object.entries(record.fields).map(([field, f]) => [field, {
+			category: f.category,
+			syncedAt: f.syncedAt
+		}])),
+		overrides: { ...record.overrides },
+		...record.lastPushAt !== void 0 ? { lastPushAt: record.lastPushAt } : {}
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/sync.ts
+const MAX_DEVICE_FIELD = 200;
+const NOT_A_SERVER = "This host takes no settings sync (a zidane-server does).";
+function checkDevice(p, withName) {
+	if (typeof p.deviceId !== "string" || p.deviceId.trim() === "" || p.deviceId.length > MAX_DEVICE_FIELD) throw new InvalidParamsError("deviceId must be a non-empty string.");
+	if (withName && (typeof p.deviceName !== "string" || p.deviceName.trim() === "" || p.deviceName.length > MAX_DEVICE_FIELD)) throw new InvalidParamsError("deviceName must be a non-empty string.");
+	return {
+		deviceId: p.deviceId,
+		deviceName: typeof p.deviceName === "string" ? p.deviceName.trim() : ""
+	};
+}
+function checkCategories(value) {
+	if (value === void 0) return void 0;
+	if (!Array.isArray(value) || !value.every((c) => SYNC_CATEGORIES.includes(c))) throw new InvalidParamsError(`categories must be some of: ${SYNC_CATEGORIES.join(", ")}.`);
+	return SYNC_CATEGORIES.filter((c) => value.includes(c));
+}
+function createSyncHandlers({ host, env, broadcast, setters, auth, options }) {
+	const store = createSyncStore(env.userDataDir());
+	const ctx = {
+		env,
+		setters,
+		auth,
+		home: () => homedir(),
+		prefix: () => env.config.prefix
+	};
+	/** Sync calls (and override marks) one at a time: each reads the record, works, writes it. */
+	let queue = Promise.resolve();
+	const exclusive = (work) => {
+		const next = queue.then(work, work);
+		queue = next.catch(() => void 0);
+		return next;
+	};
+	const changed = () => broadcast({ kind: "sync:changed" });
+	const audit = (peer, entry) => options?.audit?.(peer, entry);
+	function requireOptions() {
+		if (!options) throw new Error(NOT_A_SERVER);
+	}
+	/** Mark fields the source set as edited here; nothing for fields nobody synced. */
+	const markOverrides = (fields) => {
+		if (!options || fields.length === 0) return Promise.resolve();
+		return exclusive(() => {
+			const record = store.read();
+			const marked = fields.filter((field) => record.fields[field] && !record.overrides[field]);
+			if (marked.length === 0) return;
+			const at = Date.now();
+			for (const field of marked) record.overrides[field] = { at };
+			store.write(record);
+			changed();
+		});
+	};
+	/** Whether `deviceId` over `peer`'s token is the recorded source. */
+	const isSource = (record, deviceId, peer) => record.source !== null && record.source.deviceId === deviceId && record.source.tokenId === peer.principal;
+	/** The source's own call, or a refusal naming the device that syncs. */
+	function requireSource(record, deviceId, peer) {
+		if (!record.source) throw new Error("No device syncs to this server: claim it first (sync.claim).");
+		if (!isSource(record, deviceId, peer)) throw new Error(`This server is synced from ${record.source.deviceName}${record.source.deviceId === deviceId ? " with another token" : ""}: take over from that device first.`);
+	}
+	const rebuild = () => {
+		host.rebuildAllAgents({ rediscover: true }).catch(() => void 0);
+	};
+	return {
+		markOverrides,
+		"sync.status": () => {
+			requireOptions();
+			return syncStatusOf(store.read());
+		},
+		"sync.claim": (p, peer) => exclusive(() => {
+			requireOptions();
+			const { deviceId, deviceName } = checkDevice(p, true);
+			const categories = checkCategories(p.categories);
+			if (p.keys !== void 0 && (!Array.isArray(p.keys) || !p.keys.every((k) => typeof k === "string"))) throw new InvalidParamsError("keys must be provider names.");
+			const takeover = p.takeover === true;
+			const record = store.read();
+			const other = record.source !== null && !isSource(record, deviceId, peer);
+			if (other && !takeover) {
+				audit(peer, {
+					event: "sync.claim",
+					deviceId,
+					deviceName,
+					takeover,
+					claimed: false,
+					ok: true
+				});
+				return {
+					claimed: false,
+					status: syncStatusOf(record)
+				};
+			}
+			const next = other ? {
+				version: 1,
+				source: null,
+				categories: [],
+				keys: [],
+				fields: {},
+				overrides: {}
+			} : record;
+			next.source = {
+				deviceId,
+				deviceName,
+				claimedAt: other || !record.source ? Date.now() : record.source.claimedAt,
+				...peer.principal ? { tokenId: peer.principal } : {}
+			};
+			if (categories) next.categories = categories;
+			if (p.keys !== void 0) next.keys = [...new Set(p.keys)];
+			store.write(next);
+			changed();
+			audit(peer, {
+				event: "sync.claim",
+				deviceId,
+				deviceName,
+				takeover,
+				claimed: true,
+				categories: next.categories,
+				keys: next.keys,
+				ok: true
+			});
+			return {
+				claimed: true,
+				status: syncStatusOf(next)
+			};
+		}),
+		"sync.push": (p, peer) => exclusive(async () => {
+			requireOptions();
+			const { deviceId } = checkDevice(p, false);
+			const category = p.category;
+			const fields = {
+				event: "sync.push",
+				category,
+				deviceId
+			};
+			try {
+				if (!SYNC_CATEGORIES.includes(category)) throw new InvalidParamsError(`category must be one of: ${SYNC_CATEGORIES.join(", ")}.`);
+				const record = store.read();
+				requireSource(record, deviceId, peer);
+				if (!record.categories.includes(category)) throw new Error(`"${category}" is not synced to this server (claim it with that category).`);
+				const result = {
+					applied: [],
+					unchanged: [],
+					skipped: [],
+					warnings: []
+				};
+				const payload = p.payload;
+				if (category === "settings") pushSettings(ctx, record, payload, result);
+				else if (category === "safelists") pushSafelists(ctx, record, payload, result);
+				else if (category === "files") {
+					if (pushFiles(ctx, record, payload, result)) {
+						rebuild();
+						broadcast({
+							kind: "catalog:changed",
+							catalog: "skills"
+						});
+					}
+				} else if (category === "mcps") await pushMcps(ctx, record, payload, peer, result);
+				else if (category === "extensions") await pushExtensions(ctx, record, payload, peer, result);
+				else pushKeys(ctx, record, payload, result);
+				record.lastPushAt = Date.now();
+				store.write(record);
+				changed();
+				audit(peer, {
+					...fields,
+					applied: result.applied.length,
+					unchanged: result.unchanged.length,
+					skipped: result.skipped.length,
+					ok: true
+				});
+				return result;
+			} catch (err) {
+				audit(peer, {
+					...fields,
+					ok: false,
+					error: err instanceof Error ? err.message : String(err)
+				});
+				throw err;
+			}
+		}),
+		"sync.reset": (p, peer) => exclusive(() => {
+			requireOptions();
+			if (typeof p.field !== "string" || p.field === "") throw new InvalidParamsError("field must be a sync field name.");
+			const record = store.read();
+			const reset = Boolean(record.overrides[p.field]);
+			if (reset) {
+				delete record.overrides[p.field];
+				const known = record.fields[p.field];
+				if (known) {
+					delete known.hash;
+					delete known.sent;
+				}
+				store.write(record);
+				changed();
+			}
+			audit(peer, {
+				event: "sync.reset",
+				field: p.field,
+				reset,
+				ok: true
+			});
+			return { reset };
+		}),
+		"sync.release": (p, peer) => exclusive(() => {
+			requireOptions();
+			const { deviceId } = checkDevice(p, false);
+			const record = store.read();
+			if (!record.source) return { released: false };
+			requireSource(record, deviceId, peer);
+			store.write({
+				version: 1,
+				source: null,
+				categories: [],
+				keys: [],
+				fields: {},
+				overrides: {}
+			});
+			changed();
+			audit(peer, {
+				event: "sync.release",
+				deviceId,
+				ok: true
+			});
+			return { released: true };
+		})
+	};
+}
+/**
+* The window-facing setters, marking what they change as an override when
+* the field came from sync (the sync handlers call the unwrapped ones).
+*/
+function withSyncOverrides(handlers, { readSettings, markOverrides }) {
+	const after = async (work, fields) => {
+		const result = await work();
+		await markOverrides(fields(result));
+		return result;
+	};
+	return {
+		"settings.set": async (p, peer) => {
+			const before = readSettings();
+			return after(() => handlers["settings.set"](p, peer), (next) => Object.keys(isRecord(p?.patch) ? p.patch : {}).filter((key) => JSON.stringify(before[key]) !== JSON.stringify(next[key])).map(settingField));
+		},
+		"mcp.upsert": (p, peer) => after(() => handlers["mcp.upsert"](p, peer), (r) => [`mcp:${r.name}`]),
+		"mcp.remove": (p, peer) => after(() => handlers["mcp.remove"](p, peer), (r) => r.removed ? [`mcp:${p.name}`] : []),
+		"catalog.remove": (p, peer) => after(() => handlers["catalog.remove"](p, peer), () => [`${p.kind}:${p.name}`]),
+		"catalog.update": (p, peer) => after(() => handlers["catalog.update"](p, peer), () => [`${p.kind}:${p.name}`]),
+		"auth.setApiKey": (p, peer) => after(() => handlers["auth.setApiKey"](p, peer), () => [`key:${p.provider}`]),
+		"auth.remove": (p, peer) => after(() => handlers["auth.remove"](p, peer), (r) => r.removed ? [`key:${p.provider}`] : [])
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/terminal.ts
+function createTerminalHandlers({ host, isConnected }) {
+	return {
+		methods: {
+			"terminal.state": (p) => host.terminals.state(p.sessionId),
+			"terminal.open": (p) => host.terminals.open(p),
+			"terminal.attach": async (p, peer) => {
+				const result = await host.terminals.attach(p.terminalId, p.clientId);
+				if (!isConnected(peer)) {
+					host.terminals.detach(p.terminalId, p.clientId);
+					return result;
+				}
+				const views = peer.terminalViews ??= /* @__PURE__ */ new Map();
+				views.set(p.terminalId, (views.get(p.terminalId) ?? /* @__PURE__ */ new Set()).add(p.clientId));
+				return result;
+			},
+			"terminal.detach": (p, peer) => {
+				const views = peer.terminalViews?.get(p.terminalId);
+				views?.delete(p.clientId);
+				if (views?.size === 0) peer.terminalViews?.delete(p.terminalId);
+				host.terminals.detach(p.terminalId, p.clientId);
+			},
+			"terminal.write": (p) => host.terminals.write(p.terminalId, p.data, p.clientId ? {
+				clientId: p.clientId,
+				...p.response ? { response: true } : {}
+			} : void 0),
+			"terminal.resize": (p) => host.terminals.resize(p.terminalId, p.clientId, p.cols, p.rows, p.claim),
+			"terminal.ack": (p) => host.terminals.ack(p.terminalId, p.clientId, p.offset),
+			"terminal.restart": (p) => host.terminals.restart(p.terminalId),
+			"terminal.close": (p) => host.terminals.close(p.terminalId),
+			"terminal.setHidden": (p) => host.terminals.setHidden(p.terminalId, p.hidden),
+			"terminal.registerViewer": (p, peer) => {
+				(peer.terminalViewers ??= /* @__PURE__ */ new Set()).add(p.viewerId);
+				host.terminals.registerViewer(p.viewerId);
+				return { ok: true };
+			},
+			"terminal.unregisterViewer": (p, peer) => {
+				peer.terminalViewers?.delete(p.viewerId);
+				host.terminals.unregisterViewer(p.viewerId);
+				return { ok: true };
+			}
+		},
+		releasePeer(peer) {
+			for (const viewerId of peer.terminalViewers ?? []) host.terminals.unregisterViewer(viewerId);
+			for (const [terminalId, clients] of peer.terminalViews ?? []) for (const clientId of clients) host.terminals.detach(terminalId, clientId);
+		}
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/titles.ts
+function createTitleHandlers({ host, broadcast }) {
+	return { "sessions.generateTitle": async (p) => {
+		const sessionId = sessionIdOf(p);
+		const providerKey = optionalString(p.providerKey, "providerKey");
+		const model = optionalString(p.model, "model");
+		const title = await host.generateSessionTitle(sessionId, {
+			...providerKey !== void 0 ? { providerKey } : {},
+			...model !== void 0 ? { model } : {}
+		});
+		broadcast({
+			kind: "sessions:changed",
+			op: "update",
+			sessionId
+		});
+		return { title };
+	} };
+}
+//#endregion
+//#region src/ipc/daemon/handlers/todos.ts
+function createTodoHandlers({ host, store }) {
+	return {
+		"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);
+			if (state) return toTodosSnapshot(state);
+			if (p.persistIdle !== true || host.getLiveSession(p.sessionId)) return null;
+			return persistIdleTodos(store, p.sessionId, Array.isArray(p.items) ? p.items : []);
+		}
+	};
+}
+/** The idle-session todo edit, as a window applied it to its own copy: the active run's list, archive cleared. */
+async function persistIdleTodos(store, sessionId, items) {
+	const session = await loadSession(store, sessionId, { persistHeal: false });
+	const runId = session ? selectActiveTodos(session).runId : null;
+	if (!session || !runId) return null;
+	setTodosForRun(session, runId, items, { clearArchive: true });
+	await session.save();
+	return toTodosSnapshot(selectActiveTodos(session));
+}
+//#endregion
+//#region src/ipc/daemon/handlers/transcript.ts
+function createTranscriptHandlers({ host, store, broadcast, replays }) {
+	return {
+		"sessions.loadEvents": async (p) => {
+			const paging = p;
+			if (isPagedLoad(paging)) return await replays.page(store, p.sessionId, paging);
+			const data = await loadOrThrow(store, 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.touch": (p) => {
+			broadcast({
+				kind: "sessions:changed",
+				op: "update",
+				sessionId: p.sessionId
+			});
+		},
+		"sessions.fork": async (p) => {
+			const result = await host.forkSession({
+				source: p.sessionId,
+				turnId: p.turnId,
+				...typeof p.title === "string" && p.title ? { title: p.title.slice(0, 256) } : {}
+			});
+			if (!result.ok) throw new Error(describeForkFailure(result.reason, p.sessionId, p.turnId));
+			broadcast({
+				kind: "sessions:changed",
+				op: "create",
+				sessionId: result.id
+			});
+			return { id: result.id };
+		},
+		"sessions.deleteTurn": (p) => host.deleteTurn(p.sessionId, p.turnId),
+		"sessions.editTurnText": (p) => host.editTurnText(p.sessionId, p.turnId, typeof p.text === "string" ? p.text.slice(0, 65536) : ""),
+		"sessions.appendTurns": (p) => host.appendTurns(p.sessionId, Array.isArray(p.turns) ? p.turns : []),
+		"sessions.appendNote": (p) => host.appendNote(p.sessionId, Array.isArray(p.blocks) ? p.blocks.filter((block) => typeof block?.text === "string") : []),
+		"sessions.compact": (p) => host.compactSessionNow(p.sessionId)
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/transcript-cache.ts
+const DEFAULT_MAX_SESSIONS = 4;
+const DEFAULT_MAX_BYTES = 67108864;
+/** Signals that follow a change to a session's turns or runs. */
+const CHANGE_SIGNALS = /* @__PURE__ */ new Set([
+	"sessions:changed",
+	"run:start",
+	"run:end",
+	"turn:end",
+	"compacting:end",
+	"prompt-turns"
+]);
+/** One kind of entry (replays, documents): LRU by insertion order, bounded by count and bytes. */
+function createLru(maxSessions, maxBytes) {
+	const entries = /* @__PURE__ */ new Map();
+	let totalBytes = 0;
+	const drop = (sessionId) => {
+		const entry = entries.get(sessionId);
+		if (entry) {
+			totalBytes -= entry.bytes;
+			entries.delete(sessionId);
+		}
+	};
+	return {
+		size: () => entries.size,
+		hit(sessionId, version) {
+			const entry = entries.get(sessionId);
+			if (!entry || entry.version !== version) return void 0;
+			entries.delete(sessionId);
+			entries.set(sessionId, entry);
+			return entry;
+		},
+		drop,
+		keep(sessionId, entry) {
+			if (entry.bytes > maxBytes) return;
+			drop(sessionId);
+			entries.set(sessionId, entry);
+			totalBytes += entry.bytes;
+			for (const [id, oldest] of entries) {
+				if (entries.size <= maxSessions && totalBytes <= maxBytes) break;
+				entries.delete(id);
+				totalBytes -= oldest.bytes;
+			}
+		}
+	};
+}
+function createTranscriptReplayCache(options = {}) {
+	const maxSessions = options.maxSessions ?? DEFAULT_MAX_SESSIONS;
+	const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+	const replay = options.replay ?? replayTurns;
+	const replays = createLru(maxSessions, maxBytes);
+	const documents = createLru(maxSessions, maxBytes);
+	const inFlight = /* @__PURE__ */ new Map();
+	/** Labels a read of no known version: never equal to another read's. */
+	let unversioned = 0;
+	function drop(sessionId) {
+		for (const read of inFlight.get(sessionId) ?? []) read.dropped = true;
+		replays.drop(sessionId);
+		documents.drop(sessionId);
+	}
+	/** Run `fn` as an in-flight read of `sessionId`, tracked only while it runs. */
+	async function tracked(sessionId, fn) {
+		const read = { dropped: false };
+		const reads = inFlight.get(sessionId) ?? /* @__PURE__ */ new Set();
+		inFlight.set(sessionId, reads.add(read));
+		try {
+			return await fn(read);
+		} finally {
+			reads.delete(read);
+			if (reads.size === 0 && inFlight.get(sessionId) === reads) inFlight.delete(sessionId);
+		}
+	}
+	/**
+	* A stored session's entry of `lru`, built from `load` on a miss. The
+	* version comes from `getMeta` when the store has it (see the header),
+	* else from the loaded data (`fingerprintOf`).
+	*/
+	function stored(lru, store, sessionId, load, build, fingerprintOf) {
+		return tracked(sessionId, async (read) => {
+			if (store.getMeta) {
+				const readAt = Date.now();
+				const meta = await store.getMeta(sessionId);
+				if (!meta) return null;
+				const version = storeVersion(meta);
+				const cached = lru.hit(sessionId, version);
+				if (cached) return cached;
+				const data = await load();
+				if (data === null) return null;
+				let settled;
+				if (meta.rev !== void 0) {
+					const after = await store.getMeta(sessionId);
+					settled = after !== null && storeVersion(after) === version;
+				} else settled = meta.updatedAt < readAt;
+				const entry = build(data, settled ? version : `${version}~${++unversioned}`);
+				if (settled && !read.dropped) lru.keep(sessionId, entry);
+				return entry;
+			}
+			const data = await load();
+			if (data === null) return null;
+			const version = fingerprintOf(data);
+			const cached = lru.hit(sessionId, version);
+			if (cached) return cached;
+			const entry = build(data, version);
+			if (!read.dropped) lru.keep(sessionId, entry);
+			return entry;
+		});
+	}
+	function buildReplay(data, version) {
+		const { events, turnStarts } = replay(data.turns, data.runs);
+		return {
+			version,
+			events,
+			turnStarts,
+			boundaries: exchangeBoundaries(data.turns, data.runs),
+			cuts: turnCutPoints(data.turns),
+			bytes: JSON.stringify(events).length
+		};
+	}
+	const snapshotOf = (data, version) => ({
+		version,
+		data,
+		bytes: JSON.stringify(data).length
+	});
+	return {
+		async page(store, sessionId, paging) {
+			const entry = await stored(replays, store, sessionId, () => loadOrThrow(store, sessionId), buildReplay, (data) => fingerprint(data.updatedAt, data.turns, data.runs));
+			if (!entry) throw new Error(`Session "${sessionId}" not found.`);
+			const { from, to, cursor } = transcriptPage(entry.boundaries, paging, entry.cuts);
+			return {
+				events: entry.events.slice(entry.turnStarts[from], entry.turnStarts[to]),
+				exact: true,
+				start: entry.turnStarts[from],
+				...cursor !== void 0 ? { cursor } : {}
+			};
+		},
+		async document(store, sessionId, live) {
+			if (live) {
+				const version = `live:${fingerprint(0, live.turns, live.runs)}:${hashText(JSON.stringify([live.status, live.metadata]))}`;
+				return tracked(sessionId, async (read) => {
+					const cached = documents.hit(sessionId, version);
+					if (cached) return cached;
+					const entry = snapshotOf(live.toJSON(), version);
+					if (!read.dropped) documents.keep(sessionId, entry);
+					return entry;
+				});
+			}
+			const load = async () => (await loadSession(store, sessionId, { persistHeal: false }))?.toJSON() ?? null;
+			return stored(documents, store, sessionId, load, snapshotOf, (data) => fingerprint(data.updatedAt, data.turns, data.runs));
+		},
+		observe(signal) {
+			if (CHANGE_SIGNALS.has(signal.kind) && "sessionId" in signal && typeof signal.sessionId === "string") drop(signal.sessionId);
+		},
+		forget: drop,
+		sizes: () => ({
+			entries: replays.size() + documents.size(),
+			inFlight: inFlight.size
+		})
+	};
+}
+function storeVersion(meta) {
+	return `meta:${meta.rev ?? "-"}:${meta.updatedAt}:${meta.turnCount}:${meta.runCount}`;
+}
+/** A 32-bit FNV-1a: `mix` values in, `digest` (base 36) out. */
+function fnv1a() {
+	let hash = 2166136261;
+	const add = (text) => {
+		for (let i = 0; i < text.length; i++) hash = Math.imul(hash ^ text.charCodeAt(i), 16777619);
+	};
+	return {
+		add,
+		/** One value, then a separator: `ab` + `c` never hashes as `a` + `bc`. */
+		mix: (value) => {
+			add(String(value));
+			hash = Math.imul(hash ^ 31, 16777619);
+		},
+		digest: () => (hash >>> 0).toString(36)
+	};
+}
+function hashText(text) {
+	const hash = fnv1a();
+	hash.add(text);
+	return hash.digest();
+}
+/** FNV-1a over the document's shape: what changes when a turn or run is added, removed, or rewritten. */
+function fingerprint(updatedAt, turns, runs) {
+	const { mix, digest } = fnv1a();
+	for (const turn of turns) {
+		mix(turn.id);
+		mix(turn.role);
+		mix(turn.runId);
+		mix(typeof turn.display === "string" ? turn.display : "");
+		mix(turn.content.length);
+		for (const block of turn.content) {
+			mix(block.type);
+			const fields = block;
+			for (const field of [
+				fields.text,
+				fields.output,
+				fields.summary
+			]) mix(typeof field === "string" ? field.length : Array.isArray(field) ? field.length : "");
+		}
+	}
+	mix(JSON.stringify(runs));
+	return `doc:${updatedAt}:${turns.length}:${runs.length}:${digest()}`;
+}
+//#endregion
+//#region src/ipc/daemon/handlers/workspace.ts
+function createWorkspaceHandlers({ host }) {
+	return {
+		"sessions.workspaceExec": (p) => host.workspaceExec(p.sessionId, p.command, {
+			...p.cwd !== void 0 ? { cwd: p.cwd } : {},
+			...p.env !== void 0 ? { env: p.env } : {},
+			...p.timeoutSeconds !== void 0 ? { timeoutSeconds: p.timeoutSeconds } : {}
+		}),
+		"sessions.workspaceReadFile": (p) => host.workspaceReadFile(p.sessionId, p.path),
+		"sessions.workspaceWriteFile": (p) => host.workspaceWriteFile(p.sessionId, p.path, p.content),
+		"sessions.workspaceListFiles": (p) => host.workspaceListFiles(p.sessionId, p.path, p.options),
+		"sessions.workspaceFileSize": (p) => host.workspaceFileSize(p.sessionId, p.path)
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handlers/workspace-exec-stream.ts
+const WORKSPACE_EXEC_STREAM_LIMITS = {
+	/** Streamed commands one connection may run at once. */
+	maxConcurrent: 4,
+	/** Largest `chunk` of one data signal, in bytes. */
+	chunkBytes: 65536,
+	/** Output past this (stdout + stderr, bytes) stops the process: the same ceiling as a local `!`. */
+	maxOutputBytes: 1048576,
+	/** Longest command text. */
+	maxCommandLength: 65536,
+	/** The buffered fallback's bound (seconds), as the buffered `!` had. */
+	fallbackTimeoutSeconds: 600
+};
+/** Cut `text` into pieces of at most `max` UTF-8 bytes, never inside a code point. */
+function utf8Pieces(text, max) {
+	if (Buffer.byteLength(text) <= max) return [text];
+	const pieces = [];
+	let current = "";
+	let bytes = 0;
+	for (const char of text) {
+		const size = Buffer.byteLength(char);
+		if (bytes + size > max) {
+			pieces.push(current);
+			current = "";
+			bytes = 0;
+		}
+		current += char;
+		bytes += size;
+	}
+	if (current) pieces.push(current);
+	return pieces;
+}
+/** The longest prefix of `text` within `max` UTF-8 bytes. */
+function utf8Prefix(text, max) {
+	let bytes = 0;
+	let end = 0;
+	for (const char of text) {
+		const size = Buffer.byteLength(char);
+		if (bytes + size > max) break;
+		bytes += size;
+		end += char.length;
+	}
+	return text.slice(0, end);
+}
+function createWorkspaceExecStreamHandlers({ host, isConnected, limits = WORKSPACE_EXEC_STREAM_LIMITS }) {
+	const running = /* @__PURE__ */ new Map();
+	const perPeer = /* @__PURE__ */ new WeakMap();
+	const send = (peer, signal) => {
+		if (isConnected(peer)) peer.send(signal);
+	};
+	/** Output accounting for one exec: emits what fits, reports when the cap is reached. */
+	function outputSink(execId, peer, onCap) {
+		let total = 0;
+		let capped = false;
+		return {
+			capped: () => capped,
+			emit(stream, text) {
+				if (capped || text === "") return;
+				let piece = text;
+				if (total + Buffer.byteLength(piece) > limits.maxOutputBytes) {
+					piece = utf8Prefix(piece, limits.maxOutputBytes - total);
+					capped = true;
+				}
+				total += Buffer.byteLength(piece);
+				for (const chunk of piece ? utf8Pieces(piece, limits.chunkBytes) : []) send(peer, {
+					kind: "workspace:exec:data",
+					execId,
+					stream,
+					chunk
+				});
+				if (capped) onCap();
+			}
+		};
+	}
+	async function pump(execId, peer, stream, entry) {
+		const sink = outputSink(execId, peer, () => entry.kill());
+		const drain = async (source, name) => {
+			if (!source) return;
+			const decoder = new TextDecoder();
+			try {
+				for await (const bytes of source) sink.emit(name, decoder.decode(bytes, { stream: true }));
+				sink.emit(name, decoder.decode());
+			} catch {}
+		};
+		const [code] = await Promise.all([
+			stream.exited,
+			drain(stream.stdout, "stdout"),
+			drain(stream.stderr, "stderr")
+		]);
+		const killed = entry.killedLive === true;
+		const exit = {
+			kind: "workspace:exec:exit",
+			execId,
+			code: killed ? null : code,
+			signal: killed ? "SIGTERM" : null,
+			...sink.capped() ? { truncated: true } : {},
+			...entry.cancelled && killed ? { cancelled: true } : {}
+		};
+		send(peer, exit);
+	}
+	/** A context without `execStream`: the buffered exec, reported as one stdout and one stderr chunk. */
+	async function buffered(execId, peer, entry, run) {
+		let stopped = false;
+		entry.kill = () => {
+			stopped = true;
+		};
+		const sink = outputSink(execId, peer, () => void 0);
+		try {
+			const result = await run();
+			if (!stopped) {
+				sink.emit("stdout", result.stdout);
+				sink.emit("stderr", result.stderr);
+			}
+			send(peer, {
+				kind: "workspace:exec:exit",
+				execId,
+				code: stopped ? null : result.exitCode,
+				signal: stopped ? "SIGTERM" : null,
+				...sink.capped() ? { truncated: true } : {},
+				...entry.cancelled ? { cancelled: true } : {}
+			});
+		} catch (err) {
+			sink.emit("stderr", err instanceof Error ? err.message : String(err));
+			send(peer, {
+				kind: "workspace:exec:exit",
+				execId,
+				code: null,
+				signal: null,
+				...entry.cancelled ? { cancelled: true } : {}
+			});
+		}
+	}
+	return {
+		methods: {
+			"sessions.workspaceExecStream": async (p, peer) => {
+				if (typeof p.sessionId !== "string" || p.sessionId === "") throw new InvalidParamsError("sessionId must be a non-empty string.");
+				if (typeof p.command !== "string" || p.command.trim() === "") throw new InvalidParamsError("command must be a non-empty string.");
+				if (p.command.length > limits.maxCommandLength) throw new InvalidParamsError(`command is longer than ${limits.maxCommandLength} characters.`);
+				if (p.cwd !== void 0 && typeof p.cwd !== "string") throw new InvalidParamsError("cwd must be a string.");
+				const own = perPeer.get(peer) ?? /* @__PURE__ */ new Set();
+				perPeer.set(peer, own);
+				if (own.size >= limits.maxConcurrent) throw new Error(`This connection already runs ${own.size} shell commands (at most ${limits.maxConcurrent}): stop one first.`);
+				const execId = randomUUID();
+				own.add(execId);
+				const entry = {
+					peer,
+					kill: () => void 0,
+					cancelled: false
+				};
+				running.set(execId, entry);
+				const done = () => {
+					own.delete(execId);
+					running.delete(execId);
+				};
+				const options = p.cwd !== void 0 ? { cwd: p.cwd } : {};
+				let stream;
+				try {
+					stream = await host.workspaceExecStream(p.sessionId, p.command, options);
+				} catch (err) {
+					done();
+					throw err;
+				}
+				if (stream) {
+					const live = stream;
+					let exited = false;
+					live.exited.then(() => {
+						exited = true;
+					}, () => {
+						exited = true;
+					});
+					entry.kill = () => {
+						if (!exited) entry.killedLive = true;
+						live.kill();
+					};
+					if (!isConnected(peer)) entry.kill();
+					pump(execId, peer, live, entry).finally(done);
+				} else buffered(execId, peer, entry, () => host.workspaceExec(p.sessionId, p.command, {
+					...options,
+					timeoutSeconds: limits.fallbackTimeoutSeconds
+				})).finally(done);
+				return { execId };
+			},
+			"sessions.workspaceExecCancel": (p, peer) => {
+				const entry = typeof p.execId === "string" ? running.get(p.execId) : void 0;
+				if (!entry || entry.peer !== peer) return { cancelled: false };
+				entry.cancelled = true;
+				entry.kill();
+				return { cancelled: true };
+			}
+		},
+		releasePeer(peer) {
+			for (const execId of perPeer.get(peer) ?? []) {
+				const entry = running.get(execId);
+				if (entry) {
+					entry.cancelled = true;
+					entry.kill();
+				}
+			}
+		}
+	};
+}
+//#endregion
+//#region src/ipc/daemon/handshake.ts
+function evaluateServerHello(params) {
+	if (params.protocolVersion === 13) return {
+		accept: true,
+		retire: false
+	};
+	const client = typeof params.protocolVersion === "number" ? params.protocolVersion : void 0;
+	return {
+		accept: false,
+		message: `Protocol version mismatch: the server speaks v13, the client v${client ?? "?"}. Upgrade the ${client !== void 0 && client > 13 ? "server" : "client"}.`
+	};
+}
+function evaluateHello(params, ctx) {
+	if (ctx.hostKind === "server") return evaluateServerHello(params);
+	const clientBuild = Number(params.buildId);
+	const daemonBuild = Number(ctx.buildId);
+	const staleBuild = params.buildId !== void 0 && params.buildId !== "unknown" && ctx.buildId !== "unknown" && Number.isFinite(clientBuild) && Number.isFinite(daemonBuild) && clientBuild > daemonBuild;
+	const staleRelease = typeof params.codeVersion === "string" && compareVersions(params.codeVersion, ctx.codeVersion) > 0;
+	const protocolMatches = params.protocolVersion === 13;
+	if (protocolMatches && (staleBuild || staleRelease) && ctx.hasActiveWork) return {
+		accept: true,
+		retire: true
+	};
+	if (!protocolMatches || staleBuild || staleRelease) return {
+		accept: false,
+		message: staleRelease ? `Stale daemon: it runs zidane ${ctx.codeVersion} but the client runs ${params.codeVersion}. Draining for respawn.` : staleBuild ? `Build mismatch: the daemon was started from an older build (daemon ${ctx.buildId}, client ${params.buildId}). Draining for respawn.` : `Protocol version mismatch: daemon speaks v13, client sent v${params.protocolVersion ?? "?"}.`
+	};
+	return {
+		accept: true,
+		retire: false
+	};
+}
+//#endregion
+//#region src/ipc/daemon/identity.ts
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const FILE = "host-id";
+function readId(path) {
+	try {
+		const id = readFileSync(path, "utf8").trim();
+		return UUID.test(id) ? id : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* The id persisted in `dataDir`, created on first use. Two processes starting
+* at once agree: the file is created exclusively (`wx`) and the loser reads
+* the winner's id. A missing or corrupt file gets a fresh id.
+*/
+function readOrCreateHostId(dataDir) {
+	const path = join(dataDir, FILE);
+	const existing = readId(path);
+	if (existing) return existing;
+	const id = randomUUID();
+	try {
+		mkdirSync(dataDir, { recursive: true });
+		writeFileSync(path, `${id}\n`, {
+			flag: "wx",
+			mode: 384
+		});
+		return id;
+	} catch (err) {
+		if (err.code === "EEXIST") {
+			const raced = readId(path);
+			if (raced) return raced;
+			try {
+				writeFileSync(path, `${id}\n`, { mode: 384 });
+				return readId(path) ?? id;
+			} catch {
+				return;
+			}
+		}
+		return;
+	}
+}
+function resolveHostIdentity(dataDir, options) {
+	return {
+		id: readOrCreateHostId(dataDir),
+		kind: options.kind,
+		name: options.name ?? hostname()
+	};
+}
+//#endregion
+//#region src/ipc/daemon/peers.ts
+function createPeerRegistry(options = {}) {
+	const peers = /* @__PURE__ */ new Set();
+	let boundHost = null;
+	const closeCleanups = [];
+	/** Sessions with a run in flight, tracked from the run signals themselves. */
+	const runningSessions = /* @__PURE__ */ new Set();
+	const broadcast = (signal) => {
+		if (signal.kind === "terminal:output" || signal.kind === "terminal:reset") {
+			for (const peer of peers) if (peer.ready && peer.terminalViews?.has(signal.terminalId)) peer.send(signal);
+			return;
+		}
+		fanOut(null, signal, options.sequence?.(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();
+		}
+	};
+	function fanOut(origin, signal, seq) {
+		for (const peer of peers) {
+			if (!peer.ready || peer === origin) continue;
+			peer.send(signal, seq);
+		}
+	}
+	function broadcastExcept(origin, signal) {
+		fanOut(origin, signal, void 0);
+	}
+	/**
+	* 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 host = boundHost;
+		if (!host) throw new Error("Presence read before the host was bound.");
+		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()
+		});
+	}
+	return {
+		add(peer) {
+			peers.add(peer);
+		},
+		has: (peer) => peers.has(peer),
+		remove(peer) {
+			if (!peers.delete(peer)) return;
+			for (const cleanup of closeCleanups) cleanup(peer);
+			if (peer.watching) broadcastPresence();
+		},
+		onClose(cleanup) {
+			closeCleanups.push(cleanup);
+		},
+		clear() {
+			peers.clear();
+		},
+		size: () => peers.size,
+		broadcast,
+		broadcastExcept,
+		computePresence,
+		broadcastPresence,
+		bindHost(host) {
+			boundHost = host;
+		}
+	};
+}
+//#endregion
+//#region src/ipc/daemon/signal-log.ts
+function sessionOf(signal) {
+	const id = signal.sessionId;
+	return typeof id === "string" ? id : void 0;
+}
+function createSignalLog(options = {}) {
+	const maxSignals = options.maxSignals ?? 2e3;
+	const maxBytes = options.maxBytes ?? 4194304;
+	const maxTotalBytes = options.maxTotalBytes ?? 33554432;
+	const maxForgotten = options.maxForgotten ?? 1e4;
+	const epoch = randomUUID();
+	/** Insertion order = least recently written first. */
+	const logs = /* @__PURE__ */ new Map();
+	/** Next number of forgotten sessions; insertion order = least recently forgotten first. */
+	const forgotten = /* @__PURE__ */ new Map();
+	/** Every number below this may have been given out by a session whose counter is gone. */
+	let floor = 1;
+	let totalBytes = 0;
+	const dropOldest = (log) => {
+		totalBytes -= log.entries[log.head].bytes;
+		log.bytes -= log.entries[log.head].bytes;
+		log.head++;
+		if (log.head > 1024 && log.head * 2 > log.entries.length) {
+			log.entries = log.entries.slice(log.head);
+			log.head = 0;
+		}
+	};
+	const clear = (log) => {
+		totalBytes -= log.bytes;
+		log.entries = [];
+		log.head = 0;
+		log.bytes = 0;
+	};
+	return {
+		epoch,
+		record(signal) {
+			const sessionId = sessionOf(signal);
+			if (sessionId === void 0) return void 0;
+			let log = logs.get(sessionId);
+			if (log) logs.delete(sessionId);
+			else {
+				log = {
+					next: forgotten.get(sessionId) ?? floor,
+					entries: [],
+					head: 0,
+					bytes: 0
+				};
+				forgotten.delete(sessionId);
+			}
+			logs.set(sessionId, log);
+			const seq = log.next++;
+			let json;
+			try {
+				json = JSON.stringify(signal);
+			} catch {
+				clear(log);
+				return seq;
+			}
+			const bytes = Buffer.byteLength(json);
+			log.entries.push({
+				seq,
+				json,
+				bytes
+			});
+			log.bytes += bytes;
+			totalBytes += bytes;
+			while (log.entries.length - log.head > maxSignals || log.bytes > maxBytes && log.entries.length - log.head > 0) dropOldest(log);
+			for (const [id, other] of logs) {
+				if (totalBytes <= maxTotalBytes || id === sessionId) break;
+				clear(other);
+			}
+			return seq;
+		},
+		replay(sessionId, afterSeq) {
+			const log = logs.get(sessionId);
+			if (!log || !Number.isSafeInteger(afterSeq) || afterSeq < 0) return null;
+			const last = log.next - 1;
+			if (afterSeq > last || afterSeq < 0) return null;
+			if (afterSeq === last) return [];
+			const first = log.entries[log.head]?.seq;
+			if (first === void 0 || first > afterSeq + 1) return null;
+			const out = [];
+			for (let i = log.head; i < log.entries.length; i++) {
+				const entry = log.entries[i];
+				if (entry.seq > afterSeq) out.push({
+					seq: entry.seq,
+					signal: JSON.parse(entry.json)
+				});
+			}
+			return out;
+		},
+		forget(sessionId) {
+			const log = logs.get(sessionId);
+			if (!log) return;
+			clear(log);
+			logs.delete(sessionId);
+			forgotten.set(sessionId, log.next);
+			while (forgotten.size > maxForgotten) {
+				const [oldest, next] = forgotten.entries().next().value;
+				forgotten.delete(oldest);
+				floor = Math.max(floor, next);
+			}
+		},
+		sessionCount: () => logs.size + forgotten.size
+	};
+}
+//#endregion
+//#region src/ipc/daemon/workspace-roots.ts
+/**
+* The folders a host lets sessions use, as `fs.*` lists them: the host's own
+* confinement (`ChatHost.workspace`, `src/chat/workspace-confinement.ts`,
+* which the host enforces at its entry points), plus the folder listing. A
+* server is confined to its workspace roots; a local host is not, and its
+* listing root is the user's home, like the window's own folder picker.
+*/
+/** Most folders one listing returns. */
+const MAX_DIR_ENTRIES = 2e3;
+function createWorkspaceRoots(confinement) {
+	const { confined, roots, resolveFolder } = confinement;
+	return {
+		describe: () => ({
+			roots: [...roots],
+			confined
+		}),
+		resolveFolder,
+		checkFolder: confinement.checkFolder,
+		sessionFolder: confinement.sessionFolder,
+		list(path) {
+			const dir = resolveFolder(path ?? roots[0]);
+			const entries = [];
+			let truncated = false;
+			const names = readdirSync(dir, { withFileTypes: true }).filter((e) => !e.name.startsWith(".") && (e.isDirectory() || e.isSymbolicLink())).map((e) => e.name).sort((a, b) => a.localeCompare(b));
+			for (const name of names) {
+				let real;
+				try {
+					real = realpathSync.native(join(dir, name));
+					if (!statSync(real).isDirectory()) continue;
+				} catch {
+					continue;
+				}
+				if (!roots.some((root) => isInside(root, real))) continue;
+				if (entries.length >= MAX_DIR_ENTRIES) {
+					truncated = true;
+					break;
+				}
+				entries.push({
+					name,
+					path: real,
+					isGitRepo: existsSync(join(real, ".git"))
+				});
+			}
+			const atRoot = roots.includes(dir);
+			return {
+				roots: [...roots],
+				path: dir,
+				parent: atRoot ? null : dirname(dir),
+				entries,
+				...truncated ? { truncated } : {}
+			};
+		}
+	};
+}
+//#endregion
+//#region src/ipc/daemon/dispatcher.ts
+/** Codes a machine error keeps over the wire (`MachineErrorCode`). */
+const MACHINE_ERROR_CODES = new Set(Object.values(MachineErrorCode));
+async function createHostDispatcher(options) {
+	const { appVersion, startedAt, lifecycle } = options;
+	const signalLog = createSignalLog(options.replay);
+	const replays = createTranscriptReplayCache();
+	const peers = createPeerRegistry({ sequence: (signal) => {
+		replays.observe(signal);
+		return signalLog.record(signal);
+	} });
+	const { broadcast, broadcastExcept } = peers;
+	const env = await (options.createEnvironment ? options.createEnvironment(broadcast) : createDaemonEnvironment({ broadcast }));
+	const host = createChatHost(env);
+	peers.bindHost(host);
+	host.approvals.rehydrate();
+	const store = env.store;
+	const identity = resolveHostIdentity(env.userDataDir(), options.identity ?? { kind: "daemon" });
+	const identityFields = {
+		...identity.id ? { hostId: identity.id } : {},
+		hostKind: identity.kind,
+		hostName: identity.name
+	};
+	const workspace = createWorkspaceRoots(host.workspace);
+	const drafts = createDraftHandlers({ broadcastExcept });
+	const suggest = createSuggestHandlers({
+		env,
+		broadcastExcept
+	});
+	const launchOverrides = createLaunchOverrideHandlers({ host });
+	const browser = createBrowserHandlers({ host });
+	const terminal = createTerminalHandlers({
+		host,
+		isConnected: peers.has
+	});
+	const execStreams = createWorkspaceExecStreamHandlers({
+		host,
+		isConnected: peers.has
+	});
+	const auth = createProviderAuth({
+		host,
+		env
+	});
+	const oauth = createOAuthFlowHandlers({
+		host,
+		env,
+		auth,
+		isConnected: peers.has,
+		...options.oauthFlowTtlMs !== void 0 ? { ttlMs: options.oauthFlowTtlMs } : {}
+	});
+	const settings = createSettingsHandlers({
+		host,
+		env,
+		broadcast
+	});
+	const installs = createCatalogInstallHandlers({
+		host,
+		env,
+		broadcast,
+		setSettings: (patch) => settings["settings.set"]({ patch }, null),
+		...options.remoteInstalls ? { options: options.remoteInstalls } : {}
+	});
+	const authHandlers = createAuthHandlers({ auth });
+	const { markOverrides, ...syncMethods } = createSyncHandlers({
+		host,
+		env,
+		broadcast,
+		auth,
+		setters: {
+			setSettings: (patch) => settings["settings.set"]({ patch }, null),
+			install: (p, peer) => installs["catalog.install"](p, peer),
+			mcpUpsert: (p, peer) => installs["mcp.upsert"](p, peer),
+			mcpRemove: (p, peer) => installs["mcp.remove"](p, peer),
+			setApiKey: (p) => authHandlers["auth.setApiKey"](p, null)
+		},
+		...options.sync ? { options: options.sync } : {}
+	});
+	const machineServe = createMachineServeHandlers({
+		host,
+		dataDir: () => env.userDataDir(),
+		hostName: identity.name,
+		settings: () => env.readSettings(),
+		isConnected: peers.has,
+		...options.machineServe ? { options: options.machineServe } : {}
+	});
+	peers.onClose(browser.releasePeer);
+	peers.onClose(terminal.releasePeer);
+	peers.onClose(launchOverrides.releasePeer);
+	peers.onClose(machineServe.releasePeer);
+	peers.onClose(execStreams.releasePeer);
+	peers.onClose(oauth.releasePeer);
+	const forgetSession = (sessionId) => {
+		drafts.forget(sessionId);
+		launchOverrides.forget(sessionId);
+		suggest.forget(sessionId);
+		signalLog.forget(sessionId);
+		replays.forget(sessionId);
+	};
+	const methods = {
+		...createChatHandlers({
+			host,
+			clearDraft: drafts.clearDraft
+		}),
+		...createQueueHandlers({
+			host,
+			clearDraft: drafts.clearDraft
+		}),
+		...drafts.methods,
+		...suggest.methods,
+		...createExtensionHandlers({
+			env,
+			broadcastExcept
+		}),
+		...launchOverrides.methods,
+		...createSessionHandlers({
+			host,
+			store,
+			broadcast,
+			forgetSession,
+			hostId: identity.id,
+			workspace
+		}),
+		...createTitleHandlers({
+			host,
+			broadcast
+		}),
+		...createSessionReadHandlers({
+			host,
+			store,
+			snapshots: replays
+		}),
+		...createTranscriptHandlers({
+			host,
+			store,
+			broadcast,
+			replays
+		}),
+		...createResumeHandlers({ log: signalLog }),
+		...createContextHandlers({ host }),
+		...createEnvironmentHandlers({
+			host,
+			env,
+			setSettings: settings["settings.set"]
+		}),
+		...createWorkspaceHandlers({ host }),
+		...execStreams.methods,
+		...createFsHandlers({ workspace }),
+		...authHandlers,
+		...oauth.methods,
+		...installs,
+		...createCatalogHandlers({
+			env,
+			host
+		}),
+		...createArtifactHandlers({
+			store,
+			broadcast
+		}),
+		...createHistoryHandlers({
+			host,
+			store
+		}),
+		...createTodoHandlers({
+			host,
+			store
+		}),
+		...createOrchestrationHandlers({ host }),
+		...createHitlHandlers({ host }),
+		...browser.methods,
+		...terminal.methods,
+		...settings,
+		...createPresenceHandlers({
+			env,
+			peers
+		}),
+		...createMachineHandlers({
+			host,
+			broadcast
+		}),
+		...machineServe.methods,
+		...createMachineLinkHandlers({
+			host,
+			env,
+			broadcast,
+			hostId: identity.id,
+			server: identity.kind === "server",
+			appVersion,
+			...options.machineLinks ? { pacing: options.machineLinks } : {}
+		}),
+		"tokens.createMachineToken": (p, peer) => {
+			if (!options.tokens) throw new Error("This host has no tokens to mint (only a zidane-server does).");
+			if (typeof p.name !== "string" || p.name.trim() === "") throw new InvalidParamsError("tokens.createMachineToken: \"name\" must be a non-empty string.");
+			return options.tokens.createMachineToken(p.name.trim().slice(0, 100), peer.principal);
+		},
+		...createDaemonHandlers({
+			host,
+			appVersion,
+			startedAt,
+			lifecycle,
+			identity: identityFields
+		}),
+		...syncMethods,
+		...options.sync ? withSyncOverrides({
+			"settings.set": settings["settings.set"],
+			"mcp.upsert": installs["mcp.upsert"],
+			"mcp.remove": installs["mcp.remove"],
+			"catalog.remove": installs["catalog.remove"],
+			"catalog.update": installs["catalog.update"],
+			"auth.setApiKey": authHandlers["auth.setApiKey"],
+			"auth.remove": authHandlers["auth.remove"]
+		}, {
+			readSettings: () => env.readSettings(),
+			markOverrides
+		}) : {}
+	};
+	/**
+	* Widened view for the string-keyed lookup: the table is typed exhaustively
+	* above; unknown wire methods fall out here. Own keys only: a wire method
+	* named `constructor` / `__proto__` / `toString` is unknown, not a call into
+	* `Object.prototype`.
+	*/
+	const handlerFor = (method) => Object.hasOwn(methods, method) ? methods[method] : void 0;
+	function hello(params, peer) {
+		const verdict = evaluateHello(params, {
+			buildId: IPC_BUILD_ID,
+			codeVersion: ZIDANE_VERSION,
+			hasActiveWork: host.hasActiveWork(),
+			hostKind: identity.kind
+		});
+		if (!verdict.accept) return {
+			ok: false,
+			code: IpcErrorCode.VersionMismatch,
+			message: verdict.message,
+			data: { daemon: {
+				protocolVersion: 13,
+				appVersion,
+				pid: process.pid,
+				startedAt,
+				buildId: IPC_BUILD_ID,
+				codeVersion: ZIDANE_VERSION,
+				...identityFields
+			} }
+		};
+		if (verdict.retire) lifecycle.retireWhenIdle();
+		peer.ready = true;
+		return {
+			ok: true,
+			result: {
+				protocolVersion: 13,
+				appVersion,
+				pid: process.pid,
+				startedAt,
+				buildId: IPC_BUILD_ID,
+				codeVersion: ZIDANE_VERSION,
+				...identityFields,
+				signalEpoch: signalLog.epoch,
+				...lifecycle.isRetiring() ? { retiring: true } : {},
+				...machineServe.allowed() ? { machineServe: true } : {},
+				...remoteInstallsAllowed(options.remoteInstalls) ? { remoteInstalls: true } : {},
+				...options.sync ? { sync: true } : {}
+			}
+		};
+	}
+	return {
+		host,
+		addPeer: peers.add,
+		removePeer: peers.remove,
+		detachAll: peers.clear,
+		peerCount: peers.size,
+		async handleRequest(method, params, peer) {
+			if (method === "$/ping") return {
+				ok: true,
+				result: {}
+			};
+			if (method === "ipc.hello") return hello(params ?? {}, peer);
+			if (!peer.ready && method !== "daemon.shutdown" && method !== "daemon.info") return {
+				ok: false,
+				code: IpcErrorCode.NotHandshaken,
+				message: "Handshake required: send ipc.hello first."
+			};
+			const handler = handlerFor(method);
+			if (!handler && method.startsWith("machine.")) return {
+				ok: false,
+				code: MachineErrorCode.MethodNotAllowed,
+				message: `"${method}" needs a machine connection (a machine-scoped token); this is a client connection.`
+			};
+			if (!handler) return {
+				ok: false,
+				code: -32601,
+				message: `Unknown method "${method}".`
+			};
+			try {
+				checkParams(params);
+				return {
+					ok: true,
+					result: await handler(params, peer) ?? null
+				};
+			} catch (err) {
+				if (err instanceof InvalidParamsError) return {
+					ok: false,
+					code: -32602,
+					message: err.message
+				};
+				const code = err?.code;
+				if (typeof code === "number" && MACHINE_ERROR_CODES.has(code)) return {
+					ok: false,
+					code,
+					message: err.message
+				};
+				return {
+					ok: false,
+					code: IpcErrorCode.HandlerFailed,
+					message: err instanceof Error ? err.message : String(err)
+				};
+			}
+		},
+		async handleNotification(method, params, peer) {
+			if (!peer.ready) return;
+			const handler = handlerFor(method);
+			if (!handler) return;
+			try {
+				checkParams(params);
+				await handler(params, peer);
+			} catch {}
+		}
+	};
+}
+//#endregion
+export { turnCutPoints as a, createDaemonEnvironment as c, connectIpcClient as d, connectOrSpawnDaemon as f, transcriptPage as i, createFileApprovalsStore as l, WHOLE_RUN_PAGES as n, createMachineHandlers as o, createPacedWriter as p, exchangeBoundaries as r, createMachineLinkHandlers as s, createHostDispatcher as t, createHostEnvironment as u };
+
+//# sourceMappingURL=dispatcher-BMlu2BmZ.js.map