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

package/dist/builders/cli/composition.d.mts

@@ -0,0 +1,119 @@
+import { SyncState } from "../../composition/syncState/index.mjs";
+import { HarnessState } from "../../composition/harnessState/index.mjs";
+import { findSyncedRoot } from "./bootstrapLocator/index.mjs";
+import { COMPOSED_ENV, EXTERNAL_EXTENSIONS_ENV, MUTE_ENV } from "./compositionState.mjs";
+import { MajorModesConfig } from "@agimon-ai/doompi-config/majorModes";
+import { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { alreadyComposed as alreadyComposed$1 } from "@agimon-ai/doompi-core/child-process";
+//#region src/builders/cli/composition.d.ts
+export declare const DOOM_FLAGS: {
+  readonly majorMode: 'major-mode';
+  readonly domains: 'domains';
+  readonly profile: 'profile';
+  readonly mute: 'mute';
+};
+/** Removed flag, reported rather than ignored when a synced session passes it. */
+export declare const REMOVED_LAYER_FLAG = "layer";
+export interface StartupFlags {
+  majorMode?: string;
+  domains?: string[];
+  profile?: string;
+  mute: boolean;
+  /** True when the caller passed the removed `--layer` flag. */
+  removedLayer: boolean;
+}
+export interface ComposeOutcome {
+  /** Everything that went wrong, reported once the session can show messages. */
+  problems: string[];
+  /** Config changed since the last sync, which is a prompt to re-sync. */
+  stale: boolean;
+  loaded: string[];
+}
+/**
+ * True when this process was handed the doom extension set on the command line.
+ *
+ * The launcher and detached Doom Team children both pass the composed list as
+ * `--extension` arguments, and Pi merges those with whatever project settings
+ * declare. Composing again here would load every extension twice, which Pi
+ * reports as each tool and flag conflicting with itself.
+ *
+ * Matching against the synced paths rather than the mere presence of
+ * `--extension` keeps an unrelated one-off, `pi -e ./debug.ts`, from silently
+ * costing the user their whole setup.
+ */
+export declare function extensionsProvidedExternally(argv: string[], resolved: Record<string, string>): boolean;
+/**
+ * Opens this process's session from what sync pinned.
+ *
+ * The synced record is decoded underneath the live environment, so an inherited
+ * value still wins: a launcher run, a nested session, or a CI override is more
+ * specific than anything sync wrote. The result becomes the session's state
+ * file, which is the authority from here on; the environment it publishes is
+ * for the bash hooks and the packages that can only read one.
+ */
+export declare function startSyncedSession(state: SyncState, repoRoot: string, environment?: NodeJS.ProcessEnv): Promise<HarnessState>;
+/**
+ * Reads the doom flags off the command line.
+ *
+ * Pi collects unrecognized flags for extensions but hands their values back
+ * only after every extension has loaded, which is too late to decide what to
+ * load. Parsing argv with Pi's own parser keeps the value rules identical.
+ */
+export declare function readStartupFlags(argv: string[]): StartupFlags;
+/** Registers the flags so Pi accepts them and lists them in `pi --help`. */
+export declare function registerDoomFlags(pi: Pick<ExtensionAPI, 'registerFlag'>): void;
+/**
+ * Applies the startup flags through the same switchers the slash commands use.
+ *
+ * A bad value is collected rather than thrown: a factory that throws takes the
+ * whole doom setup down with it, which is far worse than one unapplied flag.
+ */
+export declare function applyStartupFlags(flags: StartupFlags, majorModesConfig: MajorModesConfig, repoRoot: string, problems: string[]): Promise<void>;
+/**
+ * Points harness state at a per-process directory before anything writes there.
+ *
+ * The synced directory is a baseline that every session reads; live switches
+ * materialize into this one instead, so a second session in the same repository
+ * cannot overwrite what the first is using.
+ */
+export declare function prepareRunDirectory(repoRoot: string, environment?: NodeJS.ProcessEnv): Promise<string>;
+/** Removes this session's scratch directory. */
+export declare function cleanupRunDirectory(repoRoot: string, environment?: NodeJS.ProcessEnv): Promise<void>;
+/**
+ * Builds the ordered list of extensions to load for the current state.
+ *
+ * Returns entries in actual Pi factory activation order. CLI argument adaptation
+ * remains a launcher concern and synchronized bundles preserve this same order.
+ */
+export interface ComposedRuntimeLoadPlan {
+  readonly entries: string[];
+  readonly fingerprint: string;
+}
+/** Builds the canonical synchronized activation plan. */
+export declare function composeRuntimeLoadPlan(state: SyncState, harness?: HarnessState, environment?: NodeJS.ProcessEnv): Promise<ComposedRuntimeLoadPlan>;
+/** Compatibility view for callers that only need Pi extension entries. */
+export declare function composeLoadOrder(state: SyncState, harness?: HarnessState, environment?: NodeJS.ProcessEnv): Promise<string[]>;
+/**
+ * Imports each extension and hands it a source-aware view of the Pi API.
+ *
+ * Every Pi extension entry is a factory of the same shape, so one extension can
+ * activate the rest. The view delegates to the same host API while retaining the
+ * entry path for tools registered through a composed loader. Failures are per
+ * entry: one unloadable module must not cost the session everything after it.
+ */
+export declare function loadComposedExtensions(pi: ExtensionAPI, entries: string[], problems: string[]): Promise<string[]>;
+export interface ComposeOptions {
+  cwd?: string;
+  argv?: string[];
+  environment?: NodeJS.ProcessEnv;
+}
+/**
+ * Runs the whole synced startup for one Pi session.
+ *
+ * Never throws: whatever fails is reported through the outcome so the session
+ * still starts and can say what is wrong.
+ */
+export declare function composeDoomSession(pi: ExtensionAPI, options?: ComposeOptions): Promise<ComposeOutcome>;
+//#endregion
+export { COMPOSED_ENV, EXTERNAL_EXTENSIONS_ENV, MUTE_ENV, alreadyComposed$1 as alreadyComposed, findSyncedRoot };
+//# sourceMappingURL=composition.d.mts.map

package/dist/builders/cli/composition.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composition.d.mts","names":[],"sources":["../../../src/builders/cli/composition.ts"],"mappings":";;;;;;;;qBAwDa;WACX;WACA;WACA;WACA;;;qBAIW;iBAEI;EACf;EACA;EACA;EACA;;EAEA;;iBAGe;;EAEf;;EAEA;EACA;;;;;;;;;;;;;;wBA2Bc,6BAA6B,gBAAgB,UAAU;;;;;;;;;;wBAgBjD,mBACpB,OAAO,WACP,kBACA,cAAa,OAAO,aACnB,QAAQ;;;;;;;;wBA+BK,iBAAiB,iBAAiB;;wBAoBlC,kBAAkB,IAAI,KAAK;;;;;;;wBAgBrB,kBACpB,OAAO,cACP,kBAAkB,kBAClB,kBACA,qBACC;;;;;;;;wBAyCmB,oBACpB,kBACA,cAAa,OAAO,aACnB;;wBAWmB,oBACpB,kBACA,cAAa,OAAO,aACnB;;;;;;;iBAac;WACN;WACA;;;wBAIW,uBACpB,OAAO,WACP,UAAS,cACT,cAAa,OAAO,aACnB,QAAQ;;wBA2CW,iBACpB,OAAO,WACP,UAAS,cACT,cAAa,OAAO,aACnB;;;;;;;;;wBAYmB,uBACpB,IAAI,cACJ,mBACA,qBACC;iBAkCc;EACf;EACA;EACA,cAAc,OAAO;;;;;;;;wBASD,mBAAmB,IAAI,cAAc,UAAS,iBAAsB,QAAQ"}

package/dist/builders/cli/composition.mjs

@@ -0,0 +1,351 @@
+import { createHarnessSession, getHarnessState, loadHarnessState, readHarnessState, updateHarnessState } from "../../composition/harnessState/index.mjs";
+import { PERSONA_ENTRY, packageAttribution, resolveExtensionComposition } from "./extensionAssembler/index.mjs";
+import { computeInputsHash, createMapResolvers, readSyncState, runDirectory } from "../../composition/syncState/index.mjs";
+import { findSyncedRoot, readBundleStatus } from "./bootstrapLocator/index.mjs";
+import { configurePreset } from "./harnessContext.mjs";
+import { COMPOSED_ENV, EXTERNAL_EXTENSIONS_ENV, MUTE_ENV } from "./compositionState.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { withExtensionSource } from "@agimon-ai/doompi-ui/extensionName";
+import os from "node:os";
+import { loadMajorModesConfig } from "@agimon-ai/doompi-config/majorModes";
+import { parseArgs } from "@earendil-works/pi-coding-agent";
+import { alreadyComposed, alreadyComposed as alreadyComposed$1 } from "@agimon-ai/doompi-core/child-process";
+//#region src/builders/cli/composition.ts
+/**
+* The runtime half of `doom-pi sync`.
+*
+* Pi's own config carries a single entry, the doom-pi extension, and this is
+* what that entry runs: hydrate the harness environment, apply the startup
+* flags, then load the extension set the matrix selects. It runs again on every
+* `/reload`, which is what lets `/mode` swap the set without a restart,
+* since Pi rebuilds its extension runner from whatever a reload produced.
+*/
+const ENABLED_FLAG = "1";
+const SUBAGENT_AGENT_DIRS_ENV = "PI_SUBAGENT_EXTRA_AGENT_DIRS";
+const SUBAGENT_SKILL_DIRS_ENV = "PI_SUBAGENT_EXTRA_SKILL_DIRS";
+const DOMAIN_SEPARATOR = ",";
+const PRIVATE_DIRECTORY_MODE = 448;
+const DOMAIN_APPLY_MODULE = "@agimon-ai/doompi-domain/apply";
+const SELECTION_SWITCH_MODULE = "@agimon-ai/doompi-config/selectionSwitch";
+const NOT_SYNCED = "doompi is configured for Pi but this repository was never synced. Run doompi sync.";
+const UNUSABLE_STATE_MESSAGE = "doompi could not read its synchronized state. Run doompi sync.";
+const TIMING_ENABLED = process.env.DOOMPI_TIMING === ENABLED_FLAG || process.env.PI_TIMING === ENABLED_FLAG;
+const DOOM_FLAGS = {
+	majorMode: "major-mode",
+	domains: "domains",
+	profile: "profile",
+	mute: "mute"
+};
+/** Removed flag, reported rather than ignored when a synced session passes it. */
+const REMOVED_LAYER_FLAG = "layer";
+function message(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function realPath(target) {
+	try {
+		return fs.realpathSync(target);
+	} catch {
+		return path.resolve(target);
+	}
+}
+/**
+* True when this process was handed the doom extension set on the command line.
+*
+* The launcher and detached Doom Team children both pass the composed list as
+* `--extension` arguments, and Pi merges those with whatever project settings
+* declare. Composing again here would load every extension twice, which Pi
+* reports as each tool and flag conflicting with itself.
+*
+* Matching against the synced paths rather than the mere presence of
+* `--extension` keeps an unrelated one-off, `pi -e ./debug.ts`, from silently
+* costing the user their whole setup.
+*/
+function extensionsProvidedExternally(argv, resolved) {
+	const { extensions } = parseArgs(argv);
+	if (!extensions || extensions.length === 0) return false;
+	const composed = new Set(Object.values(resolved).map(realPath));
+	return extensions.some((entry) => composed.has(realPath(entry)));
+}
+/**
+* Opens this process's session from what sync pinned.
+*
+* The synced record is decoded underneath the live environment, so an inherited
+* value still wins: a launcher run, a nested session, or a CI override is more
+* specific than anything sync wrote. The result becomes the session's state
+* file, which is the authority from here on; the environment it publishes is
+* for the bash hooks and the packages that can only read one.
+*/
+async function startSyncedSession(state, repoRoot, environment = process.env) {
+	const directory = await prepareRunDirectory(repoRoot, environment);
+	const harness = {
+		...readHarnessState({
+			...state.env,
+			...environment
+		}),
+		...state.fileState,
+		mcpProjection: {
+			...state.fileState.mcpProjection,
+			stagingDirectory: directory
+		},
+		temporaryDirectory: directory
+	};
+	createHarnessSession(harness, {
+		directory,
+		environment
+	});
+	for (const [key, value] of Object.entries(harness.profileEnvironment)) if (environment[key] === void 0) environment[key] = value;
+	return harness;
+}
+/**
+* Reads the doom flags off the command line.
+*
+* Pi collects unrecognized flags for extensions but hands their values back
+* only after every extension has loaded, which is too late to decide what to
+* load. Parsing argv with Pi's own parser keeps the value rules identical.
+*/
+function readStartupFlags(argv) {
+	const { unknownFlags } = parseArgs(argv);
+	const text = (name) => {
+		const value = unknownFlags.get(name);
+		return typeof value === "string" && value.trim() ? value.trim() : void 0;
+	};
+	const domains = text(DOOM_FLAGS.domains);
+	return {
+		majorMode: text(DOOM_FLAGS.majorMode),
+		domains: domains?.split(DOMAIN_SEPARATOR).map((name) => name.trim()).filter(Boolean),
+		profile: text(DOOM_FLAGS.profile),
+		mute: unknownFlags.get(DOOM_FLAGS.mute) !== void 0,
+		removedLayer: unknownFlags.get(REMOVED_LAYER_FLAG) !== void 0
+	};
+}
+/** Registers the flags so Pi accepts them and lists them in `pi --help`. */
+function registerDoomFlags(pi) {
+	pi.registerFlag(DOOM_FLAGS.majorMode, {
+		type: "string",
+		description: "Named major mode from .doom/modes.yaml"
+	});
+	pi.registerFlag(DOOM_FLAGS.domains, {
+		type: "string",
+		description: "Comma-separated content domains"
+	});
+	pi.registerFlag(DOOM_FLAGS.profile, {
+		type: "string",
+		description: "Persona and env from .doom/profiles.yaml"
+	});
+	pi.registerFlag(DOOM_FLAGS.mute, {
+		type: "boolean",
+		description: "Disable the notification extension"
+	});
+}
+/**
+* Applies the startup flags through the same switchers the slash commands use.
+*
+* A bad value is collected rather than thrown: a factory that throws takes the
+* whole doom setup down with it, which is far worse than one unapplied flag.
+*/
+async function applyStartupFlags(flags, majorModesConfig, repoRoot, problems) {
+	if (flags.removedLayer) problems.push(`--${REMOVED_LAYER_FLAG} was replaced by --${DOOM_FLAGS.majorMode}`);
+	if (flags.majorMode) try {
+		const { applyMajorMode } = await import(SELECTION_SWITCH_MODULE);
+		applyMajorMode(majorModesConfig, flags.majorMode, getHarnessState());
+	} catch (error) {
+		problems.push(`--${DOOM_FLAGS.majorMode} ${flags.majorMode}: ${message(error)}`);
+	}
+	if (flags.domains && flags.domains.length > 0) try {
+		const { applyDomains } = await import(DOMAIN_APPLY_MODULE);
+		await applyDomains(flags.domains, getHarnessState());
+	} catch (error) {
+		problems.push(`--domains ${flags.domains.join(DOMAIN_SEPARATOR)}: ${message(error)}`);
+	}
+	if (flags.profile) try {
+		const [{ applyProfile }, { resolveProfile }] = await Promise.all([import(SELECTION_SWITCH_MODULE), import("@agimon-ai/doompi-config/profiles")]);
+		await applyProfile(resolveProfile(repoRoot, flags.profile), getHarnessState());
+	} catch (error) {
+		problems.push(`--profile ${flags.profile}: ${message(error)}`);
+	}
+}
+/**
+* Points harness state at a per-process directory before anything writes there.
+*
+* The synced directory is a baseline that every session reads; live switches
+* materialize into this one instead, so a second session in the same repository
+* cannot overwrite what the first is using.
+*/
+async function prepareRunDirectory(repoRoot, environment = process.env) {
+	const directory = runDirectory(repoRoot, process.pid, environment.HOME ?? os.homedir());
+	await fs.promises.mkdir(directory, {
+		mode: PRIVATE_DIRECTORY_MODE,
+		recursive: true
+	});
+	updateHarnessState({ temporaryDirectory: directory }, environment);
+	return directory;
+}
+/** Removes this session's scratch directory. */
+async function cleanupRunDirectory(repoRoot, environment = process.env) {
+	await fs.promises.rm(runDirectory(repoRoot, process.pid, environment.HOME ?? os.homedir()), {
+		recursive: true,
+		force: true
+	});
+}
+/** Builds the canonical synchronized activation plan. */
+async function composeRuntimeLoadPlan(state, harness = getHarnessState(), environment = process.env) {
+	const repoRoot = harness.root ?? state.root;
+	const resolvers = createMapResolvers(state.resolved, state.compiled);
+	const context = {
+		agents: harness.agents,
+		autoStop: false,
+		preset: state.selection.preset,
+		personaEntry: resolvers.packageEntry(PERSONA_ENTRY),
+		majorMode: harness.majorMode,
+		layers: [...harness.layers],
+		majorModesConfig: loadMajorModesConfig(repoRoot),
+		resolvers
+	};
+	const composition = resolveExtensionComposition({
+		...context,
+		mute: environment[MUTE_ENV] === ENABLED_FLAG
+	});
+	updateHarnessState({
+		childExtensions: [...composition.childActivation],
+		compositionFingerprint: composition.fingerprint,
+		packageAttribution: packageAttribution(composition)
+	}, environment);
+	if (harness.agents) {
+		environment[SUBAGENT_AGENT_DIRS_ENV] = harness.agentDirectories.join(path.delimiter);
+		environment[SUBAGENT_SKILL_DIRS_ENV] = harness.skillDirectories.join(path.delimiter);
+	}
+	const entries = [...composition.parentActivation];
+	const bundle = state.bundles?.[composition.fingerprint];
+	return {
+		entries: bundle ? [bundle] : entries,
+		fingerprint: composition.fingerprint
+	};
+}
+/** Compatibility view for callers that only need Pi extension entries. */
+async function composeLoadOrder(state, harness = getHarnessState(), environment = process.env) {
+	return (await composeRuntimeLoadPlan(state, harness, environment)).entries;
+}
+/**
+* Imports each extension and hands it a source-aware view of the Pi API.
+*
+* Every Pi extension entry is a factory of the same shape, so one extension can
+* activate the rest. The view delegates to the same host API while retaining the
+* entry path for tools registered through a composed loader. Failures are per
+* entry: one unloadable module must not cost the session everything after it.
+*/
+async function loadComposedExtensions(pi, entries, problems) {
+	const loaded = [];
+	for (const entry of entries) {
+		const importStartedAt = performance.now();
+		let module;
+		try {
+			module = await import(pathToFileURL(entry).href);
+			if (TIMING_ENABLED) process.stderr.write(`[doompi:timing] import ${(performance.now() - importStartedAt).toFixed(1)}ms ${entry}\n`);
+		} catch (error) {
+			problems.push(`${entry}: ${message(error)}`);
+			continue;
+		}
+		if (typeof module.default !== "function") {
+			problems.push(`${entry}: does not export an extension factory`);
+			continue;
+		}
+		const factoryStartedAt = performance.now();
+		try {
+			await module.default(withExtensionSource(pi, entry));
+			if (TIMING_ENABLED) process.stderr.write(`[doompi:timing] factory ${(performance.now() - factoryStartedAt).toFixed(1)}ms ${entry}\n`);
+			loaded.push(entry);
+		} catch (error) {
+			problems.push(`${entry}: ${message(error)}`);
+		}
+	}
+	return loaded;
+}
+/**
+* Runs the whole synced startup for one Pi session.
+*
+* Never throws: whatever fails is reported through the outcome so the session
+* still starts and can say what is wrong.
+*/
+async function composeDoomSession(pi, options = {}) {
+	const environment = options.environment ?? process.env;
+	const problems = [];
+	const homeDirectory = environment.HOME ?? os.homedir();
+	const repoRoot = findSyncedRoot(options.cwd ?? process.cwd(), homeDirectory);
+	if (!repoRoot) return {
+		problems: [NOT_SYNCED],
+		stale: false,
+		loaded: []
+	};
+	let state;
+	try {
+		state = readSyncState(repoRoot, homeDirectory);
+	} catch (error) {
+		return {
+			problems: [message(error)],
+			stale: false,
+			loaded: []
+		};
+	}
+	if (!state) return {
+		problems: [NOT_SYNCED],
+		stale: false,
+		loaded: []
+	};
+	const argv = options.argv ?? process.argv.slice(2);
+	if (environment[EXTERNAL_EXTENSIONS_ENV] === ENABLED_FLAG || extensionsProvidedExternally(argv, {
+		...state.resolved,
+		...state.bundles
+	})) return {
+		problems: [],
+		stale: false,
+		loaded: []
+	};
+	configurePreset({
+		preset: state.selection.preset,
+		piArgs: []
+	}, environment);
+	if (!alreadyComposed(environment)) {
+		environment[COMPOSED_ENV] = ENABLED_FLAG;
+		await startSyncedSession(state, repoRoot, environment);
+		const flags = readStartupFlags(argv);
+		if (flags.mute) environment[MUTE_ENV] = ENABLED_FLAG;
+		await applyStartupFlags(flags, loadMajorModesConfig(repoRoot), repoRoot, problems);
+	}
+	let loadPlan;
+	try {
+		loadPlan = await composeRuntimeLoadPlan(state, loadHarnessState(environment).state, environment);
+	} catch (error) {
+		return {
+			problems: [...problems, message(error)],
+			stale: false,
+			loaded: []
+		};
+	}
+	const selectedBundle = state.bundles?.[loadPlan.fingerprint];
+	if (selectedBundle) try {
+		const status = readBundleStatus(repoRoot, loadPlan.fingerprint, homeDirectory);
+		if (!status.fresh || status.bundle !== selectedBundle) return {
+			problems: [...problems, UNUSABLE_STATE_MESSAGE],
+			stale: false,
+			loaded: []
+		};
+	} catch {
+		return {
+			problems: [...problems, UNUSABLE_STATE_MESSAGE],
+			stale: false,
+			loaded: []
+		};
+	}
+	const loaded = await loadComposedExtensions(pi, loadPlan.entries, problems);
+	return {
+		problems,
+		stale: computeInputsHash(repoRoot, state.selection, homeDirectory) !== state.inputsHash || loadHarnessState(environment).state.majorMode === state.selection.majorMode && loadPlan.fingerprint !== state.compositionFingerprint,
+		loaded
+	};
+}
+//#endregion
+export { COMPOSED_ENV, DOOM_FLAGS, EXTERNAL_EXTENSIONS_ENV, MUTE_ENV, REMOVED_LAYER_FLAG, alreadyComposed$1 as alreadyComposed, applyStartupFlags, cleanupRunDirectory, composeDoomSession, composeLoadOrder, composeRuntimeLoadPlan, extensionsProvidedExternally, findSyncedRoot, loadComposedExtensions, prepareRunDirectory, readStartupFlags, registerDoomFlags, startSyncedSession };
+
+//# sourceMappingURL=composition.mjs.map

package/dist/builders/cli/composition.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"composition.mjs","names":[],"sources":["../../../src/builders/cli/composition.ts"],"sourcesContent":["import fs from 'node:fs';\nimport os from 'node:os';\nimport path from 'node:path';\nimport { pathToFileURL } from 'node:url';\n\nimport { loadMajorModesConfig, type MajorModesConfig } from '@agimon-ai/doompi-config/majorModes';\nimport { alreadyComposed } from '@agimon-ai/doompi-core/child-process';\nimport { withExtensionSource } from '@agimon-ai/doompi-ui/extensionName';\nimport { type ExtensionAPI, parseArgs } from '@earendil-works/pi-coding-agent';\n\nimport {\n  createHarnessSession,\n  getHarnessState,\n  type HarnessState,\n  loadHarnessState,\n  readHarnessState,\n  updateHarnessState,\n} from '../../composition/harnessState';\nimport {\n  computeInputsHash,\n  createMapResolvers,\n  readSyncState,\n  runDirectory,\n  type SyncState,\n} from '../../composition/syncState';\nimport type { HarnessPreset } from '../../composition/types/harness';\nimport { findSyncedRoot, readBundleStatus } from './bootstrapLocator';\nimport { COMPOSED_ENV, EXTERNAL_EXTENSIONS_ENV, MUTE_ENV } from './compositionState';\nimport { PERSONA_ENTRY, packageAttribution, resolveExtensionComposition } from './extensionAssembler';\nimport { configurePreset } from './harnessContext';\n\nexport { findSyncedRoot } from './bootstrapLocator';\nexport { alreadyComposed } from '@agimon-ai/doompi-core/child-process';\nexport { COMPOSED_ENV, EXTERNAL_EXTENSIONS_ENV, MUTE_ENV } from './compositionState';\n\n/**\n * The runtime half of `doom-pi sync`.\n *\n * Pi's own config carries a single entry, the doom-pi extension, and this is\n * what that entry runs: hydrate the harness environment, apply the startup\n * flags, then load the extension set the matrix selects. It runs again on every\n * `/reload`, which is what lets `/mode` swap the set without a restart,\n * since Pi rebuilds its extension runner from whatever a reload produced.\n */\n\nconst ENABLED_FLAG = '1';\nconst SUBAGENT_AGENT_DIRS_ENV = 'PI_SUBAGENT_EXTRA_AGENT_DIRS';\nconst SUBAGENT_SKILL_DIRS_ENV = 'PI_SUBAGENT_EXTRA_SKILL_DIRS';\nconst DOMAIN_SEPARATOR = ',';\nconst PRIVATE_DIRECTORY_MODE = 0o700;\nconst DOMAIN_APPLY_MODULE = '@agimon-ai/doompi-domain/apply';\nconst SELECTION_SWITCH_MODULE = '@agimon-ai/doompi-config/selectionSwitch';\nconst NOT_SYNCED = 'doompi is configured for Pi but this repository was never synced. Run doompi sync.';\nconst UNUSABLE_STATE_MESSAGE = 'doompi could not read its synchronized state. Run doompi sync.';\nconst TIMING_ENABLED = process.env.DOOMPI_TIMING === ENABLED_FLAG || process.env.PI_TIMING === ENABLED_FLAG;\n\nexport const DOOM_FLAGS = {\n  majorMode: 'major-mode',\n  domains: 'domains',\n  profile: 'profile',\n  mute: 'mute',\n} as const;\n\n/** Removed flag, reported rather than ignored when a synced session passes it. */\nexport const REMOVED_LAYER_FLAG = 'layer';\n\nexport interface StartupFlags {\n  majorMode?: string;\n  domains?: string[];\n  profile?: string;\n  mute: boolean;\n  /** True when the caller passed the removed `--layer` flag. */\n  removedLayer: boolean;\n}\n\nexport interface ComposeOutcome {\n  /** Everything that went wrong, reported once the session can show messages. */\n  problems: string[];\n  /** Config changed since the last sync, which is a prompt to re-sync. */\n  stale: boolean;\n  loaded: string[];\n}\n\nfunction message(error: unknown): string {\n  return error instanceof Error ? error.message : String(error);\n}\n\nfunction realPath(target: string): string {\n  try {\n    return fs.realpathSync(target);\n  } catch {\n    return path.resolve(target);\n  }\n}\n\n/**\n * True when this process was handed the doom extension set on the command line.\n *\n * The launcher and detached Doom Team children both pass the composed list as\n * `--extension` arguments, and Pi merges those with whatever project settings\n * declare. Composing again here would load every extension twice, which Pi\n * reports as each tool and flag conflicting with itself.\n *\n * Matching against the synced paths rather than the mere presence of\n * `--extension` keeps an unrelated one-off, `pi -e ./debug.ts`, from silently\n * costing the user their whole setup.\n */\nexport function extensionsProvidedExternally(argv: string[], resolved: Record<string, string>): boolean {\n  const { extensions } = parseArgs(argv);\n  if (!extensions || extensions.length === 0) return false;\n  const composed = new Set(Object.values(resolved).map(realPath));\n  return extensions.some((entry) => composed.has(realPath(entry)));\n}\n\n/**\n * Opens this process's session from what sync pinned.\n *\n * The synced record is decoded underneath the live environment, so an inherited\n * value still wins: a launcher run, a nested session, or a CI override is more\n * specific than anything sync wrote. The result becomes the session's state\n * file, which is the authority from here on; the environment it publishes is\n * for the bash hooks and the packages that can only read one.\n */\nexport async function startSyncedSession(\n  state: SyncState,\n  repoRoot: string,\n  environment: NodeJS.ProcessEnv = process.env,\n): Promise<HarnessState> {\n  const directory = await prepareRunDirectory(repoRoot, environment);\n  const harness: HarnessState = {\n    ...readHarnessState({ ...state.env, ...environment }),\n    // Recorded separately because no variable carries them.\n    ...state.fileState,\n    // Every synced process gets private mutable staging. The source content\n    // identity is unchanged because the projection fingerprint excludes it.\n    mcpProjection: {\n      ...state.fileState.mcpProjection,\n      stagingDirectory: directory,\n    },\n    temporaryDirectory: directory,\n  };\n  createHarnessSession(harness, { directory, environment });\n  // The profile's own defaults, which the launcher applies at spawn. They are\n  // recorded as a map rather than as variables so /profile can tell which ones\n  // it owns when it swaps them out later.\n  for (const [key, value] of Object.entries(harness.profileEnvironment)) {\n    if (environment[key] === undefined) environment[key] = value;\n  }\n  return harness;\n}\n\n/**\n * Reads the doom flags off the command line.\n *\n * Pi collects unrecognized flags for extensions but hands their values back\n * only after every extension has loaded, which is too late to decide what to\n * load. Parsing argv with Pi's own parser keeps the value rules identical.\n */\nexport function readStartupFlags(argv: string[]): StartupFlags {\n  const { unknownFlags } = parseArgs(argv);\n  const text = (name: string): string | undefined => {\n    const value = unknownFlags.get(name);\n    return typeof value === 'string' && value.trim() ? value.trim() : undefined;\n  };\n  const domains = text(DOOM_FLAGS.domains);\n  return {\n    majorMode: text(DOOM_FLAGS.majorMode),\n    domains: domains\n      ?.split(DOMAIN_SEPARATOR)\n      .map((name) => name.trim())\n      .filter(Boolean),\n    profile: text(DOOM_FLAGS.profile),\n    mute: unknownFlags.get(DOOM_FLAGS.mute) !== undefined,\n    removedLayer: unknownFlags.get(REMOVED_LAYER_FLAG) !== undefined,\n  };\n}\n\n/** Registers the flags so Pi accepts them and lists them in `pi --help`. */\nexport function registerDoomFlags(pi: Pick<ExtensionAPI, 'registerFlag'>): void {\n  pi.registerFlag(DOOM_FLAGS.majorMode, {\n    type: 'string',\n    description: 'Named major mode from .doom/modes.yaml',\n  });\n  pi.registerFlag(DOOM_FLAGS.domains, { type: 'string', description: 'Comma-separated content domains' });\n  pi.registerFlag(DOOM_FLAGS.profile, { type: 'string', description: 'Persona and env from .doom/profiles.yaml' });\n  pi.registerFlag(DOOM_FLAGS.mute, { type: 'boolean', description: 'Disable the notification extension' });\n}\n\n/**\n * Applies the startup flags through the same switchers the slash commands use.\n *\n * A bad value is collected rather than thrown: a factory that throws takes the\n * whole doom setup down with it, which is far worse than one unapplied flag.\n */\nexport async function applyStartupFlags(\n  flags: StartupFlags,\n  majorModesConfig: MajorModesConfig,\n  repoRoot: string,\n  problems: string[],\n): Promise<void> {\n  // Reported rather than ignored: Pi hands unrecognized flags to extensions, so\n  // a stale `--layer dev` would otherwise start a session on the wrong mode\n  // without saying anything.\n  if (flags.removedLayer) problems.push(`--${REMOVED_LAYER_FLAG} was replaced by --${DOOM_FLAGS.majorMode}`);\n  if (flags.majorMode) {\n    try {\n      const { applyMajorMode } = await import(SELECTION_SWITCH_MODULE);\n      applyMajorMode(majorModesConfig, flags.majorMode, getHarnessState());\n    } catch (error) {\n      problems.push(`--${DOOM_FLAGS.majorMode} ${flags.majorMode}: ${message(error)}`);\n    }\n  }\n  if (flags.domains && flags.domains.length > 0) {\n    try {\n      const { applyDomains } = await import(DOMAIN_APPLY_MODULE);\n      await applyDomains(flags.domains, getHarnessState());\n    } catch (error) {\n      problems.push(`--domains ${flags.domains.join(DOMAIN_SEPARATOR)}: ${message(error)}`);\n    }\n  }\n  if (flags.profile) {\n    try {\n      const [{ applyProfile }, { resolveProfile }] = await Promise.all([\n        import(SELECTION_SWITCH_MODULE),\n        import('@agimon-ai/doompi-config/profiles'),\n      ]);\n      await applyProfile(resolveProfile(repoRoot, flags.profile), getHarnessState());\n    } catch (error) {\n      problems.push(`--profile ${flags.profile}: ${message(error)}`);\n    }\n  }\n}\n\n/**\n * Points harness state at a per-process directory before anything writes there.\n *\n * The synced directory is a baseline that every session reads; live switches\n * materialize into this one instead, so a second session in the same repository\n * cannot overwrite what the first is using.\n */\nexport async function prepareRunDirectory(\n  repoRoot: string,\n  environment: NodeJS.ProcessEnv = process.env,\n): Promise<string> {\n  const directory = runDirectory(repoRoot, process.pid, environment.HOME ?? os.homedir());\n  await fs.promises.mkdir(directory, { mode: PRIVATE_DIRECTORY_MODE, recursive: true });\n  // Through the store rather than the environment: the state file is the\n  // authority, and a switcher reading a stale directory would write a live\n  // session's resources into the wrong place.\n  updateHarnessState({ temporaryDirectory: directory }, environment);\n  return directory;\n}\n\n/** Removes this session's scratch directory. */\nexport async function cleanupRunDirectory(\n  repoRoot: string,\n  environment: NodeJS.ProcessEnv = process.env,\n): Promise<void> {\n  await fs.promises.rm(runDirectory(repoRoot, process.pid, environment.HOME ?? os.homedir()), {\n    recursive: true,\n    force: true,\n  });\n}\n\n/**\n * Builds the ordered list of extensions to load for the current state.\n *\n * Returns entries in actual Pi factory activation order. CLI argument adaptation\n * remains a launcher concern and synchronized bundles preserve this same order.\n */\nexport interface ComposedRuntimeLoadPlan {\n  readonly entries: string[];\n  readonly fingerprint: string;\n}\n\n/** Builds the canonical synchronized activation plan. */\nexport async function composeRuntimeLoadPlan(\n  state: SyncState,\n  harness: HarnessState = getHarnessState(),\n  environment: NodeJS.ProcessEnv = process.env,\n): Promise<ComposedRuntimeLoadPlan> {\n  const repoRoot = harness.root ?? state.root;\n  const resolvers = createMapResolvers(state.resolved, state.compiled);\n  const context = {\n    agents: harness.agents,\n    // Exiting when the agent settles is a launcher decision with no synced\n    // equivalent: a session started by hand is meant to stay open.\n    autoStop: false,\n    preset: state.selection.preset,\n    personaEntry: resolvers.packageEntry(PERSONA_ENTRY),\n    majorMode: harness.majorMode,\n    layers: [...harness.layers],\n    majorModesConfig: loadMajorModesConfig(repoRoot),\n    resolvers,\n  };\n\n  // A state field, so it goes through the store: Doom Team reads it from the\n  // environment the store publishes when it builds a child's spawn snapshot.\n  const composition = resolveExtensionComposition({\n    ...context,\n    mute: environment[MUTE_ENV] === ENABLED_FLAG,\n  });\n  updateHarnessState(\n    {\n      childExtensions: [...composition.childActivation],\n      compositionFingerprint: composition.fingerprint,\n      packageAttribution: packageAttribution(composition),\n    },\n    environment,\n  );\n  if (harness.agents) {\n    environment[SUBAGENT_AGENT_DIRS_ENV] = harness.agentDirectories.join(path.delimiter);\n    environment[SUBAGENT_SKILL_DIRS_ENV] = harness.skillDirectories.join(path.delimiter);\n  }\n  const entries = [...composition.parentActivation];\n  const bundle = state.bundles?.[composition.fingerprint];\n  return {\n    entries: bundle ? [bundle] : entries,\n    fingerprint: composition.fingerprint,\n  };\n}\n\n/** Compatibility view for callers that only need Pi extension entries. */\nexport async function composeLoadOrder(\n  state: SyncState,\n  harness: HarnessState = getHarnessState(),\n  environment: NodeJS.ProcessEnv = process.env,\n): Promise<string[]> {\n  return (await composeRuntimeLoadPlan(state, harness, environment)).entries;\n}\n\n/**\n * Imports each extension and hands it a source-aware view of the Pi API.\n *\n * Every Pi extension entry is a factory of the same shape, so one extension can\n * activate the rest. The view delegates to the same host API while retaining the\n * entry path for tools registered through a composed loader. Failures are per\n * entry: one unloadable module must not cost the session everything after it.\n */\nexport async function loadComposedExtensions(\n  pi: ExtensionAPI,\n  entries: string[],\n  problems: string[],\n): Promise<string[]> {\n  const loaded: string[] = [];\n  for (const entry of entries) {\n    const importStartedAt = performance.now();\n    let module: { default?: unknown };\n    try {\n      module = (await import(pathToFileURL(entry).href)) as { default?: unknown };\n      if (TIMING_ENABLED) {\n        process.stderr.write(`[doompi:timing] import ${(performance.now() - importStartedAt).toFixed(1)}ms ${entry}\\n`);\n      }\n    } catch (error) {\n      problems.push(`${entry}: ${message(error)}`);\n      continue;\n    }\n    if (typeof module.default !== 'function') {\n      problems.push(`${entry}: does not export an extension factory`);\n      continue;\n    }\n    const factoryStartedAt = performance.now();\n    try {\n      await (module.default as (api: ExtensionAPI) => void | Promise<void>)(withExtensionSource(pi, entry));\n      if (TIMING_ENABLED) {\n        process.stderr.write(\n          `[doompi:timing] factory ${(performance.now() - factoryStartedAt).toFixed(1)}ms ${entry}\\n`,\n        );\n      }\n      loaded.push(entry);\n    } catch (error) {\n      problems.push(`${entry}: ${message(error)}`);\n    }\n  }\n  return loaded;\n}\n\nexport interface ComposeOptions {\n  cwd?: string;\n  argv?: string[];\n  environment?: NodeJS.ProcessEnv;\n}\n\n/**\n * Runs the whole synced startup for one Pi session.\n *\n * Never throws: whatever fails is reported through the outcome so the session\n * still starts and can say what is wrong.\n */\nexport async function composeDoomSession(pi: ExtensionAPI, options: ComposeOptions = {}): Promise<ComposeOutcome> {\n  const environment = options.environment ?? process.env;\n  const problems: string[] = [];\n  const homeDirectory = environment.HOME ?? os.homedir();\n  const repoRoot = findSyncedRoot(options.cwd ?? process.cwd(), homeDirectory);\n  if (!repoRoot) return { problems: [NOT_SYNCED], stale: false, loaded: [] };\n\n  let state: SyncState | undefined;\n  try {\n    state = readSyncState(repoRoot, homeDirectory);\n  } catch (error) {\n    return { problems: [message(error)], stale: false, loaded: [] };\n  }\n  if (!state) return { problems: [NOT_SYNCED], stale: false, loaded: [] };\n\n  const argv = options.argv ?? process.argv.slice(2);\n  // The launcher and Doom Team children compose the set themselves and pass it\n  // in, so this entry has nothing left to do but stay out of the way.\n  if (\n    environment[EXTERNAL_EXTENSIONS_ENV] === ENABLED_FLAG ||\n    extensionsProvidedExternally(argv, { ...state.resolved, ...state.bundles })\n  ) {\n    return { problems: [], stale: false, loaded: [] };\n  }\n\n  configurePreset({ preset: state.selection.preset as HarnessPreset, piArgs: [] }, environment);\n\n  // Only the first load opens a session. A reload finds the pointer this set\n  // and reads the file back, which is what carries a live /domains or /profile\n  // switch across the reload instead of resetting it to what sync pinned.\n  if (!alreadyComposed(environment)) {\n    environment[COMPOSED_ENV] = ENABLED_FLAG;\n    await startSyncedSession(state, repoRoot, environment);\n    const flags = readStartupFlags(argv);\n    if (flags.mute) environment[MUTE_ENV] = ENABLED_FLAG;\n    await applyStartupFlags(flags, loadMajorModesConfig(repoRoot), repoRoot, problems);\n  }\n\n  let loadPlan: ComposedRuntimeLoadPlan;\n  try {\n    // Read back through the store rather than from this process: the startup\n    // flags may have switched the layer or the domains a moment ago, and the\n    // environment being managed is not always this process's own.\n    loadPlan = await composeRuntimeLoadPlan(state, loadHarnessState(environment).state, environment);\n  } catch (error) {\n    return { problems: [...problems, message(error)], stale: false, loaded: [] };\n  }\n\n  const selectedBundle = state.bundles?.[loadPlan.fingerprint];\n  if (selectedBundle) {\n    try {\n      const status = readBundleStatus(repoRoot, loadPlan.fingerprint, homeDirectory);\n      if (!status.fresh || status.bundle !== selectedBundle) {\n        return { problems: [...problems, UNUSABLE_STATE_MESSAGE], stale: false, loaded: [] };\n      }\n    } catch {\n      return { problems: [...problems, UNUSABLE_STATE_MESSAGE], stale: false, loaded: [] };\n    }\n  }\n\n  const loaded = await loadComposedExtensions(pi, loadPlan.entries, problems);\n  return {\n    problems,\n    stale:\n      computeInputsHash(repoRoot, state.selection, homeDirectory) !== state.inputsHash ||\n      (loadHarnessState(environment).state.majorMode === state.selection.majorMode &&\n        loadPlan.fingerprint !== state.compositionFingerprint),\n    loaded,\n  };\n}\n"],"mappings":"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"}

package/dist/builders/cli/compositionState.cjs

@@ -0,0 +1,33 @@
+let _agimon_ai_doompi_core_child_process = require("@agimon-ai/doompi-core/child-process");
+//#region src/builders/cli/compositionState.ts
+/** Marks a process whose extensions this module composed. */
+const COMPOSED_ENV = _agimon_ai_doompi_core_child_process.DOOMPI_COMPOSED_ENV;
+/** Set by the launcher when it passes one precomposed aggregate to Pi. */
+const EXTERNAL_EXTENSIONS_ENV = _agimon_ai_doompi_core_child_process.DOOMPI_EXTENSIONS_PROVIDED_ENV;
+/** Survives reload, where argv is re-read but the startup flags must not be. */
+const MUTE_ENV = "DOOMPI_MUTE";
+const COMPOSITION_CLAIM_KEY = Symbol.for("@agimon-ai/doompi:composition-claim");
+/**
+* Owns composition until Pi starts the freshly loaded extension runner.
+*
+* Pi resolves project resources before user resources, so the first DoomPi
+* factory is the repository-local one when both scopes register the package.
+* A process-global symbol survives distinct installed module URLs and lets that
+* first factory own the load cycle. Releasing on `session_start` leaves a later
+* `/reload` free to compose a new runner.
+*/
+function acquireCompositionClaim() {
+	if (Reflect.get(globalThis, COMPOSITION_CLAIM_KEY) !== void 0) return void 0;
+	const claim = Symbol("doompi-composition");
+	Reflect.set(globalThis, COMPOSITION_CLAIM_KEY, claim);
+	return () => {
+		if (Reflect.get(globalThis, COMPOSITION_CLAIM_KEY) === claim) Reflect.deleteProperty(globalThis, COMPOSITION_CLAIM_KEY);
+	};
+}
+//#endregion
+exports.COMPOSED_ENV = COMPOSED_ENV;
+exports.EXTERNAL_EXTENSIONS_ENV = EXTERNAL_EXTENSIONS_ENV;
+exports.MUTE_ENV = MUTE_ENV;
+exports.acquireCompositionClaim = acquireCompositionClaim;
+
+//# sourceMappingURL=compositionState.cjs.map

package/dist/builders/cli/compositionState.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"compositionState.cjs","names":["DOOMPI_COMPOSED_ENV","DOOMPI_EXTENSIONS_PROVIDED_ENV"],"sources":["../../../src/builders/cli/compositionState.ts"],"sourcesContent":["import { DOOMPI_COMPOSED_ENV, DOOMPI_EXTENSIONS_PROVIDED_ENV } from '@agimon-ai/doompi-core/child-process';\n\n/** Marks a process whose extensions this module composed. */\nexport const COMPOSED_ENV = DOOMPI_COMPOSED_ENV;\n/** Set by the launcher when it passes one precomposed aggregate to Pi. */\nexport const EXTERNAL_EXTENSIONS_ENV = DOOMPI_EXTENSIONS_PROVIDED_ENV;\n/** Survives reload, where argv is re-read but the startup flags must not be. */\nexport const MUTE_ENV = 'DOOMPI_MUTE';\n\nconst COMPOSITION_CLAIM_KEY = Symbol.for('@agimon-ai/doompi:composition-claim');\n\nexport type ReleaseCompositionClaim = () => void;\n\n/**\n * Owns composition until Pi starts the freshly loaded extension runner.\n *\n * Pi resolves project resources before user resources, so the first DoomPi\n * factory is the repository-local one when both scopes register the package.\n * A process-global symbol survives distinct installed module URLs and lets that\n * first factory own the load cycle. Releasing on `session_start` leaves a later\n * `/reload` free to compose a new runner.\n */\nexport function acquireCompositionClaim(): ReleaseCompositionClaim | undefined {\n  if (Reflect.get(globalThis, COMPOSITION_CLAIM_KEY) !== undefined) return undefined;\n\n  const claim = Symbol('doompi-composition');\n  Reflect.set(globalThis, COMPOSITION_CLAIM_KEY, claim);\n  return () => {\n    if (Reflect.get(globalThis, COMPOSITION_CLAIM_KEY) === claim) {\n      Reflect.deleteProperty(globalThis, COMPOSITION_CLAIM_KEY);\n    }\n  };\n}\n"],"mappings":";;;AAGA,MAAa,eAAeA,qCAAAA;;AAE5B,MAAa,0BAA0BC,qCAAAA;;AAEvC,MAAa,WAAW;AAExB,MAAM,wBAAwB,OAAO,IAAI,qCAAqC;;;;;;;;;;AAa9E,SAAgB,0BAA+D;CAC7E,IAAI,QAAQ,IAAI,YAAY,qBAAqB,MAAM,KAAA,GAAW,OAAO,KAAA;CAEzE,MAAM,QAAQ,OAAO,oBAAoB;CACzC,QAAQ,IAAI,YAAY,uBAAuB,KAAK;CACpD,aAAa;EACX,IAAI,QAAQ,IAAI,YAAY,qBAAqB,MAAM,OACrD,QAAQ,eAAe,YAAY,qBAAqB;CAE5D;AACF"}

package/dist/builders/cli/compositionState.d.cts

@@ -0,0 +1,9 @@
+//#region src/builders/cli/compositionState.d.ts
+/** Marks a process whose extensions this module composed. */
+export declare const COMPOSED_ENV = "DOOMPI_COMPOSED";
+/** Set by the launcher when it passes one precomposed aggregate to Pi. */
+export declare const EXTERNAL_EXTENSIONS_ENV = "DOOMPI_EXTENSIONS_PROVIDED";
+/** Survives reload, where argv is re-read but the startup flags must not be. */
+export declare const MUTE_ENV = "DOOMPI_MUTE";
+//#endregion
+//# sourceMappingURL=compositionState.d.cts.map

package/dist/builders/cli/compositionState.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compositionState.d.cts","names":[],"sources":["../../../src/builders/cli/compositionState.ts"],"mappings":";;qBAGa;;qBAEA;;qBAEA"}

package/dist/builders/cli/compositionState.d.mts

@@ -0,0 +1,9 @@
+//#region src/builders/cli/compositionState.d.ts
+/** Marks a process whose extensions this module composed. */
+export declare const COMPOSED_ENV = "DOOMPI_COMPOSED";
+/** Set by the launcher when it passes one precomposed aggregate to Pi. */
+export declare const EXTERNAL_EXTENSIONS_ENV = "DOOMPI_EXTENSIONS_PROVIDED";
+/** Survives reload, where argv is re-read but the startup flags must not be. */
+export declare const MUTE_ENV = "DOOMPI_MUTE";
+//#endregion
+//# sourceMappingURL=compositionState.d.mts.map

package/dist/builders/cli/compositionState.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compositionState.d.mts","names":[],"sources":["../../../src/builders/cli/compositionState.ts"],"mappings":";;qBAGa;;qBAEA;;qBAEA"}

package/dist/builders/cli/compositionState.mjs

@@ -0,0 +1,30 @@
+import { DOOMPI_COMPOSED_ENV, DOOMPI_EXTENSIONS_PROVIDED_ENV } from "@agimon-ai/doompi-core/child-process";
+//#region src/builders/cli/compositionState.ts
+/** Marks a process whose extensions this module composed. */
+const COMPOSED_ENV = DOOMPI_COMPOSED_ENV;
+/** Set by the launcher when it passes one precomposed aggregate to Pi. */
+const EXTERNAL_EXTENSIONS_ENV = DOOMPI_EXTENSIONS_PROVIDED_ENV;
+/** Survives reload, where argv is re-read but the startup flags must not be. */
+const MUTE_ENV = "DOOMPI_MUTE";
+const COMPOSITION_CLAIM_KEY = Symbol.for("@agimon-ai/doompi:composition-claim");
+/**
+* Owns composition until Pi starts the freshly loaded extension runner.
+*
+* Pi resolves project resources before user resources, so the first DoomPi
+* factory is the repository-local one when both scopes register the package.
+* A process-global symbol survives distinct installed module URLs and lets that
+* first factory own the load cycle. Releasing on `session_start` leaves a later
+* `/reload` free to compose a new runner.
+*/
+function acquireCompositionClaim() {
+	if (Reflect.get(globalThis, COMPOSITION_CLAIM_KEY) !== void 0) return void 0;
+	const claim = Symbol("doompi-composition");
+	Reflect.set(globalThis, COMPOSITION_CLAIM_KEY, claim);
+	return () => {
+		if (Reflect.get(globalThis, COMPOSITION_CLAIM_KEY) === claim) Reflect.deleteProperty(globalThis, COMPOSITION_CLAIM_KEY);
+	};
+}
+//#endregion
+export { COMPOSED_ENV, EXTERNAL_EXTENSIONS_ENV, MUTE_ENV, acquireCompositionClaim };
+
+//# sourceMappingURL=compositionState.mjs.map

package/dist/builders/cli/compositionState.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"compositionState.mjs","names":[],"sources":["../../../src/builders/cli/compositionState.ts"],"sourcesContent":["import { DOOMPI_COMPOSED_ENV, DOOMPI_EXTENSIONS_PROVIDED_ENV } from '@agimon-ai/doompi-core/child-process';\n\n/** Marks a process whose extensions this module composed. */\nexport const COMPOSED_ENV = DOOMPI_COMPOSED_ENV;\n/** Set by the launcher when it passes one precomposed aggregate to Pi. */\nexport const EXTERNAL_EXTENSIONS_ENV = DOOMPI_EXTENSIONS_PROVIDED_ENV;\n/** Survives reload, where argv is re-read but the startup flags must not be. */\nexport const MUTE_ENV = 'DOOMPI_MUTE';\n\nconst COMPOSITION_CLAIM_KEY = Symbol.for('@agimon-ai/doompi:composition-claim');\n\nexport type ReleaseCompositionClaim = () => void;\n\n/**\n * Owns composition until Pi starts the freshly loaded extension runner.\n *\n * Pi resolves project resources before user resources, so the first DoomPi\n * factory is the repository-local one when both scopes register the package.\n * A process-global symbol survives distinct installed module URLs and lets that\n * first factory own the load cycle. Releasing on `session_start` leaves a later\n * `/reload` free to compose a new runner.\n */\nexport function acquireCompositionClaim(): ReleaseCompositionClaim | undefined {\n  if (Reflect.get(globalThis, COMPOSITION_CLAIM_KEY) !== undefined) return undefined;\n\n  const claim = Symbol('doompi-composition');\n  Reflect.set(globalThis, COMPOSITION_CLAIM_KEY, claim);\n  return () => {\n    if (Reflect.get(globalThis, COMPOSITION_CLAIM_KEY) === claim) {\n      Reflect.deleteProperty(globalThis, COMPOSITION_CLAIM_KEY);\n    }\n  };\n}\n"],"mappings":";;;AAGA,MAAa,eAAe;;AAE5B,MAAa,0BAA0B;;AAEvC,MAAa,WAAW;AAExB,MAAM,wBAAwB,OAAO,IAAI,qCAAqC;;;;;;;;;;AAa9E,SAAgB,0BAA+D;CAC7E,IAAI,QAAQ,IAAI,YAAY,qBAAqB,MAAM,KAAA,GAAW,OAAO,KAAA;CAEzE,MAAM,QAAQ,OAAO,oBAAoB;CACzC,QAAQ,IAAI,YAAY,uBAAuB,KAAK;CACpD,aAAa;EACX,IAAI,QAAQ,IAAI,YAAY,qBAAqB,MAAM,OACrD,QAAQ,eAAe,YAAY,qBAAqB;CAE5D;AACF"}