@tekmidian/pai 0.49.0 → 0.51.0

package/dist/config-Bn9jpblO.mjs

@@ -0,0 +1,653 @@
+import { a as paiHomePath, o as resolvePaiFile, r as migratePaiFile } from "./pai-home-ChAOupZc.mjs";
+import { i as paiSocketPath } from "./runtime-paths-B0P1TvUr.mjs";
+import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir, userInfo } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { Document, YAMLMap, parseDocument } from "yaml";
+
+//#region src/notifications/types.ts
+const DEFAULT_ROUTING = {
+	error: [
+		"whatsapp",
+		"macos",
+		"ntfy",
+		"cli"
+	],
+	completion: [
+		"whatsapp",
+		"macos",
+		"ntfy",
+		"cli"
+	],
+	info: ["cli"],
+	progress: ["cli"],
+	debug: []
+};
+const DEFAULT_CHANNELS = {
+	ntfy: {
+		enabled: false,
+		url: void 0,
+		priority: "default"
+	},
+	whatsapp: {
+		enabled: true,
+		recipient: void 0
+	},
+	macos: { enabled: true },
+	voice: {
+		enabled: false,
+		voiceName: "bm_george"
+	},
+	cli: { enabled: true }
+};
+const DEFAULT_NOTIFICATION_CONFIG = {
+	mode: "auto",
+	channels: DEFAULT_CHANNELS,
+	routing: DEFAULT_ROUTING
+};
+
+//#endregion
+//#region src/tasks/types.ts
+/**
+* Prefix marking a tracker label as a PAI ownership assertion.
+* A task labelled `pai:acme-api` is owned by the `acme-api` project.
+*/
+const OWNER_LABEL_PREFIX = "pai:";
+/** An unresolved owner. UNROUTED is a normal state, not an error. */
+const UNROUTED = {
+	project: null,
+	rootPath: null,
+	source: "none"
+};
+const DEFAULT_TASK_CONFIG = {
+	enabled: false,
+	providers: { todoist: { enabled: false } },
+	autoDispatch: false
+};
+
+//#endregion
+//#region src/config/json-store.ts
+/**
+* json-store.ts — read/write JSON config files without destroying them
+*
+* The failure this exists to prevent:
+*
+*     try { return JSON.parse(read(path)); } catch { return {}; }
+*     ... later ...
+*     write(path, JSON.stringify(ourData));
+*
+* An unreadable file becomes an empty object, and the next write makes that
+* permanent. Silently, exit code 0. This shape appeared three times in this
+* repo against three different files, and twice in AIBroker.
+*
+* The distinction that matters is between *missing* and *unreadable*:
+*
+*   missing     — legitimate first run. Start fresh; writing is safe.
+*   unreadable  — the file exists and we could not parse it. Those bytes are
+*                 the only copy of something. Never overwrite them.
+*
+* Collapsing the second into the first is the bug.
+*
+* NOT everything deserves this guard. For a transient buffer — an undelivered
+* message queue, a cache — starting fresh IS the correct recovery, and
+* refusing to write would disable the feature permanently. Use `writeJsonAtomic`
+* alone there: it still prevents a crash from truncating a good file, without
+* blocking recovery. Reserve `readJsonStrict` for data a user cannot rebuild.
+*/
+/**
+* Read a JSON file, distinguishing "absent" from "damaged".
+*
+* @param path   file to read
+* @param label  how to name it to the user, e.g. "~/.claude.json"
+* @throws if the file exists but cannot be read or parsed
+*/
+function readJsonStrict(path, label = path) {
+	if (!existsSync(path)) return {};
+	let raw;
+	try {
+		raw = readFileSync(path, "utf8");
+	} catch (e) {
+		throw new Error(`Could not read ${label}: ${e instanceof Error ? e.message : String(e)}\nRefusing to continue — writing now would replace its contents with ours alone.`);
+	}
+	try {
+		return JSON.parse(raw);
+	} catch (e) {
+		throw new Error(`${label} exists but is not valid JSON: ${e instanceof Error ? e.message : String(e)}\nRefusing to continue — overwriting it would destroy whatever it holds.\nRepair the file, or move it aside and re-run this command.`);
+	}
+}
+/**
+* Leaf values that mean "type word", not data.
+*
+* A config whose top-level keys map to bare type words is a serialized schema,
+* not a configuration — the exact shape found over the live config on
+* 2026-09-18 (399 bytes: `socketPath: string`, `indexIntervalSecs: int`, …).
+* No real config carries three of these at its top level; a dump carries
+* nothing else.
+*/
+const SCHEMA_TYPE_WORDS = new Set([
+	"string",
+	"int",
+	"integer",
+	"number",
+	"bool",
+	"boolean",
+	"float",
+	"double",
+	"object",
+	"array",
+	"any",
+	"unknown"
+]);
+function schemaDumpHits(data) {
+	let hits = 0;
+	for (const v of Object.values(data)) if (typeof v === "string" && SCHEMA_TYPE_WORDS.has(v.trim())) hits += 1;
+	return hits;
+}
+/**
+* Write JSON without risking the existing file.
+*
+* Keeps a `.bak-pai` copy of the previous contents, then writes to a temp file
+* and renames. Rename is atomic within a filesystem, so a crash mid-write
+* leaves the original intact rather than truncated — which is how these files
+* become corrupt in the first place.
+*/
+function writeJsonAtomic(path, data, opts = {}) {
+	const { backup = true, label = path } = opts;
+	if (schemaDumpHits(data) >= 3) throw new Error(`${label}: refusing to write — the object looks like a type schema, not values (several top-level keys map to bare type words). That is the corruption signature of 2026-09-18: the caller serialized the schema instead of the config. Nothing was written.`);
+	const serialized = JSON.stringify(data, null, 2) + "\n";
+	const dir = dirname(path);
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	if (backup && existsSync(path)) try {
+		copyFileSync(path, `${path}.bak-pai`);
+	} catch (e) {
+		throw new Error(`Could not back up ${label}: ${e instanceof Error ? e.message : String(e)}\nRefusing to write without a backup.`);
+	}
+	const tmp = `${path}.tmp-pai-${process.pid}`;
+	try {
+		writeFileSync(tmp, serialized, "utf8");
+		renameSync(tmp, path);
+	} catch (e) {
+		try {
+			if (existsSync(tmp)) unlinkSync(tmp);
+		} catch {}
+		throw new Error(`Failed to write ${label}: ${e instanceof Error ? e.message : String(e)}\nThe original is unchanged.`);
+	}
+}
+
+//#endregion
+//#region src/config/yaml-store.ts
+/**
+* yaml-store.ts — generic, comment-preserving YAML file helpers shared by
+* every PAI config file that has a YAML form (config.yaml, voices.yaml;
+* workers.yaml keeps its own writer in workers-config.ts because it needs
+* provider-specific key-quoting, but its atomic-write tail is this module's
+* writeYamlFileAtomic).
+*/
+var YamlStoreError = class extends Error {};
+/**
+* Validate `text` parses as YAML, back up any existing file to `.bak-pai`,
+* then write via temp file + rename (atomic within a filesystem) at mode
+* 0600 — every PAI-owned YAML file can carry secrets, key or no key.
+*/
+function writeYamlFileAtomic(path, text, opts = {}) {
+	const label = opts.label ?? path;
+	const parsed = parseDocument(text);
+	if (parsed.errors.length) throw new YamlStoreError(`refusing to write ${label}: ${parsed.errors[0].message} (previous file left unchanged)`);
+	const dir = dirname(path);
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	if (existsSync(path)) try {
+		copyFileSync(path, `${path}.bak-pai`);
+	} catch (e) {
+		throw new YamlStoreError(`Could not back up ${label}: ${e instanceof Error ? e.message : String(e)}\nRefusing to write without a backup.`);
+	}
+	const tmp = `${path}.tmp-pai-${process.pid}`;
+	try {
+		writeFileSync(tmp, text, {
+			encoding: "utf8",
+			mode: 384
+		});
+		renameSync(tmp, path);
+		chmodSync(path, 384);
+	} catch (e) {
+		try {
+			if (existsSync(tmp)) unlinkSync(tmp);
+		} catch {}
+		throw new YamlStoreError(`Failed to write ${label}: ${e instanceof Error ? e.message : String(e)}`);
+	}
+}
+/** Deep-equal for plain JSON-shaped values (objects/arrays/scalars). */
+function deepEqualJson(a, b) {
+	return JSON.stringify(a) === JSON.stringify(b);
+}
+function isPlainObject(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/**
+* Apply the diff between `before` and `after` (arbitrary nested plain JSON
+* objects) onto a YAML Document, touching only the leaves/keys that actually
+* changed — this is what lets hand-written comments elsewhere in the file
+* survive a `set`/`unset`. Arrays and non-object values are replaced
+* wholesale when they differ; only plain objects are diffed key by key.
+*/
+function syncPlainObjectIntoYamlDoc(doc, before, after, path = []) {
+	if (isPlainObject(after) && isPlainObject(before)) {
+		for (const key of Object.keys(after)) syncPlainObjectIntoYamlDoc(doc, before[key], after[key], [...path, key]);
+		for (const key of Object.keys(before)) if (!(key in after)) doc.deleteIn([...path, key]);
+		return;
+	}
+	if (after === void 0) {
+		if (before !== void 0) doc.deleteIn(path);
+		return;
+	}
+	if (!deepEqualJson(before, after)) doc.setIn(path, after);
+}
+/**
+* Attach a `# text` comment directly above the key at `path` inside a YAML
+* Document — used for the annotated section headers `pai config yaml`
+* writes. No-op if the path does not resolve to a mapping entry (e.g. the
+* key was omitted from the document).
+*/
+function setYamlKeyComment(doc, path, text) {
+	const parentPath = path.slice(0, -1);
+	const lastKey = path[path.length - 1];
+	const parent = parentPath.length ? doc.getIn(parentPath, true) : doc.contents;
+	if (!(parent instanceof YAMLMap)) return;
+	const pair = parent.items.find((p) => p.key?.value === lastKey);
+	if (pair) pair.key.commentBefore = ` ${text}`;
+}
+
+//#endregion
+//#region src/config/main-config.ts
+/**
+* main-config.ts — the dual-format (config.yaml / config.json) engine behind
+* the main PAI config file. Deliberately has NO dependency on
+* src/daemon/config.ts (which owns path resolution, PaiDaemonConfig and
+* DEFAULTS) so that module can import this one for loadConfig() without a
+* cycle; every path this module touches is passed in explicitly.
+*
+* Precedence, same shape as workers.yaml/workers/config.ts: config.yaml wins
+* when it exists, config.json otherwise. `pai config yaml` (see
+* src/cli/commands/config.ts) performs the one-time JSON→YAML conversion;
+* every writer that goes through readMainConfigRaw/writeMainConfigRaw (see
+* src/daemon/config.ts) keeps working unmodified either way.
+*/
+var MainConfigError = class extends Error {};
+/** The config.yaml sibling of a given config.json path (same directory). */
+function yamlSiblingPath(jsonPath) {
+	return join(dirname(jsonPath), "config.yaml");
+}
+/** The path a user should be pointed at: config.yaml when it exists (same
+*  precedence as readDualFormatConfigRaw), else config.json. */
+function resolvedMainConfigPath(jsonPath, yamlPath = yamlSiblingPath(jsonPath)) {
+	return existsSync(yamlPath) ? yamlPath : jsonPath;
+}
+/**
+* Read the raw main config: config.yaml if it exists, else config.json
+* (readJsonStrict — missing is `{}`, damaged throws), matching
+* readWorkersSection's precedence for workers.yaml/JSON.
+*/
+function readDualFormatConfigRaw(jsonPath, yamlPath = yamlSiblingPath(jsonPath)) {
+	if (existsSync(yamlPath)) {
+		let text;
+		try {
+			text = readFileSync(yamlPath, "utf8");
+		} catch (e) {
+			throw new MainConfigError(`Could not read ${yamlPath}: ${e instanceof Error ? e.message : String(e)}`);
+		}
+		const doc = parseDocument(text);
+		if (doc.errors.length) throw new MainConfigError(`${yamlPath}: ${doc.errors[0].message}`);
+		const parsed = doc.toJS();
+		if (parsed === null || parsed === void 0) return {};
+		if (typeof parsed !== "object" || Array.isArray(parsed)) throw new MainConfigError(`${yamlPath}: top level must be a mapping`);
+		return parsed;
+	}
+	return readJsonStrict(jsonPath, jsonPath);
+}
+/**
+* Write the raw main config back: comment-preserving diff-sync into
+* config.yaml when it exists, else plain writeJsonAtomic to config.json —
+* this is the one seam every writer of the main config (CLI commands,
+* identity, notifications, setup, workers) routes through, so a config.yaml
+* on disk is honored no matter which of them made the change.
+*/
+function writeDualFormatConfigRaw(jsonPath, raw, yamlPath = yamlSiblingPath(jsonPath)) {
+	if (existsSync(yamlPath)) {
+		let text;
+		try {
+			text = readFileSync(yamlPath, "utf8");
+		} catch (e) {
+			throw new MainConfigError(`Could not read ${yamlPath}: ${e instanceof Error ? e.message : String(e)}`);
+		}
+		const doc = parseDocument(text);
+		if (doc.errors.length) throw new MainConfigError(`${yamlPath}: ${doc.errors[0].message}`);
+		syncPlainObjectIntoYamlDoc(doc, doc.toJS() ?? {}, raw);
+		try {
+			writeYamlFileAtomic(yamlPath, String(doc), { label: yamlPath });
+		} catch (e) {
+			throw new MainConfigError(e instanceof Error ? e.message : String(e));
+		}
+		return;
+	}
+	writeJsonAtomic(jsonPath, raw, { label: jsonPath });
+}
+/**
+* Short annotation for every top-level PaiDaemonConfig field, shown as a `#`
+* comment above the field in the generated config.yaml. Mirrors (and must be
+* kept in sync with) the doc comments on PaiDaemonConfig in
+* src/daemon/config.ts — kept as a separate short-form table rather than
+* parsed from the TS source at runtime.
+*/
+const MAIN_CONFIG_SECTION_COMMENTS = {
+	socketPath: "Unix Domain Socket path for daemon IPC.",
+	indexIntervalSecs: "How often the daemon re-indexes changed files, in seconds.",
+	embedIntervalSecs: "How often the daemon runs the embedding pass, in seconds.",
+	embedOnStartup: "Run an embed pass 60s after daemon start. Off by default: with a large backlog it makes every restart a CPU storm.",
+	maintenanceHour: "Local hour (0-23) to anchor the recurring index/embed cycle to, so maintenance runs in a fixed window.",
+	storageBackend: "Storage backend: \"sqlite\" (default) or \"postgres\".",
+	postgres: "PostgreSQL connection settings, used when storageBackend is \"postgres\".",
+	embeddingModel: "Embedding model name, used for semantic/hybrid search.",
+	logLevel: "Daemon log level: debug, info, warn, or error.",
+	vaultPath: "Obsidian vault root path for zettelkasten indexing, if any.",
+	vaultProjectId: "Registry project_id used for vault chunks in memory_chunks. Default: auto-detected.",
+	notifications: "Notification subsystem configuration.",
+	search: "Search defaults, applied when an MCP tool or CLI call doesn't specify one.",
+	tasks: "Task bus — optional external tracker for cross-session work.",
+	identity: "Who \"me\" is — addresses that count as the user's own. Empty by default and never guessed: nothing is self-addressed until this is set.",
+	workers: "Non-provider worker settings (pane, routing, tree, cache keepalive, fallback). Providers/classes/mcp_sets live in workers.yaml, not here."
+};
+/** Keys whose leading-underscore string value is a JSON stand-in for a
+*  comment (e.g. `"_comment": "..."`, `"_deliverToNote": "..."`). Stripped
+*  from the generated YAML and re-attached as a real `#` comment above the
+*  nearest remaining sibling key in the same object. */
+function isCommentKey(key) {
+	return key.startsWith("_");
+}
+/** Recursively strip `_`-prefixed comment keys out of a plain JSON value,
+*  returning the cleaned value plus where each stripped comment belongs. */
+function stripUnderscoreComments(value, path = []) {
+	if (Array.isArray(value)) {
+		const comments = [];
+		return {
+			cleaned: value.map((v, i) => {
+				const r = stripUnderscoreComments(v, [...path, i]);
+				comments.push(...r.comments);
+				return r.cleaned;
+			}),
+			comments
+		};
+	}
+	if (typeof value === "object" && value !== null) {
+		const obj = value;
+		const cleaned = {};
+		const comments = [];
+		const localComments = [];
+		for (const [k, v] of Object.entries(obj)) {
+			if (isCommentKey(k)) {
+				if (typeof v === "string" && v.trim()) localComments.push(v.trim());
+				continue;
+			}
+			const r = stripUnderscoreComments(v, [...path, k]);
+			cleaned[k] = r.cleaned;
+			comments.push(...r.comments);
+		}
+		const firstKey = Object.keys(cleaned)[0];
+		if (localComments.length && firstKey !== void 0) comments.unshift({
+			path: [...path, firstKey],
+			text: localComments.join(" ")
+		});
+		return {
+			cleaned,
+			comments
+		};
+	}
+	return {
+		cleaned: value,
+		comments: []
+	};
+}
+/**
+* `pai config yaml`: convert config.json to config.yaml. Strips `_`-prefixed
+* JSON-comment-workaround keys into real `#` comments, adds a short
+* annotation above every top-level section (MAIN_CONFIG_SECTION_COMMENTS),
+* verifies the generated YAML re-parses to the exact same data before
+* writing anything, then renames the JSON aside to
+* `config.json.migrated-<YYYY-MM-DD>` (never deleted). Refuses when
+* config.yaml already exists unless `force`. `dryRun` computes and returns
+* the would-be YAML text without touching either file.
+*/
+function migrateMainConfigToYaml(jsonPath, opts = {}) {
+	const yamlPath = opts.yamlPath ?? yamlSiblingPath(jsonPath);
+	if (existsSync(yamlPath) && !opts.force) throw new MainConfigError(`${yamlPath} already exists — edit it directly, or pass --force to regenerate it from ${jsonPath}`);
+	if (!existsSync(jsonPath)) throw new MainConfigError(`${jsonPath} does not exist — nothing to migrate`);
+	const { cleaned, comments } = stripUnderscoreComments(readJsonStrict(jsonPath, jsonPath));
+	const cleanedObj = cleaned;
+	const doc = new Document(cleanedObj);
+	const sectionComments = opts.sectionComments ?? MAIN_CONFIG_SECTION_COMMENTS;
+	for (const [key, text] of Object.entries(sectionComments)) if (key in cleanedObj) setYamlKeyComment(doc, [key], text);
+	for (const c of comments) setYamlKeyComment(doc, c.path, c.text);
+	const yamlText = String(doc);
+	if (!deepEqualJson(parseDocument(yamlText).toJS(), cleanedObj)) throw new MainConfigError(`${yamlPath}: generated YAML does not re-parse to the same data as ${jsonPath} — aborting, nothing written`);
+	if (opts.dryRun) return {
+		yamlPath,
+		yamlText,
+		backupPath: null,
+		dryRun: true
+	};
+	writeYamlFileAtomic(yamlPath, yamlText, { label: yamlPath });
+	const stamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+	const backupPath = join(dirname(jsonPath), `${basename(jsonPath)}.migrated-${stamp}`);
+	renameSync(jsonPath, backupPath);
+	return {
+		yamlPath,
+		yamlText,
+		backupPath,
+		dryRun: false
+	};
+}
+
+//#endregion
+//#region src/daemon/config.ts
+/**
+* config.ts — Configuration loader for PAI Daemon
+*
+* Loads config from ~/.claude/pai/config.json (the pre-2026-09-19 location
+* was ~/.config/pai/config.json, briefly ~/.claude/pai.json in between —
+* see paiConfigFilePath/migrateConfigFile).
+* Deep-merges with defaults so partial configs work fine.
+* Expands ~ in path values at runtime.
+*/
+/** Derive a per-user Postgres database name: pai_<username> */
+function perUserDbName() {
+	return `pai_${userInfo().username.replace(/[^a-zA-Z0-9_]/g, "_").toLowerCase()}`;
+}
+/** Derive the per-user connection string */
+function perUserConnectionString() {
+	return `postgresql://pai:pai@localhost:5432/${perUserDbName()}`;
+}
+/**
+* idleMinutes=50 sits under the 60-minute ephemeral-1h TTL with margin for
+* scheduler jitter; maxBeats=6 (~5h of coverage at one beat per idle stretch)
+* and activeHours 08:00-22:00 keep an unattended overnight machine from
+* beating all night for a session nobody will return to before the cache
+* would have expired anyway.
+*/
+const DEFAULT_SESSIONS_CACHE_KEEPALIVE = {
+	enabled: false,
+	idleMinutes: 50,
+	maxBeats: 6,
+	activeHours: "08:00-22:00",
+	minContextTokens: 2e4,
+	prompt: "keepalive"
+};
+const DEFAULTS = {
+	socketPath: paiSocketPath(),
+	indexIntervalSecs: 300,
+	embedIntervalSecs: 600,
+	embedOnStartup: false,
+	storageBackend: "sqlite",
+	postgres: {
+		connectionString: perUserConnectionString(),
+		maxConnections: 5,
+		connectionTimeoutMs: 5e3
+	},
+	embeddingModel: "Snowflake/snowflake-arctic-embed-m-v1.5",
+	logLevel: "info",
+	notifications: DEFAULT_NOTIFICATION_CONFIG,
+	tasks: DEFAULT_TASK_CONFIG,
+	identity: { selfEmails: [] },
+	sessions: { cacheKeepalive: { ...DEFAULT_SESSIONS_CACHE_KEEPALIVE } },
+	search: {
+		mode: "keyword",
+		rerank: true,
+		recencyBoostDays: 90,
+		defaultLimit: 10,
+		snippetLength: 200
+	}
+};
+/** Config template — generated at runtime so the DB name is per-user */
+function configTemplate() {
+	return `{
+  "socketPath": "/tmp/pai.sock",
+  "indexIntervalSecs": 300,
+  "embedIntervalSecs": 600,
+  "storageBackend": "sqlite",
+  "postgres": {
+    "connectionString": "${perUserConnectionString()}",
+    "maxConnections": 5,
+    "connectionTimeoutMs": 5000
+  },
+  "embeddingModel": "Snowflake/snowflake-arctic-embed-m-v1.5",
+  "logLevel": "info",
+  "vaultPath": "",
+  "vaultProjectId": 0,
+  "search": {
+    "mode": "keyword",
+    "rerank": true,
+    "recencyBoostDays": 90,
+    "defaultLimit": 10,
+    "snippetLength": 200
+  }
+}
+`;
+}
+/** Expand a leading ~ to the real home directory */
+function expandHome(p) {
+	if (p === "~" || p.startsWith("~/") || p.startsWith("~\\")) return join(homedir(), p.slice(1));
+	return p;
+}
+/** Canonical location since 2026-09-19: under the PAI_HOME namespace dir,
+*  so nothing PAI writes can collide with a file Claude Code itself owns. */
+const NEW_CONFIG_FILE = paiHomePath("config.json");
+/** Briefly the canonical location between 2026-09-19's two migrations —
+*  read during the transition, never written to again. */
+const OLD_CONFIG_FILE = join(homedir(), ".claude", "pai.json");
+/** Where the config lived before 2026-09-19 — read during the transition,
+*  never written to once NEW_CONFIG_FILE exists (see `pai config migrate`). */
+const LEGACY_CONFIG_FILE = join(homedir(), ".config", "pai", "config.json");
+/**
+* The path any read/write of the PAI config actually uses: PAI_CONFIG_FILE
+* (tests, power users) first, else the new PAI_HOME location if it exists,
+* else the most recent old location that is actually on disk (printing a
+* one-time notice), else the new location (the target a first write creates).
+*/
+function paiConfigFilePath() {
+	const override = process.env.PAI_CONFIG_FILE;
+	if (override) return override;
+	return resolvePaiFile(NEW_CONFIG_FILE, [OLD_CONFIG_FILE, LEGACY_CONFIG_FILE], "pai config migrate");
+}
+const CONFIG_FILE = paiConfigFilePath();
+const CONFIG_DIR = dirname(CONFIG_FILE);
+/** config.yaml — the canonical main config once `pai config yaml` has run,
+*  read/written by readMainConfigRaw/writeMainConfigRaw instead of
+*  CONFIG_FILE whenever it exists (see src/config/main-config.ts). */
+function paiConfigYamlFilePath() {
+	return yamlSiblingPath(CONFIG_FILE);
+}
+/**
+* Read the raw main config object exactly as every non-typed writer
+* (identity, notifications, obsidian, setup, workers, memory settings) needs
+* it: config.yaml when it exists, else CONFIG_FILE. `path` overrides the
+* JSON location (tests, or workers/config.ts's parametrized CONFIG_FILE) —
+* its YAML sibling (same dir, `config.yaml`) is what gets preferred.
+*/
+function readMainConfigRaw(path = CONFIG_FILE) {
+	try {
+		return readDualFormatConfigRaw(path);
+	} catch (e) {
+		throw e instanceof MainConfigError ? new Error(e.message) : e;
+	}
+}
+/**
+* Write the raw main config object back through the same seam: a
+* comment-preserving sync into config.yaml when it exists, else a plain
+* writeJsonAtomic to `path`. Every writer of the main config must call this
+* instead of touching CONFIG_FILE directly, so a config.yaml on disk is
+* honored no matter which of them made the change.
+*/
+function writeMainConfigRaw(raw, path = CONFIG_FILE) {
+	try {
+		writeDualFormatConfigRaw(path, raw);
+	} catch (e) {
+		throw e instanceof MainConfigError ? new Error(e.message) : e;
+	}
+}
+/**
+* `pai config migrate`: move config.json (from ~/.claude/pai.json or
+* ~/.config/pai/config.json, whichever is found) to ~/.claude/pai/config.json
+* byte-for-byte, verify the copy, then rename the old file aside as
+* config.json.migrated-<YYYYMMDD> (never deleted).
+*/
+function migrateConfigFile(opts = {}) {
+	return migratePaiFile(NEW_CONFIG_FILE, [OLD_CONFIG_FILE, LEGACY_CONFIG_FILE], opts);
+}
+function deepMerge(target, source) {
+	const result = { ...target };
+	for (const key of Object.keys(source)) {
+		const srcVal = source[key];
+		if (srcVal === void 0 || srcVal === null) continue;
+		const tgtVal = target[key];
+		if (typeof srcVal === "object" && !Array.isArray(srcVal) && typeof tgtVal === "object" && tgtVal !== null && !Array.isArray(tgtVal)) result[key] = deepMerge(tgtVal, srcVal);
+		else result[key] = srcVal;
+	}
+	return result;
+}
+/**
+* Load configuration: config.yaml (see paiConfigYamlFilePath) if it exists,
+* else CONFIG_FILE (see paiConfigFilePath), else defaults. Returns defaults
+* deep-merged with any values found in the file.
+*/
+function loadConfig() {
+	if (!existsSync(CONFIG_FILE) && !existsSync(paiConfigYamlFilePath())) return { ...DEFAULTS };
+	let parsed;
+	try {
+		parsed = readMainConfigRaw();
+	} catch (e) {
+		process.stderr.write(`[pai-daemon] Could not read config: ${e instanceof Error ? e.message : String(e)}\n`);
+		return { ...DEFAULTS };
+	}
+	if (parsed.obsidianVaultPath && !parsed.vaultPath) {
+		parsed.vaultPath = parsed.obsidianVaultPath;
+		process.stderr.write(`[pai-daemon] Config: mapped obsidianVaultPath → vaultPath (${parsed.vaultPath})\n`);
+	}
+	return deepMerge(DEFAULTS, parsed);
+}
+/**
+* Ensure CONFIG_DIR exists and write a default config template to CONFIG_FILE
+* if none exists yet. Call this only from the `serve` command.
+*/
+function ensureConfigDir() {
+	if (!existsSync(CONFIG_DIR)) {
+		mkdirSync(CONFIG_DIR, { recursive: true });
+		process.stderr.write(`[pai-daemon] Created config directory: ${CONFIG_DIR}\n`);
+	}
+	if (!existsSync(CONFIG_FILE) && !existsSync(paiConfigYamlFilePath())) try {
+		writeFileSync(CONFIG_FILE, configTemplate(), "utf-8");
+		process.stderr.write(`[pai-daemon] Wrote default config to: ${CONFIG_FILE}\n`);
+	} catch (e) {
+		process.stderr.write(`[pai-daemon] Could not write default config: ${e}\n`);
+	}
+}
+
+//#endregion
+export { DEFAULT_NOTIFICATION_CONFIG as S, writeYamlFileAtomic as _, ensureConfigDir as a, OWNER_LABEL_PREFIX as b, migrateConfigFile as c, readMainConfigRaw as d, writeMainConfigRaw as f, YamlStoreError as g, resolvedMainConfigPath as h, DEFAULT_SESSIONS_CACHE_KEEPALIVE as i, paiConfigFilePath as l, migrateMainConfigToYaml as m, CONFIG_FILE as n, expandHome as o, MainConfigError as p, DEFAULTS as r, loadConfig as s, CONFIG_DIR as t, paiConfigYamlFilePath as u, readJsonStrict as v, UNROUTED as x, writeJsonAtomic as y };
+//# sourceMappingURL=config-Bn9jpblO.mjs.map