@agimon-ai/po 0.0.0-alpha.0

package/dist/src/composition/syncService/index.cjs

@@ -0,0 +1,808 @@
+const require_runtime = require("../../../_virtual/_rolldown/runtime.cjs");
+const require_entryResolution = require("../../builders/cli/entryResolution.cjs");
+const require_index = require("../../builders/web/index.cjs");
+const require_index$1 = require("../../builders/native/index.cjs");
+const require_index$2 = require("../layerPackageInstaller/index.cjs");
+const require_sessionComposition = require("../../builders/cli/sessionComposition.cjs");
+const require_mcpAppBuild = require("../../builders/server/mcpAppBuild.cjs");
+const require_mcpBundle = require("../../builders/server/mcpBundle.cjs");
+const require_index$3 = require("../syncPrune/index.cjs");
+const require_localBuilds = require("./localBuilds.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_po_core_runtimeJson = require("@agimon-ai/po-core/runtimeJson");
+let node_child_process = require("node:child_process");
+let _agimon_ai_po_config_config = require("@agimon-ai/po-config/config");
+let _agimon_ai_po_config_majorModes = require("@agimon-ai/po-config/majorModes");
+let _agimon_ai_po_core_piSettings = require("@agimon-ai/po-core/piSettings");
+let node_crypto = require("node:crypto");
+node_crypto = require_runtime.__toESM(node_crypto, 1);
+let _agimon_ai_po_core_history = require("@agimon-ai/po-core/history");
+//#region src/composition/syncService/index.ts
+/**
+* The sync service: installs what the configuration names, ensures the global builds,
+* prunes, and reports what happened as one `SyncReport`.
+*
+* The roots are the Po home, every registered workspace whose folder exists, and the
+* repository sync runs from, which it registers. One install covers the catalogue and every
+* root's published packages. When the signature over the catalogue, each root's selection,
+* each local package's build stamp and the host identity (the po package and po-web host
+* versions) matches `current.json` and every artifact it names exists, sync returns `noop`
+* without installing or building. The pointer records that identity, so a server from another
+* Po install can tell the build is not its own.
+*
+* Only one sync runs at a time per Po home, guarded by `<po home>/build/.sync.lock`. A CLI
+* run that finds the lock held reports `busy`. A background run instead leaves
+* `.sync.rerun`, and the holder runs once more, so the background request is never lost.
+*/
+const BUILD_DIRECTORY = "build";
+const LOCK_FILE = ".sync.lock";
+const RERUN_FILE = ".sync.rerun";
+const POINTER_FILE = "current.json";
+const LAST_ATTEMPT_FILE = "last-attempt.json";
+const MCP_APP_FILE = "index.html";
+const HOOK_EMITTER = node_path.default.join("tools", "harness", "emit-hooks.mjs");
+const ROOTS_LABEL = "roots";
+const PACKAGES_LABEL = "packages";
+const WEB_LABEL = "web";
+const NATIVE_LABEL = "native";
+const MCP_LABEL = "mcp app";
+const PRUNE_LABEL = "prune";
+const HOOKS_LABEL = "hooks";
+const LOCAL_LABEL = "local";
+const BYTES_PER_MEGABYTE = 1048576;
+/** A lock file younger than this that cannot be parsed is still being written by its owner. */
+const UNREADABLE_LOCK_GRACE_MS = 1e4;
+const NO_SUCH_PROCESS = "ESRCH";
+/**
+* Bumped when the pointer gains a field a reader relies on, so an older pointer never matches
+* the fast-exit signature and the next sync rewrites it. 2: per-root `fingerprints`. 3: `host`.
+*/
+const SIGNATURE_FORMAT = 3;
+const PACKAGE_MANIFEST = "package.json";
+const ALREADY_EXISTS = "EEXIST";
+const NO_SUCH_FILE = "ENOENT";
+/** `process.kill(pid, 0)` probes without signalling; only ESRCH means the process is gone. */
+function processIsAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code !== NO_SUCH_PROCESS;
+	}
+}
+const DEFAULT_DEPS = {
+	install: require_index$2.ensureLayerPackages,
+	buildWeb: require_index.ensureGlobalWebBuild,
+	buildNative: require_index$1.ensureGlobalNativeBuild,
+	bundleMcpApp: require_mcpAppBuild.ensureMcpAppBuild,
+	prune: require_index$3.pruneAfterSync,
+	isAlive: processIsAlive,
+	pid: process.pid,
+	now: () => /* @__PURE__ */ new Date()
+};
+function syncExitCode(status) {
+	if (status === "busy") return 75;
+	return status === "ok" || status === "noop" ? 0 : 1;
+}
+function syncLockPath(globalRoot) {
+	return node_path.default.join(globalRoot, BUILD_DIRECTORY, LOCK_FILE);
+}
+function syncRerunPath(globalRoot) {
+	return node_path.default.join(globalRoot, BUILD_DIRECTORY, RERUN_FILE);
+}
+function pluralize(count, noun) {
+	return `${String(count)} ${noun}${count === 1 ? "" : "s"}`;
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function packageSummary(result) {
+	const parts = [];
+	if (result.updated.length > 0) parts.push(`updated ${pluralize(result.updated.length, "package")}`);
+	if (result.installed.length > 0) parts.push(`installed ${pluralize(result.installed.length, "missing package")}`);
+	if (parts.length === 0) parts.push("already up to date");
+	if (result.unchecked.length > 0) parts.push(`${pluralize(result.unchecked.length, "package")} left unchecked`);
+	return parts.join(", ");
+}
+function formatSyncResult(result) {
+	return [
+		`packages: ${packageSummary(result.packages)}`,
+		`web:      ${result.web.status === "skipped" ? result.web.reason : `${result.web.key} (${result.web.status})`}`,
+		...result.native === void 0 ? [] : [`native:   ${result.native.status === "skipped" ? result.native.reason : `${result.native.key} (${result.native.status})`}`],
+		...result.mcpApp === void 0 ? [] : [`mcp app:  ${result.mcpApp}`],
+		""
+	].join("\n");
+}
+function workspaceRegistry(homeDirectory, environment, onNotice) {
+	return (0, _agimon_ai_po_core_history.createWorkspaceRegistry)({
+		directory: node_path.default.join((0, _agimon_ai_po_core_piSettings.piAgentDirectory)(environment, homeDirectory), "server"),
+		onNotice
+	});
+}
+/**
+* Each root's compositions, resolved the way the server resolves them: a selection that does
+* not resolve yet (an unbuilt local package, say) is left out with a diagnostic instead of
+* failing the whole root, so sync and the server derive the same web, MCP and fingerprint
+* inputs. A root that cannot be composed at all maps to why.
+*/
+function composeRoots(roots, homeDirectory, environment) {
+	return new Map(roots.map((root) => {
+		try {
+			return [root, require_sessionComposition.rootCompositions({
+				root,
+				homeDirectory,
+				environment,
+				tolerateUnsynced: true
+			})];
+		} catch (error) {
+			return [root, error instanceof Error ? error : new Error(String(error))];
+		}
+	}));
+}
+/** Each root's composition package roots; a root that cannot be composed is left out with a notice. */
+function packageRootsByRoot(composed, onNotice) {
+	return new Map([...composed].map(([root, compositions]) => {
+		if (!(compositions instanceof Error)) return [root, require_index.compositionPackageRoots(compositions)];
+		onNotice(`'${root}' is left out of the web build: ${compositions.message}`);
+		return [root, []];
+	}));
+}
+/** The selectors a lenient composition left out, each once with the first diagnostic that explains it. */
+function skippedSelections(compositions) {
+	const skipped = /* @__PURE__ */ new Map();
+	for (const composition of compositions) for (const selection of composition.selections) if (selection.outcome === "missing-optional" && !selection.optional && !skipped.has(selection.selector)) skipped.set(selection.selector, selection.diagnostic ?? "it does not resolve");
+	return [...skipped].map(([selector, reason]) => ({
+		selector,
+		reason
+	}));
+}
+/**
+* The plugin roots one global web build covers: every installed catalogue package, so each
+* first-party plugin has a slot whether or not a config names it yet, then each root's own
+* composition package roots. Sync builds with these and the server derives the same key.
+*/
+function webPluginRootsOf(globalRoot, rootPackageRoots, environment) {
+	return [...require_index$2.catalogPackageRoots(globalRoot, environment), ...[...rootPackageRoots.values()].flat()];
+}
+/**
+* Every package root the global web build covers: the catalogue packages, the global root,
+* every workspace the server has admitted, and `targetRoot`, which the server admits when it
+* opens it. A root whose configuration cannot be read is left out with a notice, as sync
+* leaves it out of the build when it cannot compose it.
+*/
+function globalWebPluginRoots(targetRoot, homeDirectory, environment, onNotice) {
+	const globalRoot = (0, _agimon_ai_po_config_config.globalDoomConfigDirectory)(homeDirectory);
+	const admitted = workspaceRegistry(homeDirectory, environment, onNotice).list().map((workspace) => workspace.root).filter((root) => node_fs.default.existsSync(root));
+	return webPluginRootsOf(globalRoot, packageRootsByRoot(composeRoots([.../* @__PURE__ */ new Set([
+		globalRoot,
+		...admitted,
+		targetRoot
+	])], homeDirectory, environment), onNotice), environment);
+}
+/**
+* Registers the repository as a workspace the way the server admits one, so one repository
+* never gets two ids, and returns the workspace root it belongs to.
+*/
+function registerRepository(registry, repoRoot, onNotice) {
+	const checkoutRoot = node_fs.default.realpathSync(repoRoot);
+	const { id, root, moved } = (0, _agimon_ai_po_core_history.identifyWorkspace)({
+		records: registry.list(),
+		checkoutRoot,
+		marker: (0, _agimon_ai_po_core_history.readWorkspaceMarker)(checkoutRoot)
+	});
+	const record = registry.list().find((workspace) => workspace.id === id);
+	if (record === void 0 || moved) registry.add({
+		id,
+		root,
+		...record?.name === void 0 ? {} : { name: record.name }
+	});
+	if (moved) onNotice(`workspace '${id}' moved to '${root}'`);
+	try {
+		if ((0, _agimon_ai_po_core_history.readWorkspaceMarker)(root) === void 0) (0, _agimon_ai_po_core_history.writeWorkspaceMarker)(root, id);
+	} catch (error) {
+		onNotice(`'${root}' id could not be recorded in its git data: ${errorMessage(error)}`);
+	}
+	return root;
+}
+/**
+* The roots this sync covers: the Po home, every registered workspace whose folder exists,
+* and the repository, registered first. Entries whose folder is gone are removed with a warning.
+*/
+function resolveRoots(options, progress) {
+	const notice = (message) => progress.line(ROOTS_LABEL, message);
+	const registry = workspaceRegistry(options.homeDirectory, options.environment, notice);
+	const repository = options.repoRoot === void 0 || node_path.default.resolve(options.repoRoot) === node_path.default.resolve(options.globalRoot) ? void 0 : registerRepository(registry, options.repoRoot, notice);
+	const live = [];
+	for (const workspace of registry.list()) {
+		if (node_fs.default.existsSync(workspace.root)) {
+			live.push(workspace.root);
+			continue;
+		}
+		notice(`warning: removed workspace '${workspace.id}': '${workspace.root}' no longer exists`);
+		registry.remove(workspace.id);
+	}
+	return [.../* @__PURE__ */ new Set([
+		options.globalRoot,
+		...live,
+		...repository === void 0 ? [] : [repository]
+	])];
+}
+/** The packages a root's layers name by local path, each resolved against its layer's base directory. */
+function localPackages(config) {
+	const definitions = [...config.default ? [config.default] : [], ...Object.values(config.layers)];
+	const packages = /* @__PURE__ */ new Map();
+	for (const definition of definitions) for (const configured of definition.packages ?? []) {
+		const selector = typeof configured === "string" ? configured : configured.name;
+		if (!(0, _agimon_ai_po_config_majorModes.isLocalPackageSpecifier)(selector)) continue;
+		const directory = node_path.default.resolve(definition.baseDirectory, selector);
+		if (!packages.has(directory)) packages.set(directory, {
+			selector,
+			directory
+		});
+	}
+	return [...packages.values()];
+}
+/**
+* SHA-256 over every mode's composition fingerprint, or why the root cannot be composed. The
+* pointer records it per root, so a server can tell a root whose selection changed since the
+* last sync by computing it again with the environment sync ran under.
+*/
+function rootSelectionFingerprint(root, homeDirectory, environment) {
+	try {
+		const fingerprints = require_sessionComposition.rootCompositions({
+			root,
+			homeDirectory,
+			environment,
+			tolerateUnsynced: true
+		}).map((composition) => composition.fingerprint);
+		return node_crypto.default.createHash("sha256").update(fingerprints.join("\n")).digest("hex");
+	} catch (error) {
+		return `unresolved:${errorMessage(error)}`;
+	}
+}
+/** The po package version this process runs from, or why it cannot be read. */
+function poPackageVersion() {
+	try {
+		const manifest = JSON.parse(node_fs.default.readFileSync(node_path.default.join(require_entryResolution.poPackageRoot(), PACKAGE_MANIFEST), "utf8"));
+		return typeof manifest.version === "string" ? manifest.version : "unversioned";
+	} catch (error) {
+		return `unreadable:${errorMessage(error)}`;
+	}
+}
+/**
+* The Po install a sync or a server runs from: its po package version and the po-web host
+* version it builds with. Sync records it in the pointer; a server whose identity differs
+* refuses that pointer's builds and syncs with its own install.
+*/
+function syncHostIdentity(globalRoot, environment) {
+	return `po@${poPackageVersion()}+po-web@${require_index.webHostVersion(globalRoot, environment)}`;
+}
+/** The fast-exit signature: catalogue hash, each root's selection and local build stamps, host identity. */
+function syncSignature(options, roots, catalogueHash) {
+	const { homeDirectory, environment } = options;
+	const value = {
+		format: SIGNATURE_FORMAT,
+		catalogueHash,
+		roots: roots.map((root) => ({
+			root,
+			selection: rootSelectionFingerprint(root, homeDirectory, environment),
+			local: localPackages((0, _agimon_ai_po_config_majorModes.loadMajorModesConfigLenient)(root, homeDirectory, environment).config).map(({ directory }) => [directory, require_localBuilds.localBuildStamp(directory)])
+		})),
+		host: syncHostIdentity(options.globalRoot, environment)
+	};
+	return node_crypto.default.createHash("sha256").update(JSON.stringify(value)).digest("hex");
+}
+function syncPointerPath(globalRoot) {
+	return node_path.default.join(globalRoot, BUILD_DIRECTORY, POINTER_FILE);
+}
+function syncLastAttemptPath(globalRoot) {
+	return node_path.default.join(globalRoot, BUILD_DIRECTORY, LAST_ATTEMPT_FILE);
+}
+/** The current pointer, or undefined when sync has not written one yet or it is unreadable. */
+function readSyncPointer(globalRoot) {
+	try {
+		const parsed = JSON.parse(node_fs.default.readFileSync(syncPointerPath(globalRoot), "utf8"));
+		return typeof parsed.signature === "string" && typeof parsed.generation === "number" ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+/** The files whose presence proves each artifact a pointer names is complete. */
+function pointerArtifacts(globalRoot, pointer) {
+	const build = node_path.default.join(globalRoot, BUILD_DIRECTORY);
+	return [
+		...pointer.webKey === null ? [] : [node_path.default.join(build, WEB_LABEL, pointer.webKey, require_index.BUILD_RECORD)],
+		...pointer.nativeKey === null ? [] : [node_path.default.join(build, NATIVE_LABEL, pointer.nativeKey, require_index.BUILD_RECORD)],
+		...pointer.mcpKeys.map((key) => node_path.default.join(build, "mcp-app", key, MCP_APP_FILE))
+	];
+}
+/** The report of the last sync attempt, successful or not, or undefined when there is none. */
+function readSyncLastAttempt(globalRoot) {
+	try {
+		const parsed = JSON.parse(node_fs.default.readFileSync(syncLastAttemptPath(globalRoot), "utf8"));
+		return Array.isArray(parsed.roots) ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+function writeJsonFile(file, value) {
+	(0, _agimon_ai_po_core_runtimeJson.writeFileAtomic)(file, `${JSON.stringify(value, null, 2)}\n`);
+}
+function readHolder(lockPath) {
+	try {
+		const parsed = JSON.parse(node_fs.default.readFileSync(lockPath, "utf8"));
+		return typeof parsed.pid === "number" ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+function lockIsStale(lockPath, deps) {
+	const holder = readHolder(lockPath);
+	if (holder !== void 0) return !deps.isAlive(holder.pid);
+	try {
+		return deps.now().getTime() - node_fs.default.statSync(lockPath).mtimeMs > UNREADABLE_LOCK_GRACE_MS;
+	} catch {
+		return true;
+	}
+}
+function tryCreateLock(lockPath, holder) {
+	try {
+		const descriptor = node_fs.default.openSync(lockPath, "wx");
+		try {
+			node_fs.default.writeSync(descriptor, JSON.stringify(holder));
+		} finally {
+			node_fs.default.closeSync(descriptor);
+		}
+		return true;
+	} catch (error) {
+		if (error.code === ALREADY_EXISTS) return false;
+		throw error;
+	}
+}
+/**
+* Takes over a lock judged stale. Removing it by path could remove a lock another taker created
+* since the check, so it is first renamed to a name only this process knows and checked again
+* there: a lock that turns out live is linked back (link never replaces), a stale one is dropped
+* before the exclusive create, which at most one taker wins.
+*/
+function takeOverStaleLock(lockPath, holder, deps) {
+	const moved = `${lockPath}.${String(deps.pid)}.${node_crypto.default.randomUUID()}.stale`;
+	try {
+		node_fs.default.renameSync(lockPath, moved);
+	} catch (error) {
+		if (error.code === NO_SUCH_FILE) return tryCreateLock(lockPath, holder);
+		throw error;
+	}
+	try {
+		if (!lockIsStale(moved, deps)) {
+			try {
+				node_fs.default.linkSync(moved, lockPath);
+			} catch (error) {
+				if (error.code !== ALREADY_EXISTS) throw error;
+			}
+			return false;
+		}
+	} finally {
+		node_fs.default.rmSync(moved, { force: true });
+	}
+	return tryCreateLock(lockPath, holder);
+}
+/** Creates the lock, taking over one whose holder is dead. Never inspects other processes beyond `kill(pid, 0)`. */
+function acquireLock(lockPath, origin, deps) {
+	node_fs.default.mkdirSync(node_path.default.dirname(lockPath), { recursive: true });
+	const token = node_crypto.default.randomUUID();
+	const holder = {
+		pid: deps.pid,
+		token,
+		startedAt: deps.now().toISOString(),
+		origin
+	};
+	if (tryCreateLock(lockPath, holder)) return {
+		acquired: true,
+		token
+	};
+	if (lockIsStale(lockPath, deps) && takeOverStaleLock(lockPath, holder, deps)) return {
+		acquired: true,
+		token
+	};
+	return {
+		acquired: false,
+		holder: readHolder(lockPath)
+	};
+}
+/**
+* The lock as the holder with `token` sees it: undefined while the lock still names it, else
+* the busy report to stop with. A takeover that moved a live lock aside can let a third taker
+* create a new one, so a holder checks before each step whose overlap would do harm.
+*/
+function lostLock(lockPath, token, deps) {
+	const holder = readHolder(lockPath);
+	if (holder?.token === token) return void 0;
+	return emptyReport("busy", [`po sync lost its lock to ${holder === void 0 ? "another process" : `pid ${String(holder.pid)}`}`], deps);
+}
+function releaseLock(lockPath, token) {
+	if (readHolder(lockPath)?.token === token) node_fs.default.rmSync(lockPath, { force: true });
+}
+/** Consumes the rerun marker; true when a background run asked for another pass. */
+function takeRerunRequest(rerunPath) {
+	if (!node_fs.default.existsSync(rerunPath)) return false;
+	node_fs.default.rmSync(rerunPath, { force: true });
+	return true;
+}
+function emptyReport(status, errors, deps) {
+	return {
+		status,
+		generation: null,
+		catalogueHash: null,
+		webKey: null,
+		mcpKeys: [],
+		roots: [],
+		commands: [],
+		errors,
+		finishedAt: deps.now().toISOString()
+	};
+}
+/** A step reporter over the event stream, mirroring the presenter's start/done/line. */
+function steps(emit) {
+	return {
+		start(label, message) {
+			emit({
+				type: "start",
+				label,
+				message
+			});
+			return (summary) => emit({
+				type: "done",
+				label,
+				summary
+			});
+		},
+		line(label, message) {
+			emit({
+				type: "line",
+				label,
+				message
+			});
+		}
+	};
+}
+/**
+* Drops old builds and unreferenced store content once installs and builds are done.
+* Never fatal: a failed prune leaves everything for the next explicit sync.
+*/
+async function pruneStep(progress, prune, input) {
+	const done = progress.start(PRUNE_LABEL, "dropping old builds and unused packages");
+	try {
+		const result = await prune(input);
+		const runtime = "skipped" in result.runtime ? result.runtime.skipped : `${(result.runtime.bytes / BYTES_PER_MEGABYTE).toFixed(1)} MB of packages released`;
+		done(`removed ${pluralize(result.builds.length, "old build")}, ${runtime}`);
+	} catch (error) {
+		done(`failed: ${errorMessage(error)}`);
+	}
+}
+/** Regenerates the hook files the other frontends read before any harness code runs, in a root that has the emitter. */
+function emitFrontendHooks(root, progress, commands) {
+	const emitter = node_path.default.join(root, HOOK_EMITTER);
+	if (!node_fs.default.existsSync(emitter)) return;
+	commands.push(`${process.execPath} ${emitter} --write`);
+	const result = (0, node_child_process.spawnSync)(process.execPath, [emitter, "--write"], {
+		cwd: root,
+		encoding: "utf8"
+	});
+	if (result.status === 0) {
+		progress.line(HOOKS_LABEL, `regenerated for Claude Code and Codex in '${root}'`);
+		return;
+	}
+	progress.line(HOOKS_LABEL, `emit-hooks failed in '${root}' (${result.stderr?.trim() || `exit ${String(result.status)}`})`);
+}
+/** A path with its symlinks resolved, or as given when it does not exist. */
+function realPath(file) {
+	try {
+		return node_fs.default.realpathSync(file);
+	} catch {
+		return node_path.default.resolve(file);
+	}
+}
+/**
+* One sync pass under the lock. A failed step ends the pass with a `failed` report and leaves
+* the pointer alone; a lock that no longer names this holder (`lost`) ends it as busy.
+*/
+async function syncOnce(options, deps, emit, lost) {
+	const { homeDirectory, environment, globalRoot } = options;
+	const progress = steps(emit);
+	const commands = [];
+	const roots = resolveRoots(options, progress);
+	const catalogueHash = require_index$2.packageCatalogHash(environment);
+	const previous = readSyncPointer(globalRoot);
+	if (previous !== void 0 && (options.origin === "background" || previous.roots.every((root) => root.unsynced.length === 0)) && previous.signature === syncSignature(options, roots, catalogueHash) && pointerArtifacts(globalRoot, previous).every((file) => node_fs.default.existsSync(file))) {
+		progress.line(ROOTS_LABEL, `nothing changed since generation ${String(previous.generation)}`);
+		return {
+			...emptyReport("noop", [], deps),
+			generation: previous.generation,
+			catalogueHash,
+			webKey: previous.webKey,
+			mcpKeys: previous.mcpKeys,
+			roots: previous.roots
+		};
+	}
+	const unsynced = new Map(roots.map((root) => [root, []]));
+	const report = (status, errors, webKey, mcpKeys) => {
+		const rootReports = roots.map((root) => {
+			const entries = unsynced.get(root) ?? [];
+			return {
+				root,
+				status: status === "ok" && entries.length > 0 ? "partial" : status,
+				unsynced: entries
+			};
+		});
+		return {
+			...emptyReport(status === "ok" && rootReports.some((root) => root.status === "partial") ? "partial" : status, errors, deps),
+			generation: previous?.generation ?? null,
+			catalogueHash,
+			webKey,
+			mcpKeys,
+			roots: rootReports,
+			commands
+		};
+	};
+	const lostBeforeInstall = lost();
+	if (lostBeforeInstall !== void 0) return lostBeforeInstall;
+	const packagesDone = progress.start(PACKAGES_LABEL, "checking configured packages for updates");
+	let packages;
+	try {
+		const configOf = (root) => (0, _agimon_ai_po_config_majorModes.loadMajorModesConfigLenient)(root, homeDirectory, environment).config;
+		const globalConfig = configOf(globalRoot);
+		const specifiers = new Set(require_index$2.catalogInstallSpecifiers(environment));
+		for (const root of roots) {
+			const config = configOf(root);
+			for (const specifier of require_index$2.runtimeLayerPackageSpecifiers(config, Object.keys(config.layers), root)) specifiers.add(specifier);
+		}
+		packages = await deps.install({
+			repoRoot: globalRoot,
+			config: globalConfig,
+			layers: Object.keys(globalConfig.layers),
+			environment,
+			refresh: options.origin === "cli",
+			specifiers: [...specifiers],
+			exactManifest: true,
+			onProgress: (message) => progress.line(PACKAGES_LABEL, message)
+		});
+	} catch (error) {
+		packagesDone("failed");
+		return report("failed", [`Installing packages failed: ${errorMessage(error)}`], null, []);
+	}
+	packagesDone(packageSummary(packages));
+	const localByRoot = new Map(roots.map((root) => [root, localPackages((0, _agimon_ai_po_config_majorModes.loadMajorModesConfigLenient)(root, homeDirectory, environment).config)]));
+	const localDirectories = [...localByRoot.values()].flat().map(({ directory }) => directory);
+	if (localDirectories.length > 0) {
+		const localDone = progress.start(LOCAL_LABEL, "building local packages");
+		const outcomes = await require_localBuilds.buildLocalPackages({
+			globalRoot,
+			environment,
+			directories: localDirectories,
+			onCommand: (command) => commands.push(command),
+			onNotice: (message) => progress.line(LOCAL_LABEL, message)
+		});
+		let failed = 0;
+		for (const [root, packagesOfRoot] of localByRoot) for (const { selector, directory } of packagesOfRoot) {
+			const outcome = outcomes.get(directory);
+			if (outcome?.status !== "failed") continue;
+			unsynced.get(root)?.push({
+				selector,
+				reason: outcome.reason,
+				...outcome.stderr === void 0 ? {} : { stderr: outcome.stderr }
+			});
+		}
+		for (const outcome of outcomes.values()) if (outcome.status === "failed") failed += 1;
+		localDone(failed === 0 ? `${pluralize(outcomes.size, "package")} ready` : `${String(failed)} failed`);
+	}
+	const composed = composeRoots(roots, homeDirectory, environment);
+	for (const [root, compositions] of composed) {
+		if (compositions instanceof Error) continue;
+		const entries = unsynced.get(root) ?? [];
+		for (const skipped of skippedSelections(compositions)) if (!entries.some((entry) => entry.selector === skipped.selector)) entries.push(skipped);
+	}
+	const webDone = progress.start(WEB_LABEL, "ensuring the global web build");
+	let rootPackageRoots = packageRootsByRoot(composed, (message) => progress.line(WEB_LABEL, message));
+	const buildWeb = (packageRoots) => deps.buildWeb({
+		poHome: globalRoot,
+		pluginRoots: webPluginRootsOf(globalRoot, packageRoots, environment),
+		environment,
+		onNotice: (message) => progress.line(WEB_LABEL, message)
+	});
+	let built = await buildWeb(rootPackageRoots);
+	if (built.status === "failed") {
+		const local = new Set(localDirectories.map(realPath));
+		const withoutLocal = new Map([...rootPackageRoots].map(([root, packageRoots]) => [root, packageRoots.filter((packageRoot) => !local.has(realPath(packageRoot)))]));
+		const leftOut = [...rootPackageRoots].some(([root, packageRoots]) => withoutLocal.get(root)?.length !== packageRoots.length);
+		const retried = leftOut ? await buildWeb(withoutLocal) : built;
+		if (retried.status === "failed") {
+			webDone("failed");
+			const retryReason = leftOut ? `; without local copies: ${retried.reason}` : "";
+			return report("failed", [`The global web build failed: ${built.reason}${retryReason}`], null, []);
+		}
+		for (const [root, packagesOfRoot] of localByRoot) {
+			const included = new Set((rootPackageRoots.get(root) ?? []).map(realPath));
+			const entries = unsynced.get(root) ?? [];
+			for (const { selector, directory } of packagesOfRoot) if (included.has(realPath(directory)) && !entries.some((entry) => entry.selector === selector)) entries.push({
+				selector,
+				reason: `left out of the web build, which failed with it: ${built.reason}`
+			});
+		}
+		progress.line(WEB_LABEL, `built without local copies after: ${built.reason}`);
+		rootPackageRoots = withoutLocal;
+		built = retried;
+	}
+	const pluginRoots = webPluginRootsOf(globalRoot, rootPackageRoots, environment);
+	const web = built.status === "skipped" ? built : {
+		status: built.status,
+		key: built.build.key
+	};
+	webDone(web.status === "skipped" ? web.reason : `${web.key} (${web.status})`);
+	const webKey = web.status === "skipped" ? null : web.key;
+	const nativeDone = progress.start(NATIVE_LABEL, "ensuring the global native build");
+	const nativeBuilt = await deps.buildNative({
+		poHome: globalRoot,
+		pluginRoots,
+		onNotice: (message) => progress.line(NATIVE_LABEL, message)
+	});
+	if (nativeBuilt.status === "failed") {
+		nativeDone("failed");
+		return report("failed", [`The global native build failed: ${nativeBuilt.reason}`], webKey, []);
+	}
+	const native = nativeBuilt.status === "skipped" ? nativeBuilt : {
+		status: nativeBuilt.status,
+		key: nativeBuilt.build.key
+	};
+	nativeDone(native.status === "skipped" ? native.reason : `${native.key} (${native.status})`);
+	const nativeKey = native.status === "skipped" ? null : native.key;
+	const mcpDone = progress.start(MCP_LABEL, "ensuring the MCP app build of each root");
+	const mcpKeys = [];
+	for (const [root, compositions] of composed) {
+		if (compositions instanceof Error) {
+			progress.line(MCP_LABEL, `'${root}' is left out of the MCP app build: ${compositions.message}`);
+			continue;
+		}
+		try {
+			const app = await deps.bundleMcpApp({
+				poHome: globalRoot,
+				candidates: require_mcpBundle.mcpPluginCandidates(compositions)
+			});
+			if (app !== void 0 && !mcpKeys.includes(app.key)) mcpKeys.push(app.key);
+		} catch (error) {
+			unsynced.get(root)?.push({
+				selector: MCP_LABEL,
+				reason: `the MCP app build failed: ${errorMessage(error)}`
+			});
+		}
+	}
+	mcpDone(mcpKeys.length === 0 ? "no MCP UI widgets" : mcpKeys.join(", "));
+	const mcpApp = mcpKeys.length === 0 ? void 0 : mcpKeys.join(", ");
+	const missing = pointerArtifacts(globalRoot, {
+		webKey,
+		nativeKey,
+		mcpKeys
+	}).filter((file) => !node_fs.default.existsSync(file));
+	if (missing.length > 0) return report("failed", [`Build artifacts are missing: ${missing.join(", ")}`], webKey, mcpKeys);
+	if (built.status !== "skipped") for (const [root, packageRoots] of rootPackageRoots) for (const [pluginId, slots] of require_index.duplicatePluginCopies(built.build, packageRoots)) unsynced.get(root)?.push({
+		selector: pluginId,
+		reason: `two copies of plugin '${pluginId}' are selected (${slots.join(", ")})`
+	});
+	const succeeded = report("ok", [], webKey, mcpKeys);
+	const generation = (previous?.generation ?? 0) + 1;
+	const pointer = {
+		generation,
+		signature: syncSignature(options, roots, catalogueHash),
+		catalogueHash,
+		webKey,
+		nativeKey,
+		mcpKeys,
+		roots: succeeded.roots,
+		commands,
+		fingerprints: Object.fromEntries(roots.map((root) => [root, rootSelectionFingerprint(root, homeDirectory, environment)])),
+		host: syncHostIdentity(globalRoot, environment)
+	};
+	const lostBeforePointer = lost();
+	if (lostBeforePointer !== void 0) return lostBeforePointer;
+	writeJsonFile(syncPointerPath(globalRoot), pointer);
+	await pruneStep(progress, deps.prune, {
+		homeDirectory,
+		environment,
+		buildsRoot: globalRoot,
+		...webKey === null ? {} : { webKey },
+		...nativeKey === null ? {} : { nativeKey },
+		...mcpKeys.length === 0 ? {} : { mcpAppKeys: mcpKeys }
+	});
+	for (const root of /* @__PURE__ */ new Set([...roots, ...options.repoRoot === void 0 ? [] : [realPath(options.repoRoot)]])) emitFrontendHooks(root, progress, commands);
+	emit({
+		type: "result",
+		result: {
+			packages,
+			web,
+			native,
+			...mcpApp === void 0 ? {} : { mcpApp }
+		}
+	});
+	return {
+		...succeeded,
+		generation
+	};
+}
+/**
+* One pass whose report lands in `last-attempt.json`, so a failed background run leaves its
+* reasons. A pass that lost the lock leaves the file to the holder that took it.
+*/
+async function attempt(options, deps, emit, lost) {
+	let report;
+	try {
+		report = await syncOnce(options, deps, emit, lost);
+	} catch (error) {
+		report = emptyReport("failed", [`po sync failed: ${errorMessage(error)}`], deps);
+	}
+	if (report.status === "busy") return report;
+	try {
+		writeJsonFile(syncLastAttemptPath(options.globalRoot), report);
+	} catch (error) {
+		report = {
+			...report,
+			errors: [...report.errors, `last-attempt.json could not be written: ${errorMessage(error)}`]
+		};
+	}
+	return report;
+}
+/**
+* Runs sync under the Po home lock and reports the outcome.
+*
+* Busy when another live sync holds the lock; a background caller leaves a rerun marker
+* first. The holder repeats its pass while a marker is present. A marker that lands after
+* its last check but before the release is caught after the release: the holder takes the
+* lock again and runs once more, or leaves the marker to whoever took the lock first.
+*/
+async function runSync(options, overrides = {}) {
+	const deps = {
+		...DEFAULT_DEPS,
+		...overrides
+	};
+	const emit = options.onEvent ?? (() => {});
+	const lockPath = syncLockPath(options.globalRoot);
+	const rerunPath = syncRerunPath(options.globalRoot);
+	let lock = acquireLock(lockPath, options.origin, deps);
+	if (!lock.acquired) {
+		if (options.origin === "background") node_fs.default.writeFileSync(rerunPath, deps.now().toISOString());
+		return emptyReport("busy", [`po sync is already running (${lock.holder === void 0 ? "another process" : `pid ${String(lock.holder.pid)}`})`], deps);
+	}
+	for (;;) {
+		const { token } = lock;
+		const lost = () => lostLock(lockPath, token, deps);
+		let report;
+		try {
+			takeRerunRequest(rerunPath);
+			report = await attempt(options, deps, emit, lost);
+			while (report.status !== "busy" && takeRerunRequest(rerunPath)) report = await attempt(options, deps, emit, lost);
+		} finally {
+			releaseLock(lockPath, token);
+		}
+		if (report.status === "busy" || !node_fs.default.existsSync(rerunPath)) return report;
+		lock = acquireLock(lockPath, options.origin, deps);
+		if (!lock.acquired) return report;
+	}
+}
+//#endregion
+exports.formatSyncResult = formatSyncResult;
+exports.globalWebPluginRoots = globalWebPluginRoots;
+exports.processIsAlive = processIsAlive;
+exports.readSyncLastAttempt = readSyncLastAttempt;
+exports.readSyncPointer = readSyncPointer;
+exports.rootSelectionFingerprint = rootSelectionFingerprint;
+exports.runSync = runSync;
+exports.syncExitCode = syncExitCode;
+exports.syncHostIdentity = syncHostIdentity;
+exports.syncLastAttemptPath = syncLastAttemptPath;
+exports.syncLockPath = syncLockPath;
+exports.syncPointerPath = syncPointerPath;
+exports.syncRerunPath = syncRerunPath;
+
+//# sourceMappingURL=index.cjs.map