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

package/dist/index-CeOk2kqs.d.mts

@@ -0,0 +1,118 @@
+import { a as ConfigDiagnostic } from "./config-Cm3EV1jp.mjs";
+import { n as DoomConfigProvenance } from "./index-Ch7ptOkW.mjs";
+//#region src/services/majorModes/index.d.ts
+type LayerPackageConfig = Record<string, unknown>;
+/** One package selected by a layer, plus configuration owned by that package. */
+interface LayerPackage {
+  name: string;
+  optional?: boolean;
+  config?: LayerPackageConfig;
+}
+/** One configured package found while walking selected layers in order. */
+interface ResolvedPackageConfiguration {
+  layer: string;
+  specifier: string;
+  config: LayerPackageConfig;
+  baseDirectory: string;
+  filePath?: string;
+}
+interface LayerDefinition {
+  /**
+   * Po built-in names, or Pi-compatible local extension paths.
+   * Bare names resolve from Po's own extension entries. Paths beginning
+   * with `./` or `../`, plus absolute paths, resolve against the config that
+   * declares the layer and may name a script file or extension directory.
+   */
+  extensions?: string[];
+  /**
+   * npm specifiers, or local package paths retained for compatibility.
+   * Relative paths resolve against the repository root for `.po/modes.yaml`
+   * and against the global `.po` directory for
+   * `~/.po/modes.yaml`.
+   */
+  packages?: Array<string | LayerPackage>;
+  hookGroups?: string[];
+}
+/** A layer plus the root its relative extension and package paths resolve against. */
+interface ResolvedLayerDefinition extends LayerDefinition {
+  baseDirectory: string;
+  /** Absolute path of the modes file that declared this layer. */
+  filePath?: string;
+}
+interface MajorModeDefinition {
+  /** Human-readable purpose used by pickers and agent-facing catalogs. */
+  description: string;
+  /** Ordered layer names activated by this mode. */
+  layers: string[];
+}
+interface MajorModesConfig {
+  /** Unconditional package bundle loaded before packages from selected named layers. */
+  default?: ResolvedLayerDefinition;
+  layers: Record<string, ResolvedLayerDefinition>;
+  /** The mode selected when neither a flag nor the environment names one. */
+  defaultMajorMode: string;
+  /** Source that last declared the default, absent for the built-in fallback. */
+  defaultMajorModeSource?: DoomConfigProvenance;
+  /** Named major modes, including their purpose and ordered layers. */
+  majorMode: Record<string, MajorModeDefinition>;
+  /** Declaring source for each surviving named mode. */
+  majorModeSources?: Record<string, DoomConfigProvenance>;
+}
+interface LayerResolvers {
+  ownEntry: (name: string) => string;
+  packageEntry: (name: string) => string;
+  optionalPackageEntry: (name: string) => string | undefined;
+  /** Resolves every standard package.json pi.extensions entry for a package root. */
+  packageEntries?: (name: string) => string[];
+  /** Optional counterpart to packageEntries. */
+  optionalPackageEntries?: (name: string) => string[] | undefined;
+  /** Resolves one path-style layer entry against the config that declared it. */
+  localEntry: (specifier: string, baseDirectory: string) => string | undefined;
+  /** Resolves every Pi extension entry contributed by a local file or directory. */
+  localEntries?: (specifier: string, baseDirectory: string) => string[] | undefined;
+}
+/**
+ * Whether a layer value names a path rather than a built-in or installed package.
+ *
+ * The same rule Node applies to import specifiers, so a bare name is always a
+ * logical name and a path always looks like one.
+ */
+declare function isLocalPackageSpecifier(specifier: string): boolean;
+/**
+ * Reads layers and major modes from the global and repository configs.
+ *
+ * The repository is read last, so it replaces a global layer or major mode of
+ * the same name. Layers keep the root they were declared under so that a
+ * global layer naming `./extensions/x` still points beside the global config
+ * once it is loaded from inside some other repository.
+ */
+declare function loadMajorModesConfig(repoRoot: string, homeDirectory?: string, environment?: NodeJS.ProcessEnv): MajorModesConfig;
+/** Finds configuration owned by one package while preserving layer and package order. */
+declare function resolvePackageConfigurations(config: MajorModesConfig, names: string[], packageName: string): ResolvedPackageConfiguration[];
+/** Resolves one named major mode into its configured layer components. */
+declare function resolveLayers(config: MajorModesConfig, majorMode: string): string[];
+/** Resolves one layer's extension and package entries to absolute paths. */
+declare function layerEntries(config: MajorModesConfig, name: string, resolvers: LayerResolvers): string[];
+/** Hook group ids contributed by the selected layers, deduped. */
+declare function layerHookGroups(config: MajorModesConfig, names: string[]): string[];
+/**
+ * Suppress layers that exist to contribute hook groups when hooks are disabled.
+ *
+ * Lives beside layerHookGroups because it is the inverse question about the same
+ * field, and because every caller that resolves layers has to ask it.
+ */
+declare function filterHookDisabledLayers(config: MajorModesConfig, layers: readonly string[], hooks: boolean): string[];
+/**
+ * Reads layers and major modes, tolerating unknown keys.
+ *
+ * `po sync` uses this so a modes.yaml written against a different set of
+ * layer packages cannot break a build. Every other caller keeps the strict
+ * `loadMajorModesConfig`, and `po doctor` still reports what was tolerated.
+ */
+declare function loadMajorModesConfigLenient(repoRoot: string, homeDirectory?: string, environment?: NodeJS.ProcessEnv): {
+  config: MajorModesConfig;
+  diagnostics: ConfigDiagnostic[];
+};
+//#endregion
+export { MajorModeDefinition as a, ResolvedPackageConfiguration as c, layerEntries as d, layerHookGroups as f, resolvePackageConfigurations as g, resolveLayers as h, LayerResolvers as i, filterHookDisabledLayers as l, loadMajorModesConfigLenient as m, LayerPackage as n, MajorModesConfig as o, loadMajorModesConfig as p, LayerPackageConfig as r, ResolvedLayerDefinition as s, LayerDefinition as t, isLocalPackageSpecifier as u };
+//# sourceMappingURL=index-CeOk2kqs.d.mts.map

package/dist/index-CeOk2kqs.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CeOk2kqs.d.mts","names":[],"sources":["../src/services/majorModes/index.ts"],"mappings":";;;KAMY,qBAAqB;;UAGhB;EACf;EACA;EACA,SAAS;;;UAIM;EACf;EACA;EACA,QAAQ;EACR;EACA;;UAGe;;;;;;;EAOf;;;;;;;EAOA,WAAW,eAAe;EAC1B;;;UAIe,gCAAgC;EAC/C;;EAEA;;UAGe;;EAEf;;EAEA;;UAGe;;EAEf,UAAU;EACV,QAAQ,eAAe;;EAEvB;;EAEA,yBAAyB;;EAEzB,WAAW,eAAe;;EAE1B,mBAAmB,eAAe;;UAGnB;EACf,WAAW;EACX,eAAe;EACf,uBAAuB;;EAEvB,kBAAkB;;EAElB,0BAA0B;;EAE1B,aAAa,mBAAmB;;EAEhC,gBAAgB,mBAAmB;;;;;;;;iBAsBrB,wBAAwB;;;;;;;;;iBAoLxB,qBACd,kBACA,wBACA,cAAa,OAAO,aACnB;;iBA2Ea,6BACd,QAAQ,kBACR,iBACA,sBACC;;iBA4Ba,cAAc,QAAQ,kBAAkB;;iBAqBxC,aAAa,QAAQ,kBAAkB,cAAc,WAAW;;iBAmDhE,gBAAgB,QAAQ,kBAAkB;;;;;;;iBAc1C,yBACd,QAAQ,kBACR,2BACA;;;;;;;;iBAac,4BACd,kBACA,wBACA,cAAa,OAAO;EACjB,QAAQ;EAAkB,aAAa"}

package/dist/index-Ch7ptOkW.d.mts

@@ -0,0 +1,54 @@
+//#region src/services/layeredConfig/index.d.ts
+/** Repository-local po configuration directory, committed to git. */
+declare const DOOM_DIR = ".po";
+/** Source identity retained for diagnostics and composition fingerprints. */
+interface DoomConfigProvenance {
+  /** Absolute path of the declaring configuration file. */
+  filePath: string;
+  /** Directory used to resolve paths authored by that file. */
+  baseDirectory: string;
+}
+/** One `.po` document plus the root its relative paths resolve against. */
+interface DoomConfigSource<TDocument> extends DoomConfigProvenance {
+  /** Absolute path of the file the document was read from. */
+  filePath: string;
+  /**
+   * Where relative paths inside this document point.
+   *
+   * A repository document resolves against the repository root, so `plugins/x`
+   * keeps meaning the same thing it always has. A global document resolves
+   * against the global `.po` directory, so it can name plugins and extensions
+   * that live beside it in `~/.po` rather than inside whichever
+   * repository happens to be open.
+   */
+  baseDirectory: string;
+  /** Raw file contents, for callers that cache parsed results by source text. */
+  text: string;
+  document: TDocument;
+}
+/**
+ * Reads one named `.po` document from the global and repository config
+ * directories, lowest precedence first.
+ *
+ * A missing or empty file contributes nothing, so either location on its own is
+ * a complete configuration. Documents are deliberately returned unmerged:
+ * merging is by name, and only the caller knows what a name means in its own
+ * document, so each one folds the sources itself with the repository last.
+ */
+declare function doomConfigCandidates(fileName: string, repoRoot: string, homeDirectory?: string): Array<{
+  filePath: string;
+  baseDirectory: string;
+}>;
+declare function readDoomConfigSources<TDocument>(fileName: string, repoRoot: string, homeDirectory?: string): Array<DoomConfigSource<TDocument>>;
+/**
+ * Merges same-named records across sources, tagging each entry with the base
+ * directory of the document that supplied it.
+ *
+ * Later sources win outright rather than being deep-merged: a repository that
+ * redefines a name is replacing it, and a half-inherited definition whose paths
+ * straddle two roots would be impossible to resolve.
+ */
+declare function mergeNamedSources<TDocument, TEntry extends object>(sources: ReadonlyArray<DoomConfigSource<TDocument>>, select: (document: TDocument) => Record<string, TEntry> | undefined): Record<string, TEntry & DoomConfigProvenance>;
+//#endregion
+export { mergeNamedSources as a, doomConfigCandidates as i, DoomConfigProvenance as n, readDoomConfigSources as o, DoomConfigSource as r, DOOM_DIR as t };
+//# sourceMappingURL=index-Ch7ptOkW.d.mts.map

package/dist/index-Ch7ptOkW.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-Ch7ptOkW.d.mts","names":[],"sources":["../src/services/layeredConfig/index.ts"],"mappings":";;cASa;;UAKI;;EAEf;;EAEA;;;UAIe,iBAAiB,mBAAmB;;EAEnD;;;;;;;;;;EAUA;;EAEA;EACA,UAAU;;;;;;;;;;;iBAYI,qBACd,kBACA,kBACA,yBACC;EAAQ;EAAkB;;iBAOb,sBAAsB,WACpC,kBACA,kBACA,yBACC,MAAM,iBAAiB;;;;;;;;;iBAwBV,kBAAkB,WAAW,uBAC3C,SAAS,cAAc,iBAAiB,aACxC,SAAS,UAAU,cAAc,eAAe,sBAC/C,eAAe,SAAS"}

package/dist/index-Cvdt-Y-i.d.mts

@@ -0,0 +1,66 @@
+//#region src/services/configWriter/index.d.ts
+/**
+ * Writes into the global Doom config file, one key path at a time.
+ *
+ * Extracted from doom-file-edit, which owned the only writer in the repo and had
+ * it hard-coded to `editor.command`. Several extensions now edit their own
+ * settings from the config panel, and every one of them needs the same four
+ * properties: keep the user's comments, never publish a file the parser would
+ * reject, never leave a half-written file behind, and apply a set of related
+ * edits together.
+ *
+ * That last one is not a convenience. `voice.adapters.<engine>.model` accepts a
+ * path or an id but not both, so switching between them is a set and an unset
+ * that must land in the same write, or the file is briefly invalid.
+ *
+ * Atomicity is the same rename trick as `atomicJson.ts` next door, and carries
+ * the same caveat: it prevents torn reads, not lost updates. Two sessions with
+ * the panel open still clobber each other, because the rename only publishes
+ * what the caller already computed.
+ *
+ * AVOID:
+ * - Treating this as a lock
+ * - Writing an empty string; the parser rejects blank values, so clearing a key
+ *   means removing it
+ */
+/** Which file a write is aimed at; the modes follow from it. */
+type DoomConfigScope = 'global' | 'repository';
+interface DoomConfigEdit {
+  /** Key path into the document, e.g. `['voice', 'adapters', 'mlx-whisper', 'model', 'id']`. */
+  readonly keyPath: readonly string[];
+  /**
+   * The value to write. `undefined` removes the key.
+   *
+   * Not only strings: the config holds numbers (`utteranceIdleMs`) and lists
+   * (`startPhrases`), and a panel that edits them as text has to hand back the
+   * parsed value or the next load rejects what it wrote.
+   */
+  readonly value?: string | number | boolean | readonly string[];
+}
+interface WriteDoomConfigOptions {
+  /**
+   * Remove ancestors left holding nothing. Defaults to true, and is not
+   * cosmetic: an adapter left as `{}` fails validation, because the parser
+   * requires a model once the adapter exists at all.
+   */
+  readonly prune?: boolean;
+  /**
+   * Which file this is, so the write lands with the right permissions.
+   * Defaults to `global`, which is what every caller wrote before the
+   * repository file was writable at all.
+   */
+  readonly scope?: DoomConfigScope;
+}
+/**
+ * Applies every edit as one document mutation, or throws having written nothing.
+ *
+ * Validation runs against the serialized result rather than each edit, so a pair
+ * of edits only valid together is accepted, and a single edit that breaks an
+ * invariant elsewhere is still caught.
+ */
+declare function writeDoomConfigValues(filePath: string, edits: readonly DoomConfigEdit[], options?: WriteDoomConfigOptions): Promise<void>;
+declare function setDoomConfigValue(filePath: string, keyPath: readonly string[], value: string, options?: WriteDoomConfigOptions): Promise<void>;
+declare function unsetDoomConfigValue(filePath: string, keyPath: readonly string[], options?: WriteDoomConfigOptions): Promise<void>;
+//#endregion
+export { unsetDoomConfigValue as a, setDoomConfigValue as i, DoomConfigScope as n, writeDoomConfigValues as o, WriteDoomConfigOptions as r, DoomConfigEdit as t };
+//# sourceMappingURL=index-Cvdt-Y-i.d.mts.map

package/dist/index-Cvdt-Y-i.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-Cvdt-Y-i.d.mts","names":[],"sources":["../src/services/configWriter/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;KAkDY;UASK;;WAEN;;;;;;;;WAQA;;UAGM;;;;;;WAMN;;;;;;WAMA,QAAQ;;;;;;;;;iBAmCG,sBACpB,kBACA,gBAAgB,kBAChB,UAAS,yBACR;iBAqCmB,mBACpB,kBACA,4BACA,eACA,UAAS,yBACR;iBAImB,qBACpB,kBACA,4BACA,UAAS,yBACR"}

package/dist/index-DJpG-I9K.d.mts

@@ -0,0 +1,122 @@
+import { x as HarnessState } from "./config-Cm3EV1jp.mjs";
+import { r as HarnessStateParseReporter } from "./index-CIQrKS1A.mjs";
+//#region src/models/harnessCache.d.ts
+interface LoadedHarnessState {
+  /** Undefined when this process is running off the environment fallback. */
+  filePath?: string;
+  owned: boolean;
+  state: HarnessState;
+}
+//#endregion
+//#region src/services/harnessStore/index.d.ts
+/**
+ * Who owns the harness state, and where it lives.
+ *
+ * The state used to be the environment: twenty variables that every reader
+ * re-parsed and every writer mutated globally. The file is the authority now,
+ * and the environment is a projection published for the readers that can only
+ * see an environment, which are bash hooks, the shell launchers, packages that
+ * do not depend on this one, and any process spawned by any of them.
+ *
+ * OWNERSHIP IS PER PROCESS, AND THAT IS THE WHOLE DESIGN:
+ * Doom Team subagents run detached, in their own process group, from an
+ * environment snapshot taken at spawn. A child can outlive its parent. If it
+ * shared the parent's file it would corrupt a session it does not own, and if
+ * that file sat in the parent's run directory the parent's shutdown sweep would
+ * delete it from under a live run. So every process writes a file it owns:
+ * `owner.pid` records who, and a process that finds someone else's file copies
+ * it before its first write.
+ *
+ * AVOID:
+ * - Treating the file as shared mutable state between processes. Atomic writes
+ *   prevent torn reads, not lost updates
+ * - Reading the environment directly for anything this exposes
+ */
+/** Points at the state file. The one variable that is not derived. */
+declare const HARNESS_STATE_POINTER = "PO_STATE";
+interface HarnessStateFile {
+  version: number;
+  owner: {
+    pid: number;
+    startedAt: string;
+  };
+  state: HarnessState;
+}
+interface HarnessStateTransactionSnapshot {
+  readonly filePath?: string;
+  readonly owned: boolean;
+  readonly state: HarnessState;
+  readonly environment: Readonly<Record<string, string | undefined>>;
+}
+/** Drops the cached state. For tests, and for a process changing identity. */
+declare function resetHarnessStore(): void;
+/**
+ * Reads the state for this process, once.
+ *
+ * A missing pointer means nobody wrote a file for this process, so the
+ * environment is all there is: a nested run, a third-party spawn, or a caller
+ * older than the store. A pointer that cannot be read is reported and then
+ * treated the same way, because a session that starts degraded beats a session
+ * that does not start at all.
+ */
+declare function loadHarnessState(environment?: NodeJS.ProcessEnv, report?: HarnessStateParseReporter): LoadedHarnessState;
+/** Captures the owned state pointer and every projected harness variable. */
+declare function snapshotHarnessState(environment?: NodeJS.ProcessEnv): HarnessStateTransactionSnapshot;
+/** Restores a snapshot only while the current process still owns its state pointer. */
+declare function restoreHarnessStateSnapshot(snapshot: HarnessStateTransactionSnapshot, environment?: NodeJS.ProcessEnv): void;
+declare function getHarnessState(report?: HarnessStateParseReporter): HarnessState;
+/**
+ * The harness state of one session, by id.
+ *
+ * A server runs many sessions' extensions in one process, each with its own state file, so
+ * a session-scoped reader asks by session id. A terminal session owns its process, and the
+ * answer is the same as `getHarnessState`.
+ */
+declare function getSessionHarnessState(sessionId: string | undefined, report?: HarnessStateParseReporter): HarnessState;
+/**
+ * Starts a session: writes the file and publishes the derived environment.
+ *
+ * The environment is a parameter because the caller is usually describing a
+ * process other than itself. The launcher builds the environment for the Pi it
+ * is about to spawn, and Doom Team builds the snapshot for a detached child, so
+ * neither should touch its own `process.env` to do it.
+ */
+declare function createHarnessSession(state: HarnessState, options: {
+  directory: string;
+  environment: NodeJS.ProcessEnv;
+  /**
+   * Leave the file for a process that does not exist yet to claim.
+   *
+   * What a spawner wants: the child owns its state from its first read, in a
+   * directory the spawner manages, so the parent cleaning up its own session
+   * cannot pull the file out from under a detached run.
+   */
+  unclaimed?: boolean;
+}): string;
+/**
+ * Applies a patch to this process's state.
+ *
+ * Copy on write: a process holding a file it does not own writes its own copy
+ * and repoints itself at it, so a child can never rewrite its parent's session.
+ */
+declare function updateHarnessState(patch: Partial<HarnessState>, environment?: NodeJS.ProcessEnv): HarnessState;
+/** Removes this process's own state file. Safe when there is none. */
+declare function disposeHarnessState(environment?: NodeJS.ProcessEnv): void;
+declare function harnessRoot(state?: Pick<HarnessState, 'root'>): string;
+/**
+ * The repository root, or a hard error.
+ *
+ * Separate from `requireHarnessPaths` because most callers only need the root,
+ * and separate from `harnessRoot` because falling back to `process.cwd()` would
+ * quietly operate on whatever directory the session happens to sit in. A caller
+ * that asks for the root wants the session's repository or nothing.
+ */
+declare function requireHarnessRoot(state?: Pick<HarnessState, 'root'>): string;
+/** The root and the run's scratch directory, for callers that write to disk. */
+declare function requireHarnessPaths(state?: Pick<HarnessState, 'root' | 'temporaryDirectory'>): {
+  root: string;
+  temporaryDirectory: string;
+};
+//#endregion
+export { disposeHarnessState as a, harnessRoot as c, requireHarnessRoot as d, resetHarnessStore as f, LoadedHarnessState as g, updateHarnessState as h, createHarnessSession as i, loadHarnessState as l, snapshotHarnessState as m, HarnessStateFile as n, getHarnessState as o, restoreHarnessStateSnapshot as p, HarnessStateTransactionSnapshot as r, getSessionHarnessState as s, HARNESS_STATE_POINTER as t, requireHarnessPaths as u };
+//# sourceMappingURL=index-DJpG-I9K.d.mts.map

package/dist/index-DJpG-I9K.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DJpG-I9K.d.mts","names":[],"sources":["../src/models/harnessCache.ts","../src/services/harnessStore/index.ts"],"mappings":";;;UAEiB;;EAEf;EACA;EACA,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCmCI;UAYI;EACf;EACA;IAAS;IAAa;;EACtB,OAAO;;UAGQ;WACN;WACA;WACA,OAAO;WACP,aAAa,SAAS;;;iBAIjB;;;;;;;;;;iBA0DA,iBACd,cAAa,OAAO,YACpB,SAAS,4BACR;;iBAwBa,qBAAqB,cAAa,OAAO,aAA2B;;iBAepE,4BACd,UAAU,iCACV,cAAa,OAAO;iBAiCN,gBAAgB,SAAS,4BAA4B;;;;;;;;iBAWrD,uBACd,+BACA,SAAS,4BACR;;;;;;;;;iBA6Ba,qBACd,OAAO,cACP;EACE;EACA,aAAa,OAAO;;;;;;;;EAQpB;;;;;;;;iBAmBY,mBACd,OAAO,QAAQ,eACf,cAAa,OAAO,aACnB;;iBAYa,oBAAoB,cAAa,OAAO;iBAQxC,YAAY,QAAO,KAAK;;;;;;;;;iBAYxB,mBAAmB,QAAO,KAAK;;iBAM/B,oBAAoB,QAAO,KAAK;EAC9C;EACA"}

package/dist/index-DNk4q0Qm.d.mts

@@ -0,0 +1,81 @@
+import { i as PersonaVoiceOverride, r as PersonaIdentity } from "./profiles-CTrUCmIh.mjs";
+//#region src/services/profileBinding/type.d.ts
+/** Nonsecret references to fields of existing provider credentials. */
+interface ProfileSecretReference {
+  readonly credentialId: string;
+  readonly field: string;
+  /** Exact HTTP(S) origins permitted to receive this field through a browser. */
+  readonly allowedOrigins: readonly string[];
+}
+interface ProfileBrowserBinding {
+  /** Persistent browser profile name, never a caller-supplied filesystem path. */
+  readonly profileName: string;
+  readonly allowedOrigins: readonly string[];
+}
+/** Metadata only. Authentication and resolved secret values belong to the session provider. */
+interface ProfileIntegrationBinding {
+  readonly provider: string;
+  readonly organizationId: string;
+  readonly mailboxId: string;
+  readonly credentialRef: string;
+  readonly secrets: Readonly<Record<string, ProfileSecretReference>>;
+  readonly browser?: ProfileBrowserBinding;
+}
+//#endregion
+//#region src/services/profiles/index.d.ts
+/** Files that make up one repository persona, concatenated in this order. */
+declare const PERSONA_FILES: string[];
+/** A persona's resolved presentation: display name, and an icon already read into a data URL. */
+interface AgentProfile {
+  name: string;
+  /** Directory relative to personaRoot, which remains the persona source. */
+  persona: string;
+  /**
+   * Root the persona path resolves against: the repository root for a
+   * repository profile, the global `.po` directory for a global one.
+   */
+  personaRoot: string;
+  /** Environment defaults. Values already exported by the caller win. */
+  env: Record<string, string>;
+  /** Nonsecret integration metadata. Resolved secrets never enter profile environment. */
+  integration?: ProfileIntegrationBinding;
+  /** Display name and avatar declared in the persona's own front-matter. */
+  identity?: PersonaIdentity;
+  /** Narrowly scoped TTS override declared alongside the identity. */
+  voice?: PersonaVoiceOverride;
+}
+/**
+ * Loads profiles from the global and repository configs, repository last.
+ *
+ * Configured roots accumulate and inspect themselves or their direct-child
+ * directories for persona files. Later discoveries replace earlier names, and
+ * explicit entries replace discoveries. Legacy flat profile mappings remain
+ * accepted as explicit entries.
+ */
+declare function loadProfiles(repoRoot: string, homeDirectory?: string): AgentProfile[];
+/**
+ * The profile catalog: every resolved profile, plus the name a launch starts on
+ * when the caller names none.
+ *
+ * `defaultProfile` mirrors `defaultMajorMode` in modes.yaml and `defaultDomains`
+ * in domains.yaml, so each selection axis declares its default in its own
+ * catalog. A repository declaration replaces a personal one. An unknown name is
+ * an error rather than a silent fallback: a typo that quietly starts the session
+ * with no persona is worse than a refused launch.
+ */
+declare function loadProfileCatalog(repoRoot: string, homeDirectory?: string): {
+  profiles: AgentProfile[];
+  defaultProfile?: string;
+};
+/** Resolves one selected profile and fails clearly when its name is unknown. */
+declare function resolveProfile(repoRoot: string, name: string, homeDirectory?: string): AgentProfile;
+declare function listProfileNames(repoRoot: string, homeDirectory?: string): string[];
+/** Builds the persona system-prompt block, or undefined when nothing is readable. */
+declare function buildPersonaPrompt(personaRoot: string, personaDirectory: string): string | undefined;
+/** Applies profile environment defaults and returns only the values it contributed. */
+declare function applyProfileEnvironment(environment: NodeJS.ProcessEnv, defaults: Record<string, string>): Record<string, string>;
+/** Replaces environment defaults previously contributed by another profile. */
+declare function replaceProfileEnvironment(environment: NodeJS.ProcessEnv, previous: Record<string, string>, next: Record<string, string>): Record<string, string>;
+//#endregion
+export { listProfileNames as a, replaceProfileEnvironment as c, ProfileIntegrationBinding as d, ProfileSecretReference as f, buildPersonaPrompt as i, resolveProfile as l, PERSONA_FILES as n, loadProfileCatalog as o, applyProfileEnvironment as r, loadProfiles as s, AgentProfile as t, ProfileBrowserBinding as u };
+//# sourceMappingURL=index-DNk4q0Qm.d.mts.map

package/dist/index-DNk4q0Qm.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DNk4q0Qm.d.mts","names":[],"sources":["../src/services/profileBinding/type.ts","../src/services/profiles/index.ts"],"mappings":";;;UACiB;WACN;WACA;;WAEA;;UAGM;;WAEN;WACA;;;UAIM;WACN;WACA;WACA;WACA;WACA,SAAS,SAAS,eAAe;WACjC,UAAU;;;;;cCRR;;UAOI;EACf;;EAEA;;;;;EAKA;;EAEA,KAAK;;EAEL,cAAc;;EAEd,WAAW;;EAEX,QAAQ;;;;;;;;;;iBAwNM,aAAa,kBAAkB,yBAAuC;;;;;;;;;;;iBA6BtE,mBACd,kBACA;EACG,UAAU;EAAgB;;;iBAcf,eAAe,kBAAkB,cAAc,yBAAyB;iBAMxE,iBAAiB,kBAAkB;;iBA2CnC,mBAAmB,qBAAqB;;iBAuBxC,wBACd,aAAa,OAAO,YACpB,UAAU,yBACT;;iBAWa,0BACd,aAAa,OAAO,YACpB,UAAU,wBACV,MAAM,yBACL"}

package/dist/index.cjs

@@ -0,0 +1,121 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_atomicJson = require("./atomicJson-Dt2z_DXl.cjs");
+const require_configPolicy = require("./configPolicy-DmsZEp0t.cjs");
+const require_config = require("./config-BUw5kHsx.cjs");
+const require_configWriter = require("./configWriter-BTuinLjs.cjs");
+const require_layeredConfig = require("./layeredConfig-DdI5ysUf.cjs");
+const require_domains = require("./domains-CBYkuxs5.cjs");
+const require_harnessState = require("./harnessState-CCyBeutB.cjs");
+const require_harnessStore = require("./harnessStore-CJSxdSkV.cjs");
+const require_piConfig = require("./piConfig-CCBdZXQr.cjs");
+const require_init = require("./init-C_9nyp3-.cjs");
+const require_majorModes = require("./majorModes-DPhVMuhT.cjs");
+const require_profiles = require("./profiles-DnF9DBpd.cjs");
+require("./config-zZz80Mh5.cjs");
+const require_sessionConfig = require("./sessionConfig-Boh4Fdje.cjs");
+let _agimon_ai_po_core_config = require("@agimon-ai/po-core/config");
+exports.DEFAULT_IMAGE_MAX_DIMENSION = require_piConfig.DEFAULT_IMAGE_MAX_DIMENSION;
+exports.DOOM_CONFIG_ENTRY_TYPE = require_sessionConfig.DOOM_CONFIG_ENTRY_TYPE;
+Object.defineProperty(exports, "DOOM_CONFIG_SERVICE", {
+	enumerable: true,
+	get: function() {
+		return _agimon_ai_po_core_config.DOOM_CONFIG_SERVICE;
+	}
+});
+exports.DOOM_CONFIG_TEMPLATES = require_init.DOOM_CONFIG_TEMPLATES;
+exports.DOOM_CONFIG_TRANSITION_ENTRY_TYPE = require_sessionConfig.DOOM_CONFIG_TRANSITION_ENTRY_TYPE;
+exports.DOOM_DIR = require_layeredConfig.DOOM_DIR;
+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.FILE_ONLY_STATE_FIELDS = require_harnessState.FILE_ONLY_STATE_FIELDS;
+exports.GLOBAL_DOOM_SEED_FILES = require_init.GLOBAL_DOOM_SEED_FILES;
+exports.HARNESS_STATE_KEYS = require_harnessState.HARNESS_STATE_KEYS;
+exports.HARNESS_STATE_POINTER = require_harnessStore.HARNESS_STATE_POINTER;
+exports.MARKETPLACE_MANIFEST_RELATIVE_PATHS = require_domains.MARKETPLACE_MANIFEST_RELATIVE_PATHS;
+exports.MIN_IMAGE_MAX_DIMENSION = require_piConfig.MIN_IMAGE_MAX_DIMENSION;
+exports.PERSONA_FILES = require_profiles.PERSONA_FILES;
+exports.REPOSITORY_DOOM_CONFIG_TEMPLATES = require_init.REPOSITORY_DOOM_CONFIG_TEMPLATES;
+exports.acknowledgeDoomConfigTransition = require_sessionConfig.acknowledgeDoomConfigTransition;
+exports.appendDoomConfigSelection = require_sessionConfig.appendDoomConfigSelection;
+exports.appendDoomConfigTransition = require_sessionConfig.appendDoomConfigTransition;
+exports.applyProfileEnvironment = require_profiles.applyProfileEnvironment;
+exports.buildPersonaPrompt = require_profiles.buildPersonaPrompt;
+exports.clampImageMaxDimension = require_piConfig.clampImageMaxDimension;
+exports.configLeafKeys = require_configPolicy.configLeafKeys;
+exports.configRootKeys = require_configPolicy.configRootKeys;
+exports.configScopeOf = require_configPolicy.configScopeOf;
+exports.createDoomConfigContext = require_sessionConfig.createDoomConfigContext;
+exports.createDoomConfigContextAsync = require_sessionConfig.createDoomConfigContextAsync;
+exports.createHarnessSession = require_harnessStore.createHarnessSession;
+exports.disposeHarnessState = require_harnessStore.disposeHarnessState;
+exports.domainCompletionItems = require_domains.domainCompletionItems;
+exports.domainCompletionPrefix = require_domains.domainCompletionPrefix;
+exports.expandDomainNames = require_domains.expandDomainNames;
+exports.findPluginManifestPath = require_domains.findPluginManifestPath;
+exports.freezeDoomConfigContext = require_sessionConfig.freezeDoomConfigContext;
+exports.getHarnessState = require_harnessStore.getHarnessState;
+exports.getSessionHarnessState = require_harnessStore.getSessionHarnessState;
+exports.globalDoomConfigDirectory = require_config.globalDoomConfigDirectory;
+exports.globalDoomConfigPath = require_config.globalDoomConfigPath;
+exports.harnessRoot = require_harnessStore.harnessRoot;
+exports.initializeGlobalDoomConfig = require_init.initializeGlobalDoomConfig;
+exports.initializeRepositoryDoomConfig = require_init.initializeRepositoryDoomConfig;
+exports.isLocalPackageSpecifier = require_majorModes.isLocalPackageSpecifier;
+exports.isRemotePluginSource = require_domains.isRemotePluginSource;
+exports.layerEntries = require_majorModes.layerEntries;
+exports.layerHookGroups = require_majorModes.layerHookGroups;
+exports.listDomainNames = require_domains.listDomainNames;
+exports.listProfileNames = require_profiles.listProfileNames;
+exports.loadDomains = require_domains.loadDomains;
+exports.loadDoomConfig = require_config.loadDoomConfig;
+exports.loadDoomConfigAsync = require_config.loadDoomConfigAsync;
+exports.loadDoomConfigLayers = require_config.loadDoomConfigLayers;
+exports.loadDoomConfigLenient = require_config.loadDoomConfigLenient;
+exports.loadHarnessState = require_harnessStore.loadHarnessState;
+exports.loadMajorModesConfig = require_majorModes.loadMajorModesConfig;
+exports.loadMajorModesConfigLenient = require_majorModes.loadMajorModesConfigLenient;
+exports.loadPiConfig = require_piConfig.loadPiConfig;
+exports.loadPiConfigAsync = require_piConfig.loadPiConfigAsync;
+exports.loadPiImageSettings = require_piConfig.loadPiImageSettings;
+exports.loadProfiles = require_profiles.loadProfiles;
+exports.mergeDoomConfigs = require_configPolicy.mergeDoomConfigs;
+exports.parseAutocompactModeConfig = require_configPolicy.parseAutocompactModeConfig;
+exports.parseDoomConfig = require_configPolicy.parseDoomConfig;
+exports.parsePiImageSettings = require_piConfig.parsePiImageSettings;
+exports.parsePlanningModeConfig = require_configPolicy.parsePlanningModeConfig;
+exports.piConfigPaths = require_piConfig.piConfigPaths;
+exports.piImageSettingsPath = require_piConfig.piImageSettingsPath;
+exports.pluginDirectoryForSource = require_domains.pluginDirectoryForSource;
+exports.projectHarnessEnvironment = require_harnessState.projectHarnessEnvironment;
+exports.provideDoomConfigContext = require_sessionConfig.provideDoomConfigContext;
+exports.readDoomConfigContextGeneration = require_sessionConfig.readDoomConfigContextGeneration;
+exports.readDoomConfigPendingSelection = require_sessionConfig.readDoomConfigPendingSelection;
+exports.readDoomConfigSelection = require_sessionConfig.readDoomConfigSelection;
+exports.readHarnessState = require_harnessState.readHarnessState;
+exports.replaceDoomConfigContext = require_sessionConfig.replaceDoomConfigContext;
+exports.replaceProfileEnvironment = require_profiles.replaceProfileEnvironment;
+exports.repositoryDoomConfigPath = require_config.repositoryDoomConfigPath;
+exports.requireDoomConfigContext = require_sessionConfig.requireDoomConfigContext;
+exports.requireHarnessPaths = require_harnessStore.requireHarnessPaths;
+exports.requireHarnessRoot = require_harnessStore.requireHarnessRoot;
+exports.resetHarnessStore = require_harnessStore.resetHarnessStore;
+exports.resolveLayers = require_majorModes.resolveLayers;
+exports.resolvePackageConfigurations = require_majorModes.resolvePackageConfigurations;
+exports.resolvePlanningPlansDirectory = require_config.resolvePlanningPlansDirectory;
+exports.resolvePluginDirectories = require_domains.resolvePluginDirectories;
+exports.resolvePluginEntries = require_domains.resolvePluginEntries;
+exports.resolveProfile = require_profiles.resolveProfile;
+exports.resolveSharedSkills = require_domains.resolveSharedSkills;
+exports.resolveVoiceConfig = require_configPolicy.resolveVoiceConfig;
+exports.restoreHarnessStateSnapshot = require_harnessStore.restoreHarnessStateSnapshot;
+exports.savePiImageSettings = require_piConfig.savePiImageSettings;
+exports.setDoomConfigValue = require_configWriter.setDoomConfigValue;
+exports.snapshotHarnessState = require_harnessStore.snapshotHarnessState;
+exports.supersedeDoomConfigTransition = require_sessionConfig.supersedeDoomConfigTransition;
+exports.unsetDoomConfigValue = require_configWriter.unsetDoomConfigValue;
+exports.updateHarnessState = require_harnessStore.updateHarnessState;
+exports.valueAtKeyPath = require_configPolicy.valueAtKeyPath;
+exports.writeDoomConfigValues = require_configWriter.writeDoomConfigValues;
+exports.writePrivateAtomicJson = require_atomicJson.writePrivateAtomicJson;

package/dist/index.d.mts

@@ -0,0 +1,15 @@
+import { t as writePrivateAtomicJson } from "./index-C6GaYjq-.mjs";
+import { A as PluginHookSource, B as VoiceTtsConfig, C as IDoomConfigService, D as PlanningAgentConfig, E as PackageAttribution, F as VoiceAutoCaptureConfig, I as VoiceConfig, L as VoiceEngine, M as ResolvedVoiceAutoCaptureConfig, N as ResolvedVoiceConfig, O as PlanningModeConfig, P as VoiceAdapterConfig, R as VoiceMode, S as IDoomConfigLoader, V as VoiceTtsEngine, _ as DoomConfigTransitionStrategy, b as EditorConfig, c as DeepReadonly, d as DoomConfigLayer, f as DoomConfigLayers, g as DoomConfigTransitionRecord, h as DoomConfigTransitionPhase, i as AutocompactTokenConfig, j as ProjectTrust, k as PlanningThinkingLevel, l as DoomConfig, n as AutocompactOverrideConfig, o as ConfigValueOrigin, p as DoomConfigPendingSelection, r as AutocompactThresholdConfig, s as DOOM_CONFIG_SERVICE, t as AutocompactModeConfig, u as DoomConfigContext, v as DoomHarnessContext, x as HarnessState, y as DoomSelectionConfig, z as VoiceModelConfig } 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";
+import { a as PiConfigPaths, i as PiConfigLoadOptions, r as PiConfig, t as ConfigAdapterRegistrationOptions } from "./piConfig-Bx26HMb_.mjs";
+import { a as unsetDoomConfigValue, i as setDoomConfigValue, n as DoomConfigScope, o as writeDoomConfigValues, r as WriteDoomConfigOptions, t as DoomConfigEdit } from "./index-Cvdt-Y-i.mjs";
+import { C as PluginCatalog, D as PluginSkillDiscovery, E as PluginManifestMetadata, O as PluginSource, S as NpmPluginSource, T as PluginEntry, _ as DomainManifest, a as domainCompletionItems, b as GitPluginSource, d as listDomainNames, f as loadDomains, g as DomainDefinition, h as resolveSharedSkills, i as pluginDirectoryForSource, k as ResolvedDomain, m as resolvePluginEntries, n as findPluginManifestPath, o as domainCompletionPrefix, p as resolvePluginDirectories, r as isRemotePluginSource, s as expandDomainNames, t as MARKETPLACE_MANIFEST_RELATIVE_PATHS, v as DomainMcpAllowlist, w as PluginCatalogEntry, x as LocalPluginSource, y as DomainPlugin } from "./index-BT29GZx5.mjs";
+import { t as DOOM_DIR } from "./index-Ch7ptOkW.mjs";
+import { a as readHarnessState, i as projectHarnessEnvironment, n as HARNESS_STATE_KEYS, r as HarnessStateParseReporter, t as FILE_ONLY_STATE_FIELDS } from "./index-CIQrKS1A.mjs";
+import { a as disposeHarnessState, c as harnessRoot, d as requireHarnessRoot, f as resetHarnessStore, g as LoadedHarnessState, h as updateHarnessState, i as createHarnessSession, l as loadHarnessState, m as snapshotHarnessState, n as HarnessStateFile, o as getHarnessState, p as restoreHarnessStateSnapshot, r as HarnessStateTransactionSnapshot, s as getSessionHarnessState, t as HARNESS_STATE_POINTER, u as requireHarnessPaths } from "./index-DJpG-I9K.mjs";
+import { a as piImageSettingsPath, c as MIN_IMAGE_MAX_DIMENSION, d as clampImageMaxDimension, f as parsePiImageSettings, i as piConfigPaths, l as PiImageSettings, n as loadPiConfigAsync, o as savePiImageSettings, r as loadPiImageSettings, s as DEFAULT_IMAGE_MAX_DIMENSION, t as loadPiConfig, u as PiImageSettingsUpdate } from "./index-CVlciCJF.mjs";
+import { a as REPOSITORY_DOOM_CONFIG_TEMPLATES, c as initializeGlobalDoomConfig, i as GlobalDoomInitResult, l as initializeRepositoryDoomConfig, n as GLOBAL_DOOM_SEED_FILES, o as RepositoryDoomInitOptions, s as RepositoryDoomInitResult, t as DOOM_CONFIG_TEMPLATES } from "./index-CRcoVYXz.mjs";
+import { a as MajorModeDefinition, c as ResolvedPackageConfiguration, d as layerEntries, f as layerHookGroups, g as resolvePackageConfigurations, h as resolveLayers, i as LayerResolvers, m as loadMajorModesConfigLenient, n as LayerPackage, o as MajorModesConfig, p as loadMajorModesConfig, r as LayerPackageConfig, s as ResolvedLayerDefinition, t as LayerDefinition, u as isLocalPackageSpecifier } from "./index-CeOk2kqs.mjs";
+import { a as listProfileNames, c as replaceProfileEnvironment, i as buildPersonaPrompt, l as resolveProfile, n as PERSONA_FILES, r as applyProfileEnvironment, s as loadProfiles, t as AgentProfile } from "./index-DNk4q0Qm.mjs";
+import { _ as supersedeDoomConfigTransition, a as appendDoomConfigSelection, c as createDoomConfigContextAsync, d as provideDoomConfigContext, f as readDoomConfigContextGeneration, g as requireDoomConfigContext, h as replaceDoomConfigContext, i as acknowledgeDoomConfigTransition, l as freezeDoomConfigContext, m as readDoomConfigSelection, n as DOOM_CONFIG_TRANSITION_ENTRY_TYPE, o as appendDoomConfigTransition, p as readDoomConfigPendingSelection, r as DoomConfigSelection, s as createDoomConfigContext, t as DOOM_CONFIG_ENTRY_TYPE } from "./index-BAaTySaM.mjs";
+export { type AgentProfile, type AutocompactModeConfig, type AutocompactOverrideConfig, type AutocompactThresholdConfig, type AutocompactTokenConfig, type ConfigAdapterRegistrationOptions, type ConfigKeyScope, type ConfigValueOrigin, DEFAULT_IMAGE_MAX_DIMENSION, DOOM_CONFIG_ENTRY_TYPE, DOOM_CONFIG_SERVICE, DOOM_CONFIG_TEMPLATES, DOOM_CONFIG_TRANSITION_ENTRY_TYPE, DOOM_DIR, DOOM_PLANNING_THINKING_LEVELS, DOOM_VOICE_ENGINES, DOOM_VOICE_MODES, DOOM_VOICE_TTS_ENGINES, type DeepReadonly, type DomainDefinition, type DomainManifest, type DomainMcpAllowlist, type DomainPlugin, type DoomConfig, type DoomConfigContext, type DoomConfigEdit, type DoomConfigLayer, type DoomConfigLayers, type DoomConfigPendingSelection, type DoomConfigScope, type DoomConfigSelection, type DoomConfigTransitionPhase, type DoomConfigTransitionRecord, type DoomConfigTransitionStrategy, type DoomHarnessContext, type DoomSelectionConfig, type EditorConfig, FILE_ONLY_STATE_FIELDS, GLOBAL_DOOM_SEED_FILES, type GitPluginSource, type GlobalDoomInitResult, HARNESS_STATE_KEYS, HARNESS_STATE_POINTER, type HarnessState, type HarnessStateFile, type HarnessStateParseReporter, type HarnessStateTransactionSnapshot, type IDoomConfigLoader, type IDoomConfigService, type LayerDefinition, type LayerPackage, type LayerPackageConfig, type LayerResolvers, type LoadedHarnessState, type LocalPluginSource, MARKETPLACE_MANIFEST_RELATIVE_PATHS, MIN_IMAGE_MAX_DIMENSION, type MajorModeDefinition, type MajorModesConfig, type NpmPluginSource, PERSONA_FILES, type PackageAttribution, type PiConfig, type PiConfigLoadOptions, type PiConfigPaths, type PiImageSettings, type PiImageSettingsUpdate, type PlanningAgentConfig, type PlanningModeConfig, type PlanningThinkingLevel, type PluginCatalog, type PluginCatalogEntry, type PluginEntry, type PluginHookSource, type PluginManifestMetadata, type PluginSkillDiscovery, type PluginSource, type ProjectTrust, REPOSITORY_DOOM_CONFIG_TEMPLATES, type RepositoryDoomInitOptions, type RepositoryDoomInitResult, type ResolvedDomain, type ResolvedLayerDefinition, type ResolvedPackageConfiguration, type ResolvedVoiceAutoCaptureConfig, type ResolvedVoiceConfig, type VoiceAdapterConfig, type VoiceAutoCaptureConfig, type VoiceConfig, type VoiceEngine, type VoiceMode, type VoiceModelConfig, type VoiceTtsConfig, type VoiceTtsEngine, type WriteDoomConfigOptions, acknowledgeDoomConfigTransition, appendDoomConfigSelection, appendDoomConfigTransition, applyProfileEnvironment, buildPersonaPrompt, clampImageMaxDimension, configLeafKeys, configRootKeys, configScopeOf, createDoomConfigContext, createDoomConfigContextAsync, createHarnessSession, disposeHarnessState, domainCompletionItems, domainCompletionPrefix, expandDomainNames, findPluginManifestPath, freezeDoomConfigContext, getHarnessState, getSessionHarnessState, globalDoomConfigDirectory, globalDoomConfigPath, harnessRoot, initializeGlobalDoomConfig, initializeRepositoryDoomConfig, isLocalPackageSpecifier, isRemotePluginSource, layerEntries, layerHookGroups, listDomainNames, listProfileNames, loadDomains, loadDoomConfig, loadDoomConfigAsync, loadDoomConfigLayers, loadDoomConfigLenient, loadHarnessState, loadMajorModesConfig, loadMajorModesConfigLenient, loadPiConfig, loadPiConfigAsync, loadPiImageSettings, loadProfiles, mergeDoomConfigs, parseAutocompactModeConfig, parseDoomConfig, parsePiImageSettings, parsePlanningModeConfig, piConfigPaths, piImageSettingsPath, pluginDirectoryForSource, projectHarnessEnvironment, provideDoomConfigContext, readDoomConfigContextGeneration, readDoomConfigPendingSelection, readDoomConfigSelection, readHarnessState, replaceDoomConfigContext, replaceProfileEnvironment, repositoryDoomConfigPath, requireDoomConfigContext, requireHarnessPaths, requireHarnessRoot, resetHarnessStore, resolveLayers, resolvePackageConfigurations, resolvePlanningPlansDirectory, resolvePluginDirectories, resolvePluginEntries, resolveProfile, resolveSharedSkills, resolveVoiceConfig, restoreHarnessStateSnapshot, savePiImageSettings, setDoomConfigValue, snapshotHarnessState, supersedeDoomConfigTransition, unsetDoomConfigValue, updateHarnessState, valueAtKeyPath, writeDoomConfigValues, writePrivateAtomicJson };

package/dist/index.mjs

@@ -0,0 +1,15 @@
+import { t as writePrivateAtomicJson } from "./atomicJson-1W0WhuFF.mjs";
+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";
+import { n as unsetDoomConfigValue, r as writeDoomConfigValues, t as setDoomConfigValue } from "./configWriter-BgkGaLrf.mjs";
+import { t as DOOM_DIR } from "./layeredConfig-B922ibgn.mjs";
+import { a as loadDomains, c as resolveSharedSkills, d as expandDomainNames, f as MARKETPLACE_MANIFEST_RELATIVE_PATHS, h as pluginDirectoryForSource, i as listDomainNames, l as domainCompletionItems, m as isRemotePluginSource, o as resolvePluginDirectories, p as findPluginManifestPath, s as resolvePluginEntries, u as domainCompletionPrefix } from "./domains-DZOu9vYM.mjs";
+import { i as readHarnessState, n as HARNESS_STATE_KEYS, r as projectHarnessEnvironment, t as FILE_ONLY_STATE_FIELDS } from "./harnessState-Dn_S7fB9.mjs";
+import { a as getSessionHarnessState, c as requireHarnessPaths, d as restoreHarnessStateSnapshot, f as snapshotHarnessState, i as getHarnessState, l as requireHarnessRoot, n as createHarnessSession, o as harnessRoot, p as updateHarnessState, r as disposeHarnessState, s as loadHarnessState, t as HARNESS_STATE_POINTER, u as resetHarnessStore } from "./harnessStore-CltwLB7M.mjs";
+import { a as piImageSettingsPath, c as MIN_IMAGE_MAX_DIMENSION, i as piConfigPaths, l as clampImageMaxDimension, n as loadPiConfigAsync, o as savePiImageSettings, r as loadPiImageSettings, s as DEFAULT_IMAGE_MAX_DIMENSION, t as loadPiConfig, u as parsePiImageSettings } from "./piConfig-qGyCbcVj.mjs";
+import { a as initializeRepositoryDoomConfig, i as initializeGlobalDoomConfig, n as GLOBAL_DOOM_SEED_FILES, r as REPOSITORY_DOOM_CONFIG_TEMPLATES, t as DOOM_CONFIG_TEMPLATES } from "./init-DJ6wm-dr.mjs";
+import { a as loadMajorModesConfig, c as resolvePackageConfigurations, i as layerHookGroups, n as isLocalPackageSpecifier, o as loadMajorModesConfigLenient, r as layerEntries, s as resolveLayers } from "./majorModes-CmPLEpMT.mjs";
+import { c as resolveProfile, i as listProfileNames, n as applyProfileEnvironment, o as loadProfiles, r as buildPersonaPrompt, s as replaceProfileEnvironment, t as PERSONA_FILES } from "./profiles-fujQKrS0.mjs";
+import { t as DOOM_CONFIG_SERVICE } from "./config-NSHRd6na.mjs";
+import { _ as supersedeDoomConfigTransition, a as appendDoomConfigTransition, d as provideDoomConfigContext, f as readDoomConfigContextGeneration, g as requireDoomConfigContext, h as replaceDoomConfigContext, i as appendDoomConfigSelection, l as freezeDoomConfigContext, m as readDoomConfigSelection, n as DOOM_CONFIG_TRANSITION_ENTRY_TYPE, o as createDoomConfigContext, p as readDoomConfigPendingSelection, r as acknowledgeDoomConfigTransition, s as createDoomConfigContextAsync, t as DOOM_CONFIG_ENTRY_TYPE } from "./sessionConfig-CtLoc-lO.mjs";
+export { DEFAULT_IMAGE_MAX_DIMENSION, DOOM_CONFIG_ENTRY_TYPE, DOOM_CONFIG_SERVICE, DOOM_CONFIG_TEMPLATES, DOOM_CONFIG_TRANSITION_ENTRY_TYPE, DOOM_DIR, DOOM_PLANNING_THINKING_LEVELS, DOOM_VOICE_ENGINES, DOOM_VOICE_MODES, DOOM_VOICE_TTS_ENGINES, FILE_ONLY_STATE_FIELDS, GLOBAL_DOOM_SEED_FILES, HARNESS_STATE_KEYS, HARNESS_STATE_POINTER, MARKETPLACE_MANIFEST_RELATIVE_PATHS, MIN_IMAGE_MAX_DIMENSION, PERSONA_FILES, REPOSITORY_DOOM_CONFIG_TEMPLATES, acknowledgeDoomConfigTransition, appendDoomConfigSelection, appendDoomConfigTransition, applyProfileEnvironment, buildPersonaPrompt, clampImageMaxDimension, configLeafKeys, configRootKeys, configScopeOf, createDoomConfigContext, createDoomConfigContextAsync, createHarnessSession, disposeHarnessState, domainCompletionItems, domainCompletionPrefix, expandDomainNames, findPluginManifestPath, freezeDoomConfigContext, getHarnessState, getSessionHarnessState, globalDoomConfigDirectory, globalDoomConfigPath, harnessRoot, initializeGlobalDoomConfig, initializeRepositoryDoomConfig, isLocalPackageSpecifier, isRemotePluginSource, layerEntries, layerHookGroups, listDomainNames, listProfileNames, loadDomains, loadDoomConfig, loadDoomConfigAsync, loadDoomConfigLayers, loadDoomConfigLenient, loadHarnessState, loadMajorModesConfig, loadMajorModesConfigLenient, loadPiConfig, loadPiConfigAsync, loadPiImageSettings, loadProfiles, mergeDoomConfigs, parseAutocompactModeConfig, parseDoomConfig, parsePiImageSettings, parsePlanningModeConfig, piConfigPaths, piImageSettingsPath, pluginDirectoryForSource, projectHarnessEnvironment, provideDoomConfigContext, readDoomConfigContextGeneration, readDoomConfigPendingSelection, readDoomConfigSelection, readHarnessState, replaceDoomConfigContext, replaceProfileEnvironment, repositoryDoomConfigPath, requireDoomConfigContext, requireHarnessPaths, requireHarnessRoot, resetHarnessStore, resolveLayers, resolvePackageConfigurations, resolvePlanningPlansDirectory, resolvePluginDirectories, resolvePluginEntries, resolveProfile, resolveSharedSkills, resolveVoiceConfig, restoreHarnessStateSnapshot, savePiImageSettings, setDoomConfigValue, snapshotHarnessState, supersedeDoomConfigTransition, unsetDoomConfigValue, updateHarnessState, valueAtKeyPath, writeDoomConfigValues, writePrivateAtomicJson };