@agimon-ai/doompi 0.0.1-alpha.76 → 0.0.1-alpha.78

package/dist/composition/syncState/index.cjs

@@ -0,0 +1,593 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_builders_cli_extensionAssembler_index = require("../../builders/cli/extensionAssembler/index.cjs");
+let node_fs = require("node:fs");
+node_fs = require_runtime.__toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path, 1);
+let _agimon_ai_doompi_core_sync_registration = require("@agimon-ai/doompi-core/sync-registration");
+let _agimon_ai_doompi_config_domains = require("@agimon-ai/doompi-config/domains");
+let node_os = require("node:os");
+node_os = require_runtime.__toESM(node_os, 1);
+let _agimon_ai_doompi_config_profiles = require("@agimon-ai/doompi-config/profiles");
+let _agimon_ai_doompi_core_runtime_json = require("@agimon-ai/doompi-core/runtime-json");
+let node_crypto = require("node:crypto");
+node_crypto = require_runtime.__toESM(node_crypto, 1);
+let _agimon_ai_doompi_core_mcp_projection = require("@agimon-ai/doompi-core/mcp-projection");
+let _agimon_ai_doompi_core_sync_location = require("@agimon-ai/doompi-core/sync-location");
+let _agimon_ai_doompi_core_sync_state_contract = require("@agimon-ai/doompi-core/sync-state-contract");
+//#region src/composition/syncState/index.ts
+/**
+* The file `doom-pi sync` writes and the doom-pi Pi extension reads back.
+*
+* This is the whole contract between the two halves of the synced path. Sync
+* runs in plain Node, where module resolution and the repository config are
+* available; the extension runs inside a Pi session, where neither can be
+* relied on. Everything the extension needs is therefore resolved once here,
+* and everything in this file has to survive JSON.
+*/
+const PI_DIRECTORY = ".pi";
+/** The `.doom` config directory name, under both the repo root and `~/.pi`. */
+const DOOM_CONFIG_DIRECTORY = ".doom";
+const RUN_DIRECTORY = "run";
+const DEFAULT_PRESET = "default";
+const PRIVATE_FILE_MODE = 384;
+const PRIVATE_DIRECTORY_MODE = 448;
+const OWN_PREFIX = "own:";
+const PACKAGE_PREFIX = "pkg:";
+const LOCAL_PREFIX = "local:";
+const LOCAL_PACKAGE_NAME_PREFIX = "local-package-name:";
+const ENTRY_INDEX_SEPARATOR = ":entry:";
+const COMPOSITION_FINGERPRINT = /^[a-f0-9]{64}$/u;
+const PLUGIN_MCP_CONFIG_FILES = [".mcp.json", "mcp.json"];
+const PACKAGE_MANIFEST_FILE = "package.json";
+/** Folder the cockpit bundler compiles straight from each installed package. */
+const WEB_PLUGIN_DIRECTORY = "web";
+/** Config that feeds a sync, in the order the hash reads it. */
+const HASHED_CONFIG_FILES = [
+	"config.yaml",
+	"modes.yaml",
+	"domains.yaml",
+	"profiles.yaml",
+	"hooks.yaml"
+];
+function syncDirectory(repoRoot, homeDirectory = node_os.default.homedir()) {
+	return (0, _agimon_ai_doompi_core_sync_location.resolveSyncLocation)(repoRoot, homeDirectory).directory;
+}
+function syncStatePath(repoRoot, homeDirectory = node_os.default.homedir()) {
+	return (0, _agimon_ai_doompi_core_sync_registration.readSyncRegistration)(repoRoot, homeDirectory)?.statePath ?? (0, _agimon_ai_doompi_core_sync_location.resolveSyncLocation)(repoRoot, homeDirectory).statePath;
+}
+function legacySyncDirectory(repoRoot) {
+	return (0, _agimon_ai_doompi_core_sync_location.resolveSyncLocation)(repoRoot).legacyDirectory;
+}
+function legacySyncStatePath(repoRoot) {
+	return (0, _agimon_ai_doompi_core_sync_location.resolveSyncLocation)(repoRoot).legacyStatePath;
+}
+function canonicalPath(target) {
+	const absolute = node_path.default.resolve(target);
+	try {
+		return node_fs.default.realpathSync(absolute);
+	} catch {
+		const parent = node_path.default.dirname(absolute);
+		if (parent === absolute) return absolute;
+		return node_path.default.join(canonicalPath(parent), node_path.default.basename(absolute));
+	}
+}
+function isInside(directory, target) {
+	const relative = node_path.default.relative(canonicalPath(directory), canonicalPath(target));
+	return relative === "" || !relative.startsWith("..") && !node_path.default.isAbsolute(relative);
+}
+/** Whether generated state belongs to the repository that is reading it. */
+function syncStateRootMatches(repoRoot, stateRoot) {
+	return canonicalPath(repoRoot) === canonicalPath(stateRoot);
+}
+/**
+* Per-process scratch directory for live `/domains` and `/profile` switches.
+*
+* Switching rewrites the MCP config and the persona prompt. Writing those back
+* into the synced directory would both mutate the pinned baseline and let two
+* Pi sessions in one repository overwrite each other, which the launcher avoids
+* by giving every run its own temporary directory.
+*/
+function runDirectory(repoRoot, processId = process.pid, homeDirectory = node_os.default.homedir()) {
+	return node_path.default.join(syncDirectory(repoRoot, homeDirectory), RUN_DIRECTORY, String(processId));
+}
+/**
+* How a Pi project settings file should refer to a generated path.
+*
+* Relative to `.pi` when the target lives in the repository, which keeps the
+* committed settings file identical on every machine. A doom-pi installed
+* outside the repository stays absolute: Pi accepts both, and a relative path
+* climbing out of the project would be neither portable nor readable.
+*/
+function settingsRelativePath(repoRoot, target) {
+	const relative = node_path.default.relative(repoRoot, target);
+	if (relative.startsWith("..") || node_path.default.isAbsolute(relative)) return target;
+	return node_path.default.relative(node_path.default.join(repoRoot, PI_DIRECTORY), target).split(node_path.default.sep).join("/");
+}
+function readIfPresent(filePath) {
+	return node_fs.default.existsSync(filePath) ? node_fs.default.readFileSync(filePath, "utf8") : "";
+}
+function updateFramedHash(hash, label, value) {
+	const bytes = typeof value === "string" ? Buffer.from(value) : value;
+	hash.update(`${String(label.length)}:${label}:${String(bytes.byteLength)}:`);
+	hash.update(bytes);
+}
+/** Hashes path, existence, and bytes without making absent and empty files aliases. */
+function updateFileInputHash(hash, filePath) {
+	const absolutePath = node_path.default.resolve(filePath);
+	updateFramedHash(hash, "path", absolutePath);
+	if (!node_fs.default.existsSync(absolutePath)) {
+		updateFramedHash(hash, "state", "missing");
+		return;
+	}
+	updateFramedHash(hash, "state", "present");
+	updateFramedHash(hash, "contents", node_fs.default.readFileSync(absolutePath));
+}
+/** Package root owning a resolved entry, or undefined when it sits outside one. */
+function owningPackageRoot(entryPath) {
+	if (!node_path.default.isAbsolute(entryPath)) return void 0;
+	let directory = node_path.default.dirname(entryPath);
+	for (;;) {
+		if (node_fs.default.existsSync(node_path.default.join(directory, PACKAGE_MANIFEST_FILE))) return directory;
+		const parent = node_path.default.dirname(directory);
+		if (parent === directory) return void 0;
+		directory = parent;
+	}
+}
+/** Every regular file under a directory, as absolute paths in a stable order. */
+function filesUnder(directory) {
+	if (!node_fs.default.existsSync(directory)) return [];
+	const found = [];
+	const walk = (current) => {
+		for (const entry of node_fs.default.readdirSync(current, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+			const full = node_path.default.join(current, entry.name);
+			if (entry.isDirectory()) walk(full);
+			else if (entry.isFile()) found.push(full);
+		}
+	};
+	walk(directory);
+	return found;
+}
+/**
+* Hashes the cockpit sources and package versions a sync compiled.
+*
+* The cockpit bundle is built from each installed package's `web/` folder by
+* `syncWebBundle`, straight from source, with no compiler manifest recording
+* what went in. Nothing else in the drift check reads those files, so editing a
+* plugin surface and rebuilding left the hub serving the previously bundled
+* cockpit with nothing reporting a reason. Compiled entries are covered
+* elsewhere, by the content digests in their compiler manifests, so only the
+* entry identity and its package version are folded in here.
+*
+* Bounded on purpose: the web sources of a full composition are a few hundred
+* small files, which is cheap enough for the hub to poll.
+*/
+function computeWebSourcesHash(resolved) {
+	const hash = node_crypto.default.createHash("sha256");
+	const roots = [...new Set(Object.values(resolved).flatMap((entry) => owningPackageRoot(entry) ?? []))].sort();
+	for (const root of roots) {
+		updateFramedHash(hash, "package", root);
+		const manifestPath = node_path.default.join(root, PACKAGE_MANIFEST_FILE);
+		let manifest = {};
+		try {
+			manifest = JSON.parse(node_fs.default.readFileSync(manifestPath, "utf8"));
+		} catch {
+			manifest = {};
+		}
+		updateFramedHash(hash, "name", typeof manifest.name === "string" ? manifest.name : "");
+		updateFramedHash(hash, "version", typeof manifest.version === "string" ? manifest.version : "");
+		for (const file of filesUnder(node_path.default.join(root, WEB_PLUGIN_DIRECTORY))) updateFileInputHash(hash, file);
+	}
+	for (const [name, entry] of Object.entries(resolved).sort(([left], [right]) => left.localeCompare(right))) updateFramedHash(hash, "entry", `${name}${entry}`);
+	return hash.digest("hex");
+}
+/** Include declaration changes even for packages that did not previously expose a server facet. */
+function computeServerSourcesHash(resolved) {
+	const hash = node_crypto.default.createHash("sha256");
+	const roots = [...new Set(Object.values(resolved).flatMap((entry) => owningPackageRoot(entry) ?? []))].sort();
+	for (const root of roots) {
+		const manifestPath = node_path.default.join(root, PACKAGE_MANIFEST_FILE);
+		updateFileInputHash(hash, manifestPath);
+		const manifest = JSON.parse(node_fs.default.readFileSync(manifestPath, "utf8"));
+		if (!(0, _agimon_ai_doompi_core_runtime_json.isRecord)(manifest) || !(0, _agimon_ai_doompi_core_runtime_json.isRecord)(manifest.doompiServer) || !(0, _agimon_ai_doompi_core_runtime_json.isRecord)(manifest.doompiServer.contracts)) continue;
+		for (const file of [manifest.doompiServer.contracts.entry, manifest.doompiServer.contracts.dist]) {
+			if (typeof file !== "string" || !file.startsWith("./") || file.split("/").includes("..") || /[\\%?#]/u.test(file)) continue;
+			updateFileInputHash(hash, node_path.default.join(root, file));
+		}
+	}
+	for (const [name, entry] of Object.entries(resolved).sort(([left], [right]) => left.localeCompare(right))) updateFramedHash(hash, "entry", JSON.stringify([name, entry]));
+	return hash.digest("hex");
+}
+/**
+* Hashes the configuration a sync consumed.
+*
+* Deliberately cheap: the extension recomputes this on every session start, so
+* it reads config, marketplace, local plugin manifests, and profile persona text
+* without downloading plugins or re-resolving packages. A dependency upgrade that
+* moves a package path therefore does not show up here; `doom-pi sync --check`
+* re-resolves and is the check that catches that.
+*/
+function computeInputsHash(repoRoot, selection, homeDirectory = node_os.default.homedir()) {
+	repoRoot = (0, _agimon_ai_doompi_core_sync_location.resolveSyncLocation)(repoRoot, homeDirectory).root;
+	const hash = node_crypto.default.createHash("sha256");
+	hash.update(JSON.stringify({
+		...selection,
+		domains: [...selection.domains].sort()
+	}));
+	for (const directory of [node_path.default.join(homeDirectory, PI_DIRECTORY, DOOM_CONFIG_DIRECTORY), node_path.default.join(repoRoot, DOOM_CONFIG_DIRECTORY)]) for (const fileName of HASHED_CONFIG_FILES) hash.update(readIfPresent(node_path.default.join(directory, fileName)));
+	updateFileInputHash(hash, node_path.default.join(repoRoot, ".mcp.json"));
+	const catalog = (0, _agimon_ai_doompi_config_domains.loadDomains)(repoRoot, homeDirectory).plugins;
+	for (const root of catalog.roots) hash.update(root);
+	for (const diagnostic of catalog.diagnostics) hash.update(diagnostic);
+	for (const marketplace of catalog.marketplaces) {
+		hash.update(marketplace);
+		hash.update(readIfPresent(marketplace));
+	}
+	for (const [name, plugin] of Object.entries(catalog.entries).sort(([left], [right]) => left.localeCompare(right))) {
+		hash.update(name);
+		hash.update(JSON.stringify(plugin.source));
+		if (plugin.manifest) {
+			hash.update(plugin.manifest.path);
+			hash.update(readIfPresent(plugin.manifest.path));
+		}
+	}
+	let selectedPluginDirectories = [];
+	try {
+		selectedPluginDirectories = [...new Set((0, _agimon_ai_doompi_config_domains.resolvePluginEntries)(repoRoot, selection.domains, [], homeDirectory).filter((plugin) => plugin.mcp !== false).map((plugin) => node_path.default.resolve(plugin.directory)))].sort();
+	} catch {}
+	for (const directory of selectedPluginDirectories) for (const fileName of PLUGIN_MCP_CONFIG_FILES) updateFileInputHash(hash, node_path.default.join(directory, fileName));
+	for (const profile of (0, _agimon_ai_doompi_config_profiles.loadProfiles)(repoRoot, homeDirectory)) {
+		hash.update(profile.name);
+		hash.update(profile.personaRoot);
+		hash.update(profile.persona);
+		hash.update(JSON.stringify(profile.env));
+		const personaDirectory = node_path.default.resolve(profile.personaRoot, profile.persona);
+		for (const fileName of _agimon_ai_doompi_config_profiles.PERSONA_FILES) {
+			const filePath = node_path.default.join(personaDirectory, fileName);
+			hash.update(filePath);
+			hash.update(readIfPresent(filePath));
+		}
+	}
+	return hash.digest("hex");
+}
+function stringRecord(value, field, statePath) {
+	if (!(0, _agimon_ai_doompi_core_runtime_json.isRecord)(value)) throw new Error(`Doom sync state at ${statePath} requires ${field} to be an object`);
+	return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string"));
+}
+function parsePrecompileState(value, statePath) {
+	if (!(0, _agimon_ai_doompi_core_runtime_json.isRecord)(value) || value.version !== _agimon_ai_doompi_core_sync_state_contract.PRECOMPILE_STATE_VERSION || value.strategy !== "bundle" || typeof value.bootstrapEntry !== "string" || typeof value.bootstrapManifest !== "string" || !(0, _agimon_ai_doompi_core_runtime_json.isRecord)(value.bundleManifests) || Object.entries(value.bundleManifests).some(([fingerprint, manifest]) => !COMPOSITION_FINGERPRINT.test(fingerprint) || typeof manifest !== "string")) throw new Error(`Doom sync state at ${statePath} has an invalid precompile record`);
+	return {
+		version: value.version,
+		strategy: value.strategy,
+		bootstrapEntry: value.bootstrapEntry,
+		bootstrapManifest: value.bootstrapManifest,
+		bundleManifests: value.bundleManifests
+	};
+}
+function precompileMatchesBundles(precompile, bundles) {
+	const bundleFingerprints = Object.keys(bundles ?? {}).sort();
+	const manifestFingerprints = Object.keys(precompile.bundleManifests).sort();
+	return bundleFingerprints.length === manifestFingerprints.length && bundleFingerprints.every((fingerprint, index) => fingerprint === manifestFingerprints[index]);
+}
+function identityMatches(left, right) {
+	return left.repositoryId === right.repositoryId && left.worktreeId === right.worktreeId;
+}
+function parseSyncIdentity(value, statePath) {
+	if (!(0, _agimon_ai_doompi_core_runtime_json.isRecord)(value) || typeof value.repositoryId !== "string" || typeof value.worktreeId !== "string") throw new Error(`Doom sync state at ${statePath} requires repository and worktree identity`);
+	return {
+		repositoryId: value.repositoryId,
+		worktreeId: value.worktreeId
+	};
+}
+function parseSyncState(source, statePath, options) {
+	let parsed;
+	try {
+		parsed = JSON.parse(source);
+	} catch (error) {
+		throw new Error(`Doom sync state at ${statePath} is not valid JSON`, { cause: error });
+	}
+	if (!(0, _agimon_ai_doompi_core_runtime_json.isRecord)(parsed)) throw new Error(`Doom sync state at ${statePath} must be an object`);
+	if (typeof parsed.version !== "number" || parsed.version !== _agimon_ai_doompi_core_sync_state_contract.SYNC_STATE_VERSION) throw new Error(`Doom sync state at ${statePath} has version ${String(parsed.version)}, expected ${_agimon_ai_doompi_core_sync_state_contract.SYNC_STATE_VERSION}. Run doompi sync.`);
+	if (typeof parsed.root !== "string" || typeof parsed.inputsHash !== "string") throw new Error(`Doom sync state at ${statePath} requires string root and inputsHash`);
+	if (typeof parsed.compositionFingerprint !== "string" || !COMPOSITION_FINGERPRINT.test(parsed.compositionFingerprint)) throw new Error(`Doom sync state at ${statePath} requires a canonical compositionFingerprint`);
+	if (parsed.nativeGraphs !== void 0) throw new Error(`Doom sync state at ${statePath} contains removed native graph state. Run doompi sync.`);
+	if (!syncStateRootMatches(options.repoRoot, parsed.root)) throw new Error(`Doom sync state at ${statePath} belongs to a different repository: ${parsed.root}`);
+	const identity = parseSyncIdentity(parsed.identity, statePath);
+	if (!identityMatches(identity, options.location.identity)) throw new Error(`Doom sync state at ${statePath} belongs to a different repository or worktree identity`);
+	if (!(0, _agimon_ai_doompi_core_runtime_json.isRecord)(parsed.selection) || typeof parsed.selection.majorMode !== "string") throw new Error(`Doom sync state at ${statePath} requires a selection with a majorMode`);
+	if (!(0, _agimon_ai_doompi_core_runtime_json.isRecord)(parsed.baseline) || typeof parsed.baseline.themePath !== "string") throw new Error(`Doom sync state at ${statePath} requires a baseline with a themePath`);
+	const { majorMode, domains, profile, preset } = parsed.selection;
+	const fileState = (0, _agimon_ai_doompi_core_runtime_json.isRecord)(parsed.fileState) ? parsed.fileState : {};
+	if (!(0, _agimon_ai_doompi_core_mcp_projection.isDoomMcpProjection)(fileState.mcpProjection)) throw new Error(`Doom sync state at ${statePath} requires a valid MCP projection. Run doompi sync.`);
+	if (!syncStateRootMatches(parsed.root, fileState.mcpProjection.repoRoot)) throw new Error(`Doom sync state at ${statePath} contains an MCP projection for a different repository`);
+	const generatedDirectory = options.legacy ? options.location.legacyDirectory : options.location.directory;
+	const compiled = parsed.compiled === void 0 ? void 0 : stringRecord(parsed.compiled, "compiled", statePath);
+	const bundles = parsed.bundles === void 0 ? void 0 : stringRecord(parsed.bundles, "bundles", statePath);
+	const precompile = parsed.precompile === void 0 ? void 0 : parsePrecompileState(parsed.precompile, statePath);
+	if (precompile && !precompileMatchesBundles(precompile, bundles)) throw new Error(`Doom sync state at ${statePath} has an invalid precompile record`);
+	let serverBundle;
+	if (parsed.serverBundle !== void 0) {
+		const value = parsed.serverBundle;
+		if (!(0, _agimon_ai_doompi_core_runtime_json.isRecord)(value) || typeof value.descriptorPath !== "string" || typeof value.fingerprint !== "string" || !COMPOSITION_FINGERPRINT.test(value.fingerprint) || typeof value.sourcesHash !== "string" || !COMPOSITION_FINGERPRINT.test(value.sourcesHash)) throw new Error(`Doom sync state at ${statePath} has an invalid server bundle record`);
+		const compilerManifests = stringRecord(value.compilerManifests, "server compiler manifests", statePath);
+		if ([value.descriptorPath, ...Object.values(compilerManifests)].some((entry) => !isInside(generatedDirectory, entry))) throw new Error(`Doom sync state at ${statePath} references server material outside ${generatedDirectory}`);
+		serverBundle = {
+			descriptorPath: value.descriptorPath,
+			fingerprint: value.fingerprint,
+			compilerManifests,
+			sourcesHash: value.sourcesHash
+		};
+	}
+	const bootstrap = typeof parsed.bootstrap === "string" ? parsed.bootstrap : void 0;
+	if ([
+		bootstrap,
+		...Object.values(compiled ?? {}),
+		...Object.values(bundles ?? {})
+	].filter((entry) => entry !== void 0).some((entry) => !isInside(generatedDirectory, entry))) throw new Error(`Doom sync state at ${statePath} references generated material outside ${generatedDirectory}`);
+	return {
+		version: parsed.version,
+		root: parsed.root,
+		identity,
+		inputsHash: parsed.inputsHash,
+		webSourcesHash: typeof parsed.webSourcesHash === "string" ? parsed.webSourcesHash : void 0,
+		compositionFingerprint: parsed.compositionFingerprint,
+		selection: {
+			majorMode,
+			domains: Array.isArray(domains) ? domains.filter((name) => typeof name === "string") : [],
+			profile: typeof profile === "string" ? profile : void 0,
+			preset: typeof preset === "string" ? preset : DEFAULT_PRESET
+		},
+		env: stringRecord(parsed.env, "env", statePath),
+		fileState: {
+			profileEnvironment: (0, _agimon_ai_doompi_core_runtime_json.isRecord)(fileState.profileEnvironment) ? fileState.profileEnvironment : {},
+			pluginHooks: Array.isArray(fileState.pluginHooks) ? fileState.pluginHooks : [],
+			mcpProjection: fileState.mcpProjection
+		},
+		resolved: stringRecord(parsed.resolved, "resolved", statePath),
+		compiled,
+		bundles,
+		bootstrap,
+		precompile,
+		...serverBundle ? { serverBundle } : {},
+		baseline: parsed.baseline
+	};
+}
+/** Reads only state reached through this repository/worktree's validated registration. */
+function readLocatedSyncState(repoRoot, homeDirectory = node_os.default.homedir()) {
+	const location = (0, _agimon_ai_doompi_core_sync_location.resolveSyncLocation)(repoRoot, homeDirectory);
+	const registration = (0, _agimon_ai_doompi_core_sync_registration.readSyncRegistration)(repoRoot, homeDirectory);
+	if (!registration) return void 0;
+	return {
+		state: parseSyncState(node_fs.default.readFileSync(registration.statePath, "utf8"), registration.statePath, {
+			repoRoot,
+			location,
+			legacy: false
+		}),
+		location,
+		layout: "global"
+	};
+}
+/** Reads the synced state, or undefined when the repository was never synced. */
+function readSyncState(repoRoot, homeDirectory = node_os.default.homedir()) {
+	return readLocatedSyncState(repoRoot, homeDirectory)?.state;
+}
+function serializeSyncState(state) {
+	return `${JSON.stringify(state, null, 2)}\n`;
+}
+async function writeSyncState(repoRoot, state, homeDirectory = node_os.default.homedir(), targetPath) {
+	const location = (0, _agimon_ai_doompi_core_sync_location.resolveSyncLocation)(repoRoot, homeDirectory);
+	const statePath = targetPath ?? location.statePath;
+	if (state.version !== _agimon_ai_doompi_core_sync_state_contract.SYNC_STATE_VERSION) throw new Error(`Doom sync state writes require version ${_agimon_ai_doompi_core_sync_state_contract.SYNC_STATE_VERSION}`);
+	if (!COMPOSITION_FINGERPRINT.test(state.compositionFingerprint)) throw new Error("Doom sync state writes require a canonical composition fingerprint");
+	if (!(0, _agimon_ai_doompi_core_mcp_projection.isDoomMcpProjection)(state.fileState.mcpProjection)) throw new Error("Doom sync state writes require a valid MCP projection");
+	if (!syncStateRootMatches(state.root, state.fileState.mcpProjection.repoRoot)) throw new Error("Refusing to write a Doom sync state whose MCP projection belongs to another repository");
+	if (!syncStateRootMatches(repoRoot, state.root) || !identityMatches(state.identity, location.identity)) throw new Error("Refusing to write Doom sync state for a different repository or worktree");
+	if (state.precompile) {
+		if (!precompileMatchesBundles(parsePrecompileState(state.precompile, statePath), state.bundles)) throw new Error(`Doom sync state at ${statePath} has an invalid precompile record`);
+	}
+	if (!isInside(location.directory, statePath)) throw new Error(`Refusing to write Doom sync state outside ${location.directory}`);
+	(0, _agimon_ai_doompi_core_sync_location.assertSyncLocationSafe)(location);
+	await node_fs.default.promises.mkdir(node_path.default.dirname(statePath), {
+		mode: PRIVATE_DIRECTORY_MODE,
+		recursive: true
+	});
+	const temporaryPath = `${statePath}.${process.pid}.${node_crypto.default.randomUUID()}.tmp`;
+	try {
+		await node_fs.default.promises.writeFile(temporaryPath, serializeSyncState(state), { mode: PRIVATE_FILE_MODE });
+		await node_fs.default.promises.rename(temporaryPath, statePath);
+	} catch (error) {
+		await node_fs.default.promises.rm(temporaryPath, { force: true });
+		throw error;
+	}
+	return statePath;
+}
+function ownKey(name) {
+	return `${OWN_PREFIX}${name}`;
+}
+function packageKey(specifier) {
+	return `${PACKAGE_PREFIX}${specifier}`;
+}
+function packageEntryKey(specifier, index) {
+	return index === 0 ? packageKey(specifier) : `${packageKey(specifier)}${ENTRY_INDEX_SEPARATOR}${index}`;
+}
+/**
+* Keyed by the absolute target, because the same relative specifier means
+* different files under the repository and the global config directory.
+*/
+function localKey(specifier, baseDirectory) {
+	return `${LOCAL_PREFIX}${node_path.default.resolve(baseDirectory, specifier)}`;
+}
+function localEntryKey(specifier, baseDirectory, index) {
+	return index === 0 ? localKey(specifier, baseDirectory) : `${localKey(specifier, baseDirectory)}${ENTRY_INDEX_SEPARATOR}${index}`;
+}
+function localPackageNameKey(specifier, baseDirectory) {
+	return `${LOCAL_PACKAGE_NAME_PREFIX}${node_path.default.resolve(baseDirectory, specifier)}`;
+}
+/**
+* Resolvers that record what they resolve.
+*
+* Sync composes once with every layer selected and hands the recording to the
+* state file, so the extension never has to resolve a specifier itself.
+*/
+function createRecordingResolvers(base = require_builders_cli_extensionAssembler_index.LAYER_RESOLVERS) {
+	const resolved = {};
+	const extensionBase = base;
+	const recordEntries = (entries, keyFor) => {
+		entries.forEach((entry, index) => {
+			resolved[keyFor(index)] = entry;
+		});
+		return entries;
+	};
+	return {
+		resolved,
+		ownEntry(name) {
+			const entry = base.ownEntry(name);
+			resolved[ownKey(name)] = entry;
+			return entry;
+		},
+		packageEntry(name) {
+			const entry = base.packageEntry(name);
+			resolved[packageKey(name)] = entry;
+			return entry;
+		},
+		optionalPackageEntry(name) {
+			const entry = base.optionalPackageEntry(name);
+			if (entry) resolved[packageKey(name)] = entry;
+			return entry;
+		},
+		packageEntries(name) {
+			const entries = extensionBase.packageEntries?.(name) ?? [base.packageEntry(name)];
+			return recordEntries(entries, (index) => packageEntryKey(name, index));
+		},
+		optionalPackageEntries(name) {
+			let entries = extensionBase.optionalPackageEntries?.(name);
+			if (entries === void 0) {
+				const entry = base.optionalPackageEntry(name);
+				entries = entry ? [entry] : void 0;
+			}
+			return entries ? recordEntries(entries, (index) => packageEntryKey(name, index)) : void 0;
+		},
+		localEntry(specifier, baseDirectory) {
+			const entry = base.localEntry(specifier, baseDirectory);
+			if (entry) resolved[localKey(specifier, baseDirectory)] = entry;
+			return entry;
+		},
+		localEntries(specifier, baseDirectory) {
+			let entries = extensionBase.localEntries?.(specifier, baseDirectory);
+			if (entries === void 0) {
+				const entry = base.localEntry(specifier, baseDirectory);
+				entries = entry ? [entry] : void 0;
+			}
+			return entries ? recordEntries(entries, (index) => localEntryKey(specifier, baseDirectory, index)) : void 0;
+		},
+		localPackageName(specifier, baseDirectory) {
+			const name = extensionBase.localPackageName?.(specifier, baseDirectory);
+			if (name) resolved[localPackageNameKey(specifier, baseDirectory)] = name;
+			return name;
+		}
+	};
+}
+/**
+* Resolves every entry any layer could contribute, in one pass.
+*
+* Composing with every layer selected and the widest options is what makes the
+* map complete: a later `/mode` switch inside a Pi session can then pick a
+* different set without resolving anything itself. The persona entry is asked
+* for separately because it remains a fixed host entry rather than a layer.
+*/
+function recordResolvedEntries(majorModesConfig, base = require_builders_cli_extensionAssembler_index.LAYER_RESOLVERS) {
+	const recording = createRecordingResolvers(base);
+	recording.packageEntry(require_builders_cli_extensionAssembler_index.PERSONA_ENTRY);
+	require_builders_cli_extensionAssembler_index.assembleExtensions({
+		agents: true,
+		autoStop: true,
+		mute: false,
+		preset: require_builders_cli_extensionAssembler_index.OLLAMA_PRESET,
+		layers: Object.keys(majorModesConfig.layers),
+		majorModesConfig,
+		resolvers: recording
+	});
+	require_builders_cli_extensionAssembler_index.assembleChildExtensions({
+		agents: false,
+		autoStop: false,
+		mute: true,
+		preset: require_builders_cli_extensionAssembler_index.OLLAMA_PRESET,
+		layers: Object.keys(majorModesConfig.layers),
+		majorModesConfig,
+		resolvers: recording
+	});
+	return recording.resolved;
+}
+/** Resolvers backed by a synced map, for composing inside a Pi session. */
+function createMapResolvers(resolved, compiled = {}) {
+	const entryFor = (key) => compiled[key] ?? resolved[key];
+	const lookup = (key, name) => {
+		const entry = entryFor(key);
+		if (!entry) throw new Error(`${name} is missing from the doompi sync state. Run doompi sync.`);
+		return entry;
+	};
+	const indexedEntries = (keyFor) => {
+		const first = entryFor(keyFor(0));
+		if (!first) return void 0;
+		const entries = [first];
+		for (let index = 1;; index += 1) {
+			const entry = entryFor(keyFor(index));
+			if (!entry) break;
+			entries.push(entry);
+		}
+		return entries;
+	};
+	return {
+		ownEntry: (name) => lookup(ownKey(name), name),
+		packageEntry: (name) => lookup(packageKey(name), name),
+		optionalPackageEntry: (name) => entryFor(packageKey(name)),
+		packageEntries: (name) => {
+			const entries = indexedEntries((index) => packageEntryKey(name, index));
+			if (!entries) throw new Error(`${name} is missing from the doompi sync state. Run doompi sync.`);
+			return entries;
+		},
+		optionalPackageEntries: (name) => indexedEntries((index) => packageEntryKey(name, index)),
+		localEntry: (specifier, baseDirectory) => entryFor(localKey(specifier, baseDirectory)),
+		localEntries: (specifier, baseDirectory) => indexedEntries((index) => localEntryKey(specifier, baseDirectory, index)),
+		localPackageName: (specifier, baseDirectory) => resolved[localPackageNameKey(specifier, baseDirectory)]
+	};
+}
+/** Reads the resolved MCP servers back out of a generated config. */
+function readMcpServerNames(configPath) {
+	if (!node_fs.default.existsSync(configPath)) return [];
+	const config = JSON.parse(node_fs.default.readFileSync(configPath, "utf8"));
+	return (0, _agimon_ai_doompi_core_runtime_json.isRecord)(config.mcpServers) ? Object.keys(config.mcpServers) : [];
+}
+//#endregion
+Object.defineProperty(exports, "SYNC_STATE_VERSION", {
+	enumerable: true,
+	get: function() {
+		return _agimon_ai_doompi_core_sync_state_contract.SYNC_STATE_VERSION;
+	}
+});
+exports.computeInputsHash = computeInputsHash;
+exports.computeServerSourcesHash = computeServerSourcesHash;
+exports.computeWebSourcesHash = computeWebSourcesHash;
+exports.createMapResolvers = createMapResolvers;
+exports.createRecordingResolvers = createRecordingResolvers;
+exports.legacySyncDirectory = legacySyncDirectory;
+exports.legacySyncStatePath = legacySyncStatePath;
+exports.localEntryKey = localEntryKey;
+exports.localKey = localKey;
+exports.localPackageNameKey = localPackageNameKey;
+exports.ownKey = ownKey;
+exports.packageEntryKey = packageEntryKey;
+exports.packageKey = packageKey;
+exports.readLocatedSyncState = readLocatedSyncState;
+exports.readMcpServerNames = readMcpServerNames;
+exports.readSyncState = readSyncState;
+exports.recordResolvedEntries = recordResolvedEntries;
+exports.runDirectory = runDirectory;
+exports.serializeSyncState = serializeSyncState;
+exports.settingsRelativePath = settingsRelativePath;
+exports.syncDirectory = syncDirectory;
+exports.syncStatePath = syncStatePath;
+exports.syncStateRootMatches = syncStateRootMatches;
+exports.writeSyncState = writeSyncState;
+
+//# sourceMappingURL=index.cjs.map