@agimon-ai/po-config 0.0.0-alpha.0

package/dist/config-CKA07FxG.mjs

@@ -0,0 +1,162 @@
+import { a as configLeafKeys, c as mergeDoomConfigs, p as valueAtKeyPath, s as configScopeOf, u as parseDoomConfig } from "./configPolicy--TNX7feH.mjs";
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { poHomeDirectory } from "@agimon-ai/po-core/piSettings";
+import { parse } from "yaml";
+//#region src/services/config/index.ts
+const DOOM_DIR = ".po";
+const CONFIG_FILE = "config.yaml";
+const PLANS_DIR = "plans";
+function readConfig(filePath) {
+	return fs.existsSync(filePath) ? parseDoomConfig(fs.readFileSync(filePath, "utf8"), filePath) : { projectTrust: "ask" };
+}
+async function readConfigAsync(filePath) {
+	try {
+		return parseDoomConfig(await fs.promises.readFile(filePath, "utf8"), filePath);
+	} catch (error) {
+		if (error.code === "ENOENT") return { projectTrust: "ask" };
+		throw error;
+	}
+}
+function globalDoomConfigDirectory(homeDirectory = os.homedir()) {
+	return poHomeDirectory(homeDirectory);
+}
+function globalDoomConfigPath(homeDirectory = os.homedir()) {
+	return path.join(globalDoomConfigDirectory(homeDirectory), CONFIG_FILE);
+}
+function resolvePlanningPlansDirectory(configured, repoRoot, homeDirectory = os.homedir()) {
+	if (!configured) return path.join(globalDoomConfigDirectory(homeDirectory), PLANS_DIR);
+	if (configured === "~") return homeDirectory;
+	if (configured.startsWith("~/")) return path.resolve(homeDirectory, configured.slice(2));
+	if (configured.startsWith("~")) throw new Error("Doom planning plansDirectory supports only '~' or '~/' home aliases");
+	return path.isAbsolute(configured) ? path.normalize(configured) : path.resolve(repoRoot, configured);
+}
+function repositoryDoomConfigPath(repoRoot) {
+	return path.join(repoRoot, DOOM_DIR, CONFIG_FILE);
+}
+/**
+* True when a repository's `.po` folder is Po's home itself, as it is for a
+* session rooted at home. That folder is already the global layer; reading it
+* again as the repository layer would apply global-only keys at repository scope.
+*/
+function isGlobalDoomConfigRoot(repoRoot, homeDirectory = os.homedir()) {
+	return path.resolve(repoRoot, DOOM_DIR) === path.resolve(globalDoomConfigDirectory(homeDirectory));
+}
+function repositoryConfigFor(repoRoot, homeDirectory) {
+	return isGlobalDoomConfigRoot(repoRoot, homeDirectory) ? void 0 : repositoryDoomConfigPath(repoRoot);
+}
+/** Process-local distribution defaults never grant native authority or modify user files. */
+function distributionDefaults(config, environment) {
+	if (environment.PO_DISTRIBUTION !== "desktop") return config;
+	return {
+		...config,
+		computerUse: {
+			...config.computerUse,
+			enabled: config.computerUse?.enabled ?? true
+		}
+	};
+}
+function loadDoomConfig(repoRoot, homeDirectory = os.homedir(), environment = process.env) {
+	const repositoryPath = repositoryConfigFor(repoRoot, homeDirectory);
+	return distributionDefaults(mergeDoomConfigs(readConfig(globalDoomConfigPath(homeDirectory)), repositoryPath === void 0 ? { projectTrust: "ask" } : readConfig(repositoryPath)), environment);
+}
+/**
+* Loads the merged config, tolerating unknown keys in either file.
+*
+* Only `po sync` uses this. Everything that runs during a session keeps
+* `loadDoomConfig`, because a key a running extension cannot understand is
+* better reported than silently ignored; a build that refuses to start over
+* the same key is not.
+*/
+function loadDoomConfigLenient(repoRoot, homeDirectory = os.homedir(), environment = process.env) {
+	const read = (filePath) => filePath !== void 0 && fs.existsSync(filePath) ? parseDoomConfig(fs.readFileSync(filePath, "utf8"), filePath, { lenient: true }) : {
+		config: { projectTrust: "ask" },
+		diagnostics: []
+	};
+	const globalConfig = read(globalDoomConfigPath(homeDirectory));
+	const repositoryConfig = read(repositoryConfigFor(repoRoot, homeDirectory));
+	const diagnostics = [...globalConfig.diagnostics, ...repositoryConfig.diagnostics];
+	return {
+		config: distributionDefaults(mergeDoomConfigs(globalConfig.config, repositoryConfig.config), environment),
+		diagnostics
+	};
+}
+async function loadDoomConfigAsync(repoRoot, homeDirectory = os.homedir(), environment = process.env) {
+	const globalConfig = await readConfigAsync(globalDoomConfigPath(homeDirectory));
+	const repositoryPath = repositoryConfigFor(repoRoot, homeDirectory);
+	const repositoryConfig = repositoryPath === void 0 ? { projectTrust: "ask" } : await readConfigAsync(repositoryPath);
+	return distributionDefaults(mergeDoomConfigs(globalConfig, repositoryConfig), environment);
+}
+/**
+* Reads one config file as a layer: what it is, what it sets, and the bytes it
+* held. A file that does not exist is a layer that sets nothing, which is a
+* normal state rather than an error.
+*/
+function readLayer(filePath) {
+	let text;
+	try {
+		text = fs.readFileSync(filePath, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return {
+			filePath,
+			exists: false,
+			hash: "",
+			keys: []
+		};
+		throw error;
+	}
+	const document = parse(text) ?? {};
+	return {
+		filePath,
+		exists: true,
+		hash: createHash("sha256").update(text, "utf8").digest("hex"),
+		keys: configLeafKeys(document)
+	};
+}
+/**
+* The two config files kept apart, with the merge alongside them.
+*
+* `repoRoot` is optional because the global file is complete on its own: a
+* settings surface with no repository in view still has settings to show, and
+* demanding one would leave it with nothing to render rather than with the
+* global half.
+*
+* The origin answer respects the merge's own per-field rules rather than simply
+* preferring the repository: `editor` is read from the global side whatever the
+* repository says, and `projectTrust` from the repository side whatever the
+* global one says. Reporting a file as the source of a value the merge discards
+* is the exact confusion this exists to remove.
+*/
+function loadDoomConfigLayers(repoRoot, homeDirectory = os.homedir(), environment = process.env) {
+	const globalLayer = readLayer(globalDoomConfigPath(homeDirectory));
+	const repositoryPath = repoRoot === void 0 ? void 0 : repositoryConfigFor(repoRoot, homeDirectory);
+	const repositoryLayer = repositoryPath === void 0 ? {
+		filePath: "",
+		exists: false,
+		hash: "",
+		keys: []
+	} : readLayer(repositoryPath);
+	const effective = repoRoot === void 0 ? distributionDefaults(mergeDoomConfigs(readConfig(globalDoomConfigPath(homeDirectory)), { projectTrust: "ask" }), environment) : loadDoomConfig(repoRoot, homeDirectory, environment);
+	const sets = (layer, keyPath) => {
+		const dotted = keyPath.join(".");
+		return layer.keys.some((key) => key === dotted || key.startsWith(`${dotted}.`));
+	};
+	return {
+		globalFile: globalLayer,
+		repositoryFile: repositoryLayer,
+		effective,
+		originOf(keyPath) {
+			const scope = configScopeOf(keyPath);
+			if (scope !== "global" && sets(repositoryLayer, keyPath)) return "repository";
+			if (scope !== "repository" && sets(globalLayer, keyPath)) return "global";
+			return "default";
+		},
+		valueAt: (keyPath) => valueAtKeyPath(effective, keyPath)
+	};
+}
+//#endregion
+export { loadDoomConfigAsync as a, repositoryDoomConfigPath as c, loadDoomConfig as i, resolvePlanningPlansDirectory as l, globalDoomConfigPath as n, loadDoomConfigLayers as o, isGlobalDoomConfigRoot as r, loadDoomConfigLenient as s, globalDoomConfigDirectory as t };
+
+//# sourceMappingURL=config-CKA07FxG.mjs.map

package/dist/config-CKA07FxG.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-CKA07FxG.mjs","names":["parseYaml"],"sources":["../src/services/config/index.ts"],"sourcesContent":["import { createHash } from 'node:crypto';\nimport fs from 'node:fs';\nimport os from 'node:os';\nimport path from 'node:path';\n\nimport { poHomeDirectory } from '@agimon-ai/po-core/piSettings';\nimport { parse as parseYaml } from 'yaml';\n\nimport type {\n  ConfigDiagnostic,\n  ConfigValueOrigin,\n  DoomConfig,\n  DoomConfigLayer,\n  DoomConfigLayers,\n  LenientParseResult,\n} from '../../types/config';\nimport { configLeafKeys, configScopeOf, mergeDoomConfigs, parseDoomConfig, valueAtKeyPath } from '../configPolicy';\n\nconst DOOM_DIR = '.po';\nconst CONFIG_FILE = 'config.yaml';\nconst PLANS_DIR = 'plans';\n\nfunction readConfig(filePath: string): DoomConfig {\n  return fs.existsSync(filePath)\n    ? parseDoomConfig(fs.readFileSync(filePath, 'utf8'), filePath)\n    : { projectTrust: 'ask' };\n}\n\nasync function readConfigAsync(filePath: string): Promise<DoomConfig> {\n  try {\n    return parseDoomConfig(await fs.promises.readFile(filePath, 'utf8'), filePath);\n  } catch (error) {\n    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return { projectTrust: 'ask' };\n    throw error;\n  }\n}\n\nexport function globalDoomConfigDirectory(homeDirectory = os.homedir()): string {\n  return poHomeDirectory(homeDirectory);\n}\n\nexport function globalDoomConfigPath(homeDirectory = os.homedir()): string {\n  return path.join(globalDoomConfigDirectory(homeDirectory), CONFIG_FILE);\n}\n\nexport function resolvePlanningPlansDirectory(\n  configured: string | undefined,\n  repoRoot: string,\n  homeDirectory = os.homedir(),\n): string {\n  // Under Po's home, so Po writes nothing into ~/.pi.\n  if (!configured) return path.join(globalDoomConfigDirectory(homeDirectory), PLANS_DIR);\n  if (configured === '~') return homeDirectory;\n  if (configured.startsWith('~/')) return path.resolve(homeDirectory, configured.slice(2));\n  if (configured.startsWith('~')) {\n    throw new Error(\"Doom planning plansDirectory supports only '~' or '~/' home aliases\");\n  }\n  return path.isAbsolute(configured) ? path.normalize(configured) : path.resolve(repoRoot, configured);\n}\n\nexport function repositoryDoomConfigPath(repoRoot: string): string {\n  return path.join(repoRoot, DOOM_DIR, CONFIG_FILE);\n}\n\n/**\n * True when a repository's `.po` folder is Po's home itself, as it is for a\n * session rooted at home. That folder is already the global layer; reading it\n * again as the repository layer would apply global-only keys at repository scope.\n */\nexport function isGlobalDoomConfigRoot(repoRoot: string, homeDirectory = os.homedir()): boolean {\n  return path.resolve(repoRoot, DOOM_DIR) === path.resolve(globalDoomConfigDirectory(homeDirectory));\n}\n\nfunction repositoryConfigFor(repoRoot: string, homeDirectory: string): string | undefined {\n  return isGlobalDoomConfigRoot(repoRoot, homeDirectory) ? undefined : repositoryDoomConfigPath(repoRoot);\n}\n\n/** Process-local distribution defaults never grant native authority or modify user files. */\nfunction distributionDefaults(config: DoomConfig, environment: NodeJS.ProcessEnv): DoomConfig {\n  if (environment.PO_DISTRIBUTION !== 'desktop') return config;\n  return { ...config, computerUse: { ...config.computerUse, enabled: config.computerUse?.enabled ?? true } };\n}\n\nexport function loadDoomConfig(\n  repoRoot: string,\n  homeDirectory = os.homedir(),\n  environment: NodeJS.ProcessEnv = process.env,\n): DoomConfig {\n  const repositoryPath = repositoryConfigFor(repoRoot, homeDirectory);\n  return distributionDefaults(\n    mergeDoomConfigs(\n      readConfig(globalDoomConfigPath(homeDirectory)),\n      repositoryPath === undefined ? { projectTrust: 'ask' } : readConfig(repositoryPath),\n    ),\n    environment,\n  );\n}\n\n/**\n * Loads the merged config, tolerating unknown keys in either file.\n *\n * Only `po sync` uses this. Everything that runs during a session keeps\n * `loadDoomConfig`, because a key a running extension cannot understand is\n * better reported than silently ignored; a build that refuses to start over\n * the same key is not.\n */\nexport function loadDoomConfigLenient(\n  repoRoot: string,\n  homeDirectory = os.homedir(),\n  environment: NodeJS.ProcessEnv = process.env,\n): LenientParseResult {\n  const read = (filePath: string | undefined): LenientParseResult =>\n    filePath !== undefined && fs.existsSync(filePath)\n      ? parseDoomConfig(fs.readFileSync(filePath, 'utf8'), filePath, { lenient: true })\n      : { config: { projectTrust: 'ask' }, diagnostics: [] };\n  const globalConfig = read(globalDoomConfigPath(homeDirectory));\n  const repositoryConfig = read(repositoryConfigFor(repoRoot, homeDirectory));\n  const diagnostics: ConfigDiagnostic[] = [...globalConfig.diagnostics, ...repositoryConfig.diagnostics];\n  // mergeDoomConfigs stays strict on purpose: its errors are cross-file scope\n  // violations on known keys, which is a different fault from an unknown key.\n  return {\n    config: distributionDefaults(mergeDoomConfigs(globalConfig.config, repositoryConfig.config), environment),\n    diagnostics,\n  };\n}\n\nexport async function loadDoomConfigAsync(\n  repoRoot: string,\n  homeDirectory = os.homedir(),\n  environment: NodeJS.ProcessEnv = process.env,\n): Promise<DoomConfig> {\n  const globalConfig = await readConfigAsync(globalDoomConfigPath(homeDirectory));\n  const repositoryPath = repositoryConfigFor(repoRoot, homeDirectory);\n  const repositoryConfig: DoomConfig =\n    repositoryPath === undefined ? { projectTrust: 'ask' } : await readConfigAsync(repositoryPath);\n  return distributionDefaults(mergeDoomConfigs(globalConfig, repositoryConfig), environment);\n}\n\n/**\n * Reads one config file as a layer: what it is, what it sets, and the bytes it\n * held. A file that does not exist is a layer that sets nothing, which is a\n * normal state rather than an error.\n */\nfunction readLayer(filePath: string): DoomConfigLayer {\n  let text: string;\n  try {\n    text = fs.readFileSync(filePath, 'utf8');\n  } catch (error) {\n    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {\n      return { filePath, exists: false, hash: '', keys: [] };\n    }\n    throw error;\n  }\n  // The raw document, not the parsed config: this is the one read that has to\n  // distinguish a key the file set from a key the parser defaulted.\n  const document = (parseYaml(text) ?? {}) as unknown;\n  return {\n    filePath,\n    exists: true,\n    hash: createHash('sha256').update(text, 'utf8').digest('hex'),\n    keys: configLeafKeys(document),\n  };\n}\n\n/**\n * The two config files kept apart, with the merge alongside them.\n *\n * `repoRoot` is optional because the global file is complete on its own: a\n * settings surface with no repository in view still has settings to show, and\n * demanding one would leave it with nothing to render rather than with the\n * global half.\n *\n * The origin answer respects the merge's own per-field rules rather than simply\n * preferring the repository: `editor` is read from the global side whatever the\n * repository says, and `projectTrust` from the repository side whatever the\n * global one says. Reporting a file as the source of a value the merge discards\n * is the exact confusion this exists to remove.\n */\nexport function loadDoomConfigLayers(\n  repoRoot: string | undefined,\n  homeDirectory = os.homedir(),\n  environment: NodeJS.ProcessEnv = process.env,\n): DoomConfigLayers {\n  const globalLayer = readLayer(globalDoomConfigPath(homeDirectory));\n  const repositoryPath = repoRoot === undefined ? undefined : repositoryConfigFor(repoRoot, homeDirectory);\n  const repositoryLayer =\n    repositoryPath === undefined ? { filePath: '', exists: false, hash: '', keys: [] } : readLayer(repositoryPath);\n  // With no repository there is nothing to merge, so the global file stands as\n  // the effective config on its own.\n  const effective =\n    repoRoot === undefined\n      ? distributionDefaults(\n          mergeDoomConfigs(readConfig(globalDoomConfigPath(homeDirectory)), { projectTrust: 'ask' }),\n          environment,\n        )\n      : loadDoomConfig(repoRoot, homeDirectory, environment);\n  const sets = (layer: DoomConfigLayer, keyPath: readonly string[]): boolean => {\n    const dotted = keyPath.join('.');\n    return layer.keys.some((key) => key === dotted || key.startsWith(`${dotted}.`));\n  };\n  return {\n    globalFile: globalLayer,\n    repositoryFile: repositoryLayer,\n    effective,\n    originOf(keyPath: readonly string[]): ConfigValueOrigin {\n      const scope = configScopeOf(keyPath);\n      if (scope !== 'global' && sets(repositoryLayer, keyPath)) return 'repository';\n      if (scope !== 'repository' && sets(globalLayer, keyPath)) return 'global';\n      return 'default';\n    },\n    valueAt: (keyPath: readonly string[]) => valueAtKeyPath(effective, keyPath),\n  };\n}\n"],"mappings":"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"}

package/dist/config-Cm3EV1jp.d.mts

@@ -0,0 +1,320 @@
+import { i as PersonaVoiceOverride, r as PersonaIdentity } from "./profiles-CTrUCmIh.mjs";
+import { DoomMcpProjection } from "@agimon-ai/po-core/mcpProjection";
+import { DOOM_CONFIG_SERVICE, IDoomConfigService } from "@agimon-ai/po-core/config";
+import { PackageAttribution, PackageAttribution as PackageAttribution$1 } from "@agimon-ai/po-core/contextProjection";
+//#region src/types/config.d.ts
+type ProjectTrust = 'ask' | 'always' | 'never';
+type PlanningThinkingLevel = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+type VoiceEngine = 'auto' | 'whisper-cpp' | 'openai-whisper' | 'mlx-whisper';
+type VoiceMode = 'legacy' | 'live';
+type VoiceTtsEngine = 'macos-say';
+interface PlanningAgentConfig {
+  model?: string;
+  thinking?: PlanningThinkingLevel;
+}
+interface PlanningModeConfig {
+  main?: PlanningAgentConfig;
+  subagents?: PlanningAgentConfig;
+  plansDirectory?: string;
+}
+/**
+ * Ratios of the context window at which each autocompact pass fires.
+ *
+ * Held as plain numbers so a reader can see the ladder in one place. The
+ * package owns the defaults and the ordering rule; this only carries what the
+ * file said.
+ */
+interface AutocompactThresholdConfig {
+  pass1?: number;
+  pass2?: number;
+  pass3?: number;
+}
+/**
+ * Absolute token checkpoints one matching model pins, replacing the ratio for
+ * that pass when it would fire earlier.
+ *
+ * A pass left unset keeps its ratio value, so an entry may pin one rung of the
+ * ladder without restating the rest.
+ */
+interface AutocompactTokenConfig {
+  pass1?: number;
+  pass2?: number;
+  pass3?: number;
+}
+/**
+ * One per-model override rule.
+ *
+ * `model` is a glob. A pattern containing `/` is matched against `provider/id`,
+ * anything else against the bare model id, because the wildcard does not cross
+ * the separator. Entries are tried in file order and the first match wins.
+ */
+interface AutocompactOverrideConfig {
+  model: string;
+  tokens: AutocompactTokenConfig;
+}
+interface AutocompactModeConfig {
+  enabled?: boolean;
+  model?: string;
+  thinking?: PlanningThinkingLevel;
+  thresholds?: AutocompactThresholdConfig;
+  overrides?: AutocompactOverrideConfig[];
+}
+interface ComputerUseConfig {
+  enabled?: boolean;
+}
+interface EditorConfig {
+  command?: string;
+}
+interface VoiceModelConfig {
+  path?: string;
+  id?: string;
+}
+interface VoiceAdapterConfig {
+  binary?: string;
+  model: VoiceModelConfig;
+}
+interface VoiceTtsConfig {
+  engine: VoiceTtsEngine;
+  voice?: string;
+  rate?: number;
+}
+interface VoiceAutoCaptureConfig {
+  model: string;
+  startPhrases?: string[];
+  stopPhrases?: string[];
+  composeOpenPhrases?: string[];
+  composeSendPhrases?: string[];
+  composeCancelPhrases?: string[];
+  utteranceIdleMs?: number;
+  composeUtteranceIdleMs?: number;
+  composeNudgeMs?: number;
+  transcriptionTimeoutMs?: number;
+  tts: VoiceTtsConfig;
+}
+interface ResolvedVoiceAutoCaptureConfig {
+  model: string;
+  startPhrases: string[];
+  stopPhrases: string[];
+  composeOpenPhrases: string[];
+  composeSendPhrases: string[];
+  composeCancelPhrases: string[];
+  utteranceIdleMs: number;
+  composeUtteranceIdleMs: number;
+  composeNudgeMs: number;
+  transcriptionTimeoutMs?: number;
+  tts: VoiceTtsConfig;
+}
+interface VoiceConfig {
+  mode?: VoiceMode;
+  engine?: VoiceEngine;
+  language?: string;
+  recorder?: {
+    binary?: string;
+    device?: string;
+  };
+  adapters?: {
+    'whisper-cpp'?: VoiceAdapterConfig;
+    'openai-whisper'?: VoiceAdapterConfig;
+    'mlx-whisper'?: VoiceAdapterConfig;
+  };
+  autoCapture?: VoiceAutoCaptureConfig;
+}
+interface ResolvedVoiceConfig {
+  mode: VoiceMode;
+  engine: VoiceEngine;
+  language: string;
+  recorder: {
+    binary?: string;
+    device: string;
+  };
+  adapters: NonNullable<VoiceConfig['adapters']>;
+  autoCapture?: ResolvedVoiceAutoCaptureConfig;
+}
+/**
+ * The matrix a repository selects by default.
+ *
+ * Read by `po sync`, which pins it into the generated Pi config so a plain
+ * `pi` session starts on the same matrix the repository declares. The launcher
+ * keeps taking its selection from flags and the environment.
+ */
+interface DoomSelectionConfig {
+  majorMode?: string;
+  domains?: string[];
+  profile?: string;
+}
+/** The selection persisted in a Pi session entry. */
+interface DoomConfigSelection {
+  readonly version: 1;
+  readonly majorMode: string;
+  readonly domains: readonly string[];
+  readonly profile?: string;
+  /** Canonical identity of the parent/child extension composition. */
+  readonly compositionFingerprint?: string;
+}
+type DoomConfigTransitionStrategy = 'pi-reload' | 'process-relaunch';
+type DoomConfigTransitionPhase = 'pending' | 'applied' | 'aborted' | 'superseded';
+interface DoomConfigTransitionRecord {
+  readonly version: 1;
+  readonly operationId: string;
+  readonly active: DoomConfigSelection;
+  readonly target: DoomConfigSelection;
+  readonly strategy: DoomConfigTransitionStrategy;
+  readonly phase: DoomConfigTransitionPhase;
+}
+/** A transition journal target that has not yet received an explicit fresh-session acknowledgement. */
+type DoomConfigPendingSelection = DoomConfigTransitionRecord & {
+  readonly phase: 'pending';
+};
+interface DoomConfig {
+  modes?: {
+    planning?: PlanningModeConfig;
+    autocompact?: AutocompactModeConfig;
+  };
+  computerUse?: ComputerUseConfig;
+  projectTrust: ProjectTrust;
+  editor?: EditorConfig;
+  voice?: VoiceConfig;
+  selection?: DoomSelectionConfig;
+  /** Default layout identifier, resolved against the available web template packages. */
+  web?: {
+    template?: string;
+  };
+  /** Phone app layout identifier, resolved against the native templates the admitted packages offer. */
+  native?: {
+    template?: string;
+  };
+}
+interface PluginHookSource {
+  pluginRoot: string;
+  configPath: string;
+}
+interface HarnessState {
+  root?: string;
+  /** The one named major mode this session runs under. */
+  majorMode: string;
+  temporaryDirectory?: string;
+  domains: string[];
+  /** The layer components the major mode resolved to. */
+  layers: string[];
+  /**
+   * Which mode, layer, or domain admitted each package, keyed by the package
+   * name exactly as its manifest spells it.
+   *
+   * The composition resolves this on its way to a flat list of entry paths and
+   * has no further use for it, so without somewhere to put it the causal link
+   * between a mode and the tools it brought is lost the moment the session
+   * starts. A surface that reports what the session is carrying has to be able
+   * to say what asked for it.
+   */
+  packageAttribution?: Record<string, PackageAttribution>;
+  /** Canonical identity shared by launch, sync, children, and reload. */
+  compositionFingerprint?: string;
+  profile?: string;
+  profileEnvironment: Record<string, string>;
+  hookGroups?: string[];
+  skillDirectories: string[];
+  agentDirectories: string[];
+  additionalDirectories: string[];
+  childExtensions: string[];
+  pluginDirectories: string[];
+  pluginHooks: PluginHookSource[];
+  /** File-only authority that the Config core publishes to the session registry. */
+  mcpProjection?: DoomMcpProjection;
+  /** Generation-pinned hook descriptor, transported only through the state file. */
+  hookModules?: {
+    file: string;
+  };
+  mcpConfigPath?: string;
+  personaFile?: string;
+  /**
+   * The active persona's presentation, carried here because the three surfaces
+   * that need it share no transport: the cockpit reads journalled entries, the
+   * voice worker reads config from disk, and the TUI reads the Cordis snapshot.
+   */
+  profileIdentity?: PersonaIdentity;
+  /** The active profile's TTS override, applied over `voice.autoCapture.tts`. */
+  profileVoice?: PersonaVoiceOverride;
+  allowProtectedWrites: boolean;
+  hooks: boolean;
+  agents: boolean;
+  mcp: boolean;
+}
+type DeepReadonly<TValue> = TValue extends ((...args: never[]) => unknown) ? TValue : TValue extends readonly (infer TItem)[] ? readonly DeepReadonly<TItem>[] : TValue extends object ? { readonly [TKey in keyof TValue]: DeepReadonly<TValue[TKey]>; } : TValue;
+type DoomHarnessContext = DeepReadonly<HarnessState>;
+interface DoomConfigContext {
+  readonly settings: DeepReadonly<DoomConfig>;
+  readonly harness: DoomHarnessContext;
+  /** A journal target awaiting explicit acknowledgement; the active harness remains above. */
+  readonly pendingSelection?: DeepReadonly<DoomConfigPendingSelection>;
+  /** Whether the active harness does not yet match the pending target. */
+  readonly requiresRelaunch: boolean;
+}
+/** A file-only loader; unlike the Cordis service it owns no live session snapshot. */
+interface IDoomConfigLoader {
+  load(repoRoot: string, homeDirectory?: string): DoomConfig;
+}
+/** The config package's concrete specialization of the cross-package service contract. */
+interface IDoomConfigService$1 extends IDoomConfigService<DoomConfigContext, DoomConfig> {}
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    'doom/config': IDoomConfigService$1;
+  }
+}
+/** Which file the effective value for a key came from, or that no file set it. */
+type ConfigValueOrigin = 'global' | 'repository' | 'default';
+/** One of the two config files, as a settings surface needs to see it. */
+interface DoomConfigLayer {
+  filePath: string;
+  exists: boolean;
+  /**
+   * sha256 of the file's bytes, empty when absent. The token a write proves
+   * itself with: the writer is torn-read safe but not lost-update safe, so a
+   * caller that read a file and then writes it should say which bytes it read.
+   */
+  hash: string;
+  /** Dotted key paths this file actually sets, leaves only. */
+  keys: readonly string[];
+}
+/**
+ * The two config files kept apart, alongside the merge every consumer sees.
+ *
+ * `loadDoomConfig` flattens global and repository into one object, which is all
+ * the runtime needs and not enough for a settings surface: a value that is set
+ * in both files looks identical to one set in neither, so an editor cannot say
+ * where a value came from, and offers a write that the merge may then ignore.
+ */
+interface DoomConfigLayers {
+  /** Named with the suffix because a bare `global` reads as the process global. */
+  globalFile: DoomConfigLayer;
+  repositoryFile: DoomConfigLayer;
+  effective: DoomConfig;
+  /** Where the effective value at this key path came from. */
+  originOf(keyPath: readonly string[]): ConfigValueOrigin;
+  /** The effective value at this key path, or undefined when nothing set it. */
+  valueAt(keyPath: readonly string[]): unknown;
+}
+/**
+ * One tolerated problem found while reading a config file.
+ *
+ * Carries the file it came from because a lenient load merges the global and
+ * repository files, and "unsupported field: voice.engine" is unactionable
+ * without saying which of the two declared it.
+ */
+interface ConfigDiagnostic {
+  filePath: string;
+  /** Dotted path to the offending key, for example `voice.recorder.typo`. */
+  path: string;
+  message: string;
+}
+/** Opts a parse into collecting unknown keys instead of throwing on them. */
+interface LenientParseOptions {
+  lenient: true;
+}
+/** What a lenient parse returns in place of a bare config. */
+interface LenientParseResult {
+  config: DoomConfig;
+  diagnostics: ConfigDiagnostic[];
+}
+//#endregion
+export { PluginHookSource as A, VoiceTtsConfig as B, IDoomConfigService$1 as C, PlanningAgentConfig as D, PackageAttribution$1 as E, VoiceAutoCaptureConfig as F, VoiceConfig as I, VoiceEngine as L, ResolvedVoiceAutoCaptureConfig as M, ResolvedVoiceConfig as N, PlanningModeConfig as O, VoiceAdapterConfig as P, VoiceMode as R, IDoomConfigLoader as S, LenientParseResult as T, VoiceTtsEngine as V, DoomConfigTransitionStrategy as _, ConfigDiagnostic as a, EditorConfig as b, DeepReadonly as c, DoomConfigLayer as d, DoomConfigLayers as f, DoomConfigTransitionRecord as g, DoomConfigTransitionPhase as h, AutocompactTokenConfig as i, ProjectTrust as j, PlanningThinkingLevel as k, DoomConfig as l, DoomConfigSelection as m, AutocompactOverrideConfig as n, ConfigValueOrigin as o, DoomConfigPendingSelection as p, AutocompactThresholdConfig as r, DOOM_CONFIG_SERVICE as s, AutocompactModeConfig as t, DoomConfigContext as u, DoomHarnessContext as v, LenientParseOptions as w, HarnessState as x, DoomSelectionConfig as y, VoiceModelConfig as z };
+//# sourceMappingURL=config-Cm3EV1jp.d.mts.map

package/dist/config-Cm3EV1jp.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-Cm3EV1jp.d.mts","names":["IDoomConfigService","DoomConfigServiceContract"],"sources":["../src/types/config.ts"],"mappings":";;;;;KAOY;KACA;KACA;KACA;KACA;UAEK;EACf;EACA,WAAW;;UAEI;EACf,OAAO;EACP,YAAY;EACZ;;;;;;;;;UASe;EACf;EACA;EACA;;;;;;;;;UASe;EACf;EACA;EACA;;;;;;;;;UASe;EACf;EACA,QAAQ;;UAEO;EACf;EACA;EACA,WAAW;EACX,aAAa;EACb,YAAY;;UAEG;EACf;;UAGe;EACf;;UAEe;EACf;EACA;;UAEe;EACf;EACA,OAAO;;UAEQ;EACf,QAAQ;EACR;EACA;;UAEe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,KAAK;;UAEU;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,KAAK;;UAEU;EACf,OAAO;EACP,SAAS;EACT;EACA;IAAa;IAAiB;;EAC9B;IACE,gBAAgB;IAChB,mBAAmB;IACnB,gBAAgB;;EAElB,cAAc;;UAEC;EACf,MAAM;EACN,QAAQ;EACR;EACA;IAAY;IAAiB;;EAC7B,UAAU,YAAY;EACtB,cAAc;;;;;;;;;UASC;EACf;EACA;EACA;;;UAIe;WACN;WACA;WACA;WACA;;WAEA;;KAGC;KACA;UAEK;WACN;WACA;WACA,QAAQ;WACR,QAAQ;WACR,UAAU;WACV,OAAO;;;KAIN,6BAA6B;WAAwC;;UAEhE;EACf;IAAU,WAAW;IAAoB,cAAc;;EACvD,cAAc;EACd,cAAc;EACd,SAAS;EACT,QAAQ;EACR,YAAY;;EAEZ;IAAQ;;;EAER;IAAW;;;UAGI;EACf;EACA;;UAMe;EACf;;EAEA;EACA;EACA;;EAEA;;;;;;;;;;;EAWA,qBAAqB,eAAe;;EAEpC;EACA;EACA,oBAAoB;EACpB;EACA;EACA;EACA;EACA;EACA;EACA,aAAa;;EAEb,gBAAgB;;EAEhB;IAAgB;;EAChB;EACA;;;;;;EAMA,kBAAkB;;EAElB,eAAe;EACf;EACA;EACA;EACA;;KAGU,aAAa,UAAU,oBAAmB,6BAClD,SACA,+BAA+B,oBACpB,aAAa,WACtB,oCACc,cAAc,SAAS,aAAa,OAAO,YACvD;KAEI,qBAAqB,aAAa;UAE7B;WACN,UAAU,aAAa;WACvB,SAAS;;WAET,mBAAmB,aAAa;;WAEhC;;;UAIM;EACf,KAAK,kBAAkB,yBAAyB;;;UAIjCA,6BAA2BC,mBAA0B,mBAAmB;;YAG7E;IACR,eAAeD;;;;KAQP;;UAGK;EACf;EACA;;;;;;EAMA;;EAEA;;;;;;;;;;UAWe;;EAEf,YAAY;EACZ,gBAAgB;EAChB,WAAW;;EAEX,SAAS,6BAA6B;;EAEtC,QAAQ;;;;;;;;;UAUO;EACf;;EAEA;EACA;;;UAIe;EACf;;;UAIe;EACf,QAAQ;EACR,aAAa"}

package/dist/config-NSHRd6na.mjs

@@ -0,0 +1,2 @@
+import { DOOM_CONFIG_SERVICE } from "@agimon-ai/po-core/config";
+export { DOOM_CONFIG_SERVICE as t };

package/dist/config-zZz80Mh5.cjs

@@ -0,0 +1 @@
+require("@agimon-ai/po-core/config");

package/dist/config.cjs

@@ -0,0 +1,24 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_configPolicy = require("./configPolicy-DmsZEp0t.cjs");
+const require_config = require("./config-BUw5kHsx.cjs");
+exports.DOOM_PLANNING_THINKING_LEVELS = require_configPolicy.DOOM_PLANNING_THINKING_LEVELS;
+exports.DOOM_VOICE_ENGINES = require_configPolicy.DOOM_VOICE_ENGINES;
+exports.DOOM_VOICE_MODES = require_configPolicy.DOOM_VOICE_MODES;
+exports.DOOM_VOICE_TTS_ENGINES = require_configPolicy.DOOM_VOICE_TTS_ENGINES;
+exports.configLeafKeys = require_configPolicy.configLeafKeys;
+exports.configRootKeys = require_configPolicy.configRootKeys;
+exports.configScopeOf = require_configPolicy.configScopeOf;
+exports.globalDoomConfigDirectory = require_config.globalDoomConfigDirectory;
+exports.globalDoomConfigPath = require_config.globalDoomConfigPath;
+exports.loadDoomConfig = require_config.loadDoomConfig;
+exports.loadDoomConfigAsync = require_config.loadDoomConfigAsync;
+exports.loadDoomConfigLayers = require_config.loadDoomConfigLayers;
+exports.loadDoomConfigLenient = require_config.loadDoomConfigLenient;
+exports.mergeDoomConfigs = require_configPolicy.mergeDoomConfigs;
+exports.parseAutocompactModeConfig = require_configPolicy.parseAutocompactModeConfig;
+exports.parseDoomConfig = require_configPolicy.parseDoomConfig;
+exports.parsePlanningModeConfig = require_configPolicy.parsePlanningModeConfig;
+exports.repositoryDoomConfigPath = require_config.repositoryDoomConfigPath;
+exports.resolvePlanningPlansDirectory = require_config.resolvePlanningPlansDirectory;
+exports.resolveVoiceConfig = require_configPolicy.resolveVoiceConfig;
+exports.valueAtKeyPath = require_configPolicy.valueAtKeyPath;

package/dist/config.d.mts

@@ -0,0 +1,3 @@
+import { T as LenientParseResult, a as ConfigDiagnostic, d as DoomConfigLayer, f as DoomConfigLayers, o as ConfigValueOrigin, w as LenientParseOptions } from "./config-Cm3EV1jp.mjs";
+import { S as resolvePlanningPlansDirectory, _ as loadDoomConfig, a as DOOM_VOICE_TTS_ENGINES, b as loadDoomConfigLenient, c as configScopeOf, d as parseDoomConfig, f as parsePlanningModeConfig, g as globalDoomConfigPath, h as globalDoomConfigDirectory, i as DOOM_VOICE_MODES, l as mergeDoomConfigs, m as valueAtKeyPath, n as DOOM_PLANNING_THINKING_LEVELS, o as configLeafKeys, p as resolveVoiceConfig, r as DOOM_VOICE_ENGINES, s as configRootKeys, t as ConfigKeyScope, u as parseAutocompactModeConfig, v as loadDoomConfigAsync, x as repositoryDoomConfigPath, y as loadDoomConfigLayers } from "./index-B_lp0W3U.mjs";
+export { type ConfigDiagnostic, type ConfigKeyScope, type ConfigValueOrigin, DOOM_PLANNING_THINKING_LEVELS, DOOM_VOICE_ENGINES, DOOM_VOICE_MODES, DOOM_VOICE_TTS_ENGINES, type DoomConfigLayer, type DoomConfigLayers, type LenientParseOptions, type LenientParseResult, configLeafKeys, configRootKeys, configScopeOf, globalDoomConfigDirectory, globalDoomConfigPath, loadDoomConfig, loadDoomConfigAsync, loadDoomConfigLayers, loadDoomConfigLenient, mergeDoomConfigs, parseAutocompactModeConfig, parseDoomConfig, parsePlanningModeConfig, repositoryDoomConfigPath, resolvePlanningPlansDirectory, resolveVoiceConfig, valueAtKeyPath };

package/dist/config.mjs

@@ -0,0 +1,3 @@
+import { a as configLeafKeys, c as mergeDoomConfigs, d as parsePlanningModeConfig, f as resolveVoiceConfig, i as DOOM_VOICE_TTS_ENGINES, l as parseAutocompactModeConfig, n as DOOM_VOICE_ENGINES, o as configRootKeys, p as valueAtKeyPath, r as DOOM_VOICE_MODES, s as configScopeOf, t as DOOM_PLANNING_THINKING_LEVELS, u as parseDoomConfig } from "./configPolicy--TNX7feH.mjs";
+import { a as loadDoomConfigAsync, c as repositoryDoomConfigPath, i as loadDoomConfig, l as resolvePlanningPlansDirectory, n as globalDoomConfigPath, o as loadDoomConfigLayers, s as loadDoomConfigLenient, t as globalDoomConfigDirectory } from "./config-CKA07FxG.mjs";
+export { DOOM_PLANNING_THINKING_LEVELS, DOOM_VOICE_ENGINES, DOOM_VOICE_MODES, DOOM_VOICE_TTS_ENGINES, configLeafKeys, configRootKeys, configScopeOf, globalDoomConfigDirectory, globalDoomConfigPath, loadDoomConfig, loadDoomConfigAsync, loadDoomConfigLayers, loadDoomConfigLenient, mergeDoomConfigs, parseAutocompactModeConfig, parseDoomConfig, parsePlanningModeConfig, repositoryDoomConfigPath, resolvePlanningPlansDirectory, resolveVoiceConfig, valueAtKeyPath };