@tekmidian/pai 0.49.0 → 0.51.0

package/src/hooks/ts/lib/context-fill.ts

@@ -294,7 +294,8 @@ export function formatContextFill(reading: ContextFillReading): FillDisplay {
 // The configured chain — env override, then a default — is the fallback,
 // used ONLY when a project has no compaction history yet:
 //
-//   effectiveTrigger = measured ?? (windowSize * (override ?? 80) / 100)
+//   effectiveTrigger = measured ?? configuredTrigger(windowSize, override ?? 80)
+//   configuredTrigger(windowSize, pct) = pct/100 * (windowSize - 20,000)
 //
 // DEFAULT IS 80, NOT 100, WHEN NOTHING IS KNOWN. 100 was considered — it
 // matches the FIRST regime above — and rejected: the costs are asymmetric.
@@ -313,6 +314,17 @@ export function formatContextFill(reading: ContextFillReading): FillDisplay {
 // waiting for one.
 export const DEFAULT_AUTOCOMPACT_PCT = 80;
 
+/**
+ * The platform's actual compaction trigger for a window/pct pair. NOT
+ * windowSize * pct/100 — that formula gives 800,000 on 1M/80 and 160,000 on
+ * 200k/80, but the platform fires at pct/100 * (windowSize - 20,000):
+ * 784,000 and 144,000, measured on every compact_boundary on this machine,
+ * 2026-09-20 (see the module comment above).
+ */
+export function configuredTrigger(windowSize: number, pct: number): number {
+  return Math.round((pct / 100) * (windowSize - 20_000));
+}
+
 /** How many of the most recent compact_boundary events to consider, and to
  *  take the minimum of. */
 const MEASURED_TRIGGER_SAMPLE_SIZE = 3;
@@ -575,26 +587,57 @@ export function selectedCompactionSamples(
 
 /**
  * The measured compaction trigger for a project, or null when it has no
- * compaction history yet (a brand-new project, or one whose transcripts
- * this process cannot read). Minimum of the most recent
- * MEASURED_TRIGGER_SAMPLE_SIZE DISTINCT compact_boundary events, ordered by
- * the events' own timestamps across every transcript the project has
- * (live and archived) — see the module comment above for why minimum, not
- * mean, and readCompactBoundarySamples for why "distinct" and "own
- * timestamp" both matter (a file-mtime-ordered, non-deduplicated version of
- * this returned a stale pre-regime-change trigger on real project data).
+ * compaction history yet (a brand-new project, one whose transcripts this
+ * process cannot read, or one whose only recent samples belong to a
+ * different override regime — see the admissibility filter below).
+ * Minimum of the most recent MEASURED_TRIGGER_SAMPLE_SIZE DISTINCT
+ * compact_boundary events, ordered by the events' own timestamps across
+ * every transcript the project has (live and archived) — see the module
+ * comment above for why minimum, not mean, and readCompactBoundarySamples
+ * for why "distinct" and "own timestamp" both matter (a file-mtime-ordered,
+ * non-deduplicated version of this returned a stale pre-regime-change
+ * trigger on real project data).
+ *
+ * When `configuredTriggerTokens` is given, a sample is admissible only when
+ * preTokens >= 0.5 * configuredTriggerTokens — a compaction that fired far
+ * below the currently configured trigger came from a lower override or a
+ * smaller window, a different regime than the one in force now, and must
+ * not drag the trigger down with it. Real case, 2026-09-20:
+ * CLAUDE_AUTOCOMPACT_PCT_OVERRIDE was 20 for seven hours, this project
+ * compacted three times at ~195k-198k under it, then the override went
+ * back to 80 (configured ~784k) — those three samples are inadmissible and
+ * must be discarded, not averaged into the new regime's trigger, or the
+ * handover would fire at ~155k for days until three fresh ~784k
+ * compactions pushed them out on their own.
  */
 export function measureCompactionTrigger(
   cwd: string,
   projectsDir: string = CLAUDE_PROJECTS_DIR,
-  configPath?: string
+  configPath?: string,
+  configuredTriggerTokens?: number
 ): number | null {
   const samples = selectedCompactionSamples(cwd, projectsDir, configPath);
   if (samples.length === 0) return null;
-  const trigger = Math.min(...samples.map((s) => s.preTokens));
+
+  let admissible = samples;
+  if (configuredTriggerTokens !== undefined) {
+    const floor = 0.5 * configuredTriggerTokens;
+    admissible = samples.filter((s) => s.preTokens >= floor);
+    const discarded = samples.length - admissible.length;
+    if (discarded > 0) {
+      console.error(
+        `[context-fill] discarded ${discarded} compaction sample(s) as other-regime for ${cwd} ` +
+        `(preTokens below ${Math.round(floor)}, half of configured=${configuredTriggerTokens}): ` +
+        samples.filter((s) => s.preTokens < floor).map((s) => `${s.preTokens}@${s.timestamp}`).join(", ")
+      );
+    }
+    if (admissible.length === 0) return null;
+  }
+
+  const trigger = Math.min(...admissible.map((s) => s.preTokens));
   console.error(
     `[context-fill] measured trigger for ${cwd}: ${trigger} (minimum of ` +
-    samples.map((s) => `${s.preTokens}@${s.timestamp}`).join(", ") + ")"
+    admissible.map((s) => `${s.preTokens}@${s.timestamp}`).join(", ") + ")"
   );
   return trigger;
 }
@@ -717,12 +760,12 @@ export function contextFillThresholds(
 ): ContextFillThresholds {
   const windowConfirmed = reading.source === "statusline";
   const autocompactPct = resolveAutocompactPct(env);
-  const configuredTriggerTokens = Math.round(reading.windowSize * (autocompactPct / 100));
+  const configuredTriggerTokens = configuredTrigger(reading.windowSize, autocompactPct);
 
   const measuredTriggerTokens = opts.measuredTrigger !== undefined
     ? opts.measuredTrigger
     : opts.cwd
-      ? measureCompactionTrigger(opts.cwd)
+      ? measureCompactionTrigger(opts.cwd, CLAUDE_PROJECTS_DIR, undefined, configuredTriggerTokens)
       : null;
 
   let effectiveTriggerTokens: number;

package/src/hooks/ts/user-prompt/whisper-rules.test.ts

@@ -1,5 +1,8 @@
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, afterEach } from "vitest";
 import { execFileSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
 // whisper-rules.ts calls main() unconditionally at module scope (it's a hook
 // entrypoint, always run as a subprocess) — including a blocking read of fd 0.
@@ -46,4 +49,56 @@ describe("user-prompt/whisper-rules entrypoint", () => {
     expect(stdout).toContain("<system-reminder>");
     expect(stdout).toContain("CURRENT LOCAL TIME");
   });
+
+  describe("cache-keepalive beat prompt", () => {
+    const dirs: string[] = [];
+
+    afterEach(() => {
+      for (const d of dirs.splice(0)) rmSync(d, { recursive: true, force: true });
+    });
+
+    function configuredEnv(config: Record<string, unknown>): NodeJS.ProcessEnv {
+      const dir = mkdtempSync(join(tmpdir(), "pai-whisper-keepalive-"));
+      dirs.push(dir);
+      const file = join(dir, "config.json");
+      writeFileSync(file, JSON.stringify(config), "utf8");
+      return { ...process.env, PAI_CONFIG_FILE: file };
+    }
+
+    it("replies with only the minimal tool-free instruction, bypassing rules/advisor", () => {
+      const env = configuredEnv({ sessions: { cacheKeepalive: { enabled: true, prompt: "keepalive" } } });
+      const stdout = execFileSync("bun", [ENTRYPOINT], {
+        input: JSON.stringify({ prompt: "keepalive" }),
+        encoding: "utf8",
+        timeout: 15_000,
+        env,
+      });
+      expect(stdout).toBe(
+        "<system-reminder>\nReply with a single period and nothing else. Do not call tools.\n</system-reminder>\n"
+      );
+      expect(stdout).not.toContain("CURRENT LOCAL TIME");
+    });
+
+    it("falls through to the normal rule block when the feature is disabled", () => {
+      const env = configuredEnv({ sessions: { cacheKeepalive: { enabled: false, prompt: "keepalive" } } });
+      const stdout = execFileSync("bun", [ENTRYPOINT], {
+        input: JSON.stringify({ prompt: "keepalive" }),
+        encoding: "utf8",
+        timeout: 15_000,
+        env,
+      });
+      expect(stdout).toContain("CURRENT LOCAL TIME");
+    });
+
+    it("falls through to the normal rule block for a prompt that doesn't match the configured word", () => {
+      const env = configuredEnv({ sessions: { cacheKeepalive: { enabled: true, prompt: "keepalive" } } });
+      const stdout = execFileSync("bun", [ENTRYPOINT], {
+        input: JSON.stringify({ prompt: "please fix the login bug" }),
+        encoding: "utf8",
+        timeout: 15_000,
+        env,
+      });
+      expect(stdout).toContain("CURRENT LOCAL TIME");
+    });
+  });
 });

package/src/hooks/ts/user-prompt/whisper-rules.ts

@@ -24,6 +24,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { resolveAdvisorMode, type AdvisorConfig } from "../lib/advisor-budget.js";
 import { whisperRulesPath, advisorModePath } from "../../../config/pai-files.js";
+import { loadConfig } from "../../../daemon/config.js";
 
 const WHISPER_FILE = whisperRulesPath();
 const ADVISOR_FILE = advisorModePath();
@@ -181,6 +182,24 @@ function resetReinjectCounter(sessionId: string): void {
  * several times per turn during worker-heavy work, so injecting the ~5KB rule
  * block on each one was landing it 3-5 times in a single turn.
  */
+/**
+ * True when this prompt is the daemon's own idle-triggered cache-keepalive
+ * beat (sessions.cacheKeepalive, src/daemon/config.ts): the daemon typed the
+ * configured word into this session purely to refresh its prompt-cache TTL,
+ * not to ask anything. The whole point is a beat that costs as little output
+ * as possible, so this bypasses every other rule/advisor injection below —
+ * adding ~5KB of context to answer nothing would erase the saving the beat
+ * exists to capture.
+ */
+export function isCacheKeepaliveBeat(prompt: string): boolean {
+  try {
+    const { enabled, prompt: word } = loadConfig().sessions.cacheKeepalive;
+    return enabled && prompt.trim() === word;
+  } catch {
+    return false;
+  }
+}
+
 export function isRelayedPrompt(prompt: string): boolean {
   return (
     /^\s*\[Session:[^\]]+\]/.test(prompt) ||
@@ -204,6 +223,11 @@ function main() {
 
   resetReinjectCounter(sessionId);
 
+  if (isCacheKeepaliveBeat(prompt)) {
+    console.log("<system-reminder>\nReply with a single period and nothing else. Do not call tools.\n</system-reminder>");
+    return;
+  }
+
   if (isRelayedPrompt(prompt)) return;
 
   const isWorker = process.env.PAI_WORKER === "1";

package/statusline-command.sh

@@ -114,15 +114,90 @@ if [ ! -f "$pai_config" ]; then
         pai_config="${XDG_CONFIG_HOME:-$HOME/.config}/pai/config.json"
     fi
 fi
+
+# Providers moved to $pai_home_dir/workers.yaml (top-level `providers:`; see
+# src/workers/config.ts readWorkersSection) on 2026-09-19 — jq never sees the
+# YAML directly (no yq on this machine), so a small node script converts it
+# via the `yaml` package sitting next to this script's own real location
+# (readlink -f "$0": this file is usually reached through a symlink at
+# ~/.claude/statusline-command.sh). The conversion is cached under
+# pai_cache_dir, the cache kept only while it is newer than workers.yaml's own
+# mtime, so node is spawned only when the YAML actually changed. Resolved once
+# into $providers_file (holding just the providers object, unwrapped) so both
+# this lookup and the usage block below read the same data — never re-derived.
+# Any failure (no workers.yaml, no node, parse error) falls back silently to
+# the legacy `.workers.providers` of $pai_config, then to anthropic.
+providers_file=""
+_workers_yaml="${pai_home_dir}/workers.yaml"
+if [ -f "$_workers_yaml" ] && command -v node >/dev/null 2>&1; then
+    _sl_script="$(readlink -f "$0" 2>/dev/null || echo "$0")"
+    _sl_script_dir="$(dirname "$_sl_script")"
+    _providers_cache="${pai_cache_dir}/statusline-providers.json"
+    _yaml_mtime=$(stat -f %m "$_workers_yaml" 2>/dev/null || echo 0)
+    _cache_mtime=$(stat -f %m "$_providers_cache" 2>/dev/null || echo -1)
+    if [ ! -s "$_providers_cache" ] || [ "$_cache_mtime" -lt "$_yaml_mtime" ] 2>/dev/null; then
+        mkdir -p "$pai_cache_dir" 2>/dev/null
+        # umask 077 so the temp file is born 0600 — it must never exist at a
+        # world-readable mode even transiently, since providers carry inline
+        # `key:` secrets and only the allow-listed fields below leave this
+        # subshell.
+        (
+            umask 077
+            NODE_PATH="${_sl_script_dir}/node_modules" node - "$_workers_yaml" \
+                > "${_providers_cache}.tmp" 2>/dev/null <<'PAI_YAML_PROVIDERS'
+const fs = require("fs");
+try {
+    const YAML = require("yaml");
+    const doc = YAML.parse(fs.readFileSync(process.argv[2], "utf8"));
+    const providers = (doc && doc.providers) || {};
+    // Allow-list: only what the status line ever reads from a provider.
+    // workers.yaml is 0600 because providers carry inline `key:` secrets —
+    // this cache must never repeat them (or `env`, `url`, `headers`, …).
+    const safe = {};
+    for (const [name, p] of Object.entries(providers || {})) {
+        safe[name] = {
+            models: (p && p.models) || {},
+            usage: (p && p.usage) || undefined,
+            keyFile: (p && p.keyFile) || undefined,
+        };
+    }
+    process.stdout.write(JSON.stringify(safe));
+} catch {
+    process.exit(1);
+}
+PAI_YAML_PROVIDERS
+        )
+        if [ -s "${_providers_cache}.tmp" ]; then
+            mv "${_providers_cache}.tmp" "$_providers_cache"
+        else
+            rm -f "${_providers_cache}.tmp"
+        fi
+    fi
+    [ -s "$_providers_cache" ] && providers_file="$_providers_cache"
+fi
+if [ -z "$providers_file" ] && [ -f "$pai_config" ] && command -v jq >/dev/null 2>&1; then
+    _providers_legacy="${pai_cache_dir}/statusline-providers-legacy.json"
+    mkdir -p "$pai_cache_dir" 2>/dev/null
+    # Same allow-list and 0600-from-birth handling as the YAML path above:
+    # this legacy config can carry the same inline `key:` secrets.
+    if (umask 077; jq -c '(.workers.providers // {}) | with_entries(.value |= {models, usage, keyFile})' "$pai_config" > "${_providers_legacy}.tmp" 2>/dev/null) \
+        && [ -s "${_providers_legacy}.tmp" ]; then
+        mv "${_providers_legacy}.tmp" "$_providers_legacy"
+        providers_file="$_providers_legacy"
+    else
+        rm -f "${_providers_legacy}.tmp"
+    fi
+fi
+
 model_base="${model_id%%\[*}"
 session_provider=anthropic
-if [ -n "$model_base" ] && [ -f "$pai_config" ] && command -v jq >/dev/null 2>&1; then
+if [ -n "$model_base" ] && [ -n "$providers_file" ] && command -v jq >/dev/null 2>&1; then
     _matched_provider=$(jq -r --arg mb "$model_base" '
-        (.workers.providers // {}) | to_entries[] as $p
+        (. // {}) | to_entries[] as $p
         | (($p.value.models // {}) | to_entries[]) as $m
         | ($m.value | tostring) as $v
         | select($v == $mb or ($v | split("[")[0]) == $mb)
-        | $p.key' "$pai_config" 2>/dev/null | head -1)
+        | $p.key' "$providers_file" 2>/dev/null | head -1)
     [ -n "$_matched_provider" ] && session_provider="$_matched_provider"
 fi
 
@@ -624,8 +699,12 @@ if [ "$session_provider" = "anthropic" ]; then
         remaining_secs=$((seven_reset_epoch - now_epoch))
         [ "$remaining_secs" -lt 0 ] && remaining_secs=0
         elapsed_secs=$((window_secs - remaining_secs))
-        # Daily pace: actual spend/day vs dynamic budget
-        # Budget = remaining capacity / remaining days (not static 100/7)
+        # Daily pace: actual spend/day vs the flat weekly share.
+        # Budget = static 100/7 (not remaining capacity / remaining days): the
+        # user reads "1d" as "what I may spend today", a fixed share of the
+        # week, not a figure that shrinks as the week is used — dividing the
+        # shrinking remainder by the shrinking remaining days double-counted
+        # overspend and drove the pace red for no new reason.
         elapsed_days_x10=$((elapsed_secs * 10 / 86400))
         # A per-day rate divided by a fraction of a day is not a rate, it is an
         # extrapolation from noise: an hour into a fresh window the old clamp to
@@ -633,10 +712,7 @@ if [ "$session_provider" = "anthropic" ]; then
         # Below half a day there is nothing to pace against yet — say nothing.
         if [ "$elapsed_days_x10" -ge 5 ]; then
             spend_per_day=$((seven_day_int * 10 / elapsed_days_x10))
-            remaining_days_x10=$((remaining_secs * 10 / 86400))
-            [ "$remaining_days_x10" -lt 1 ] && remaining_days_x10=1
-            remaining_budget=$((100 - seven_day_int))
-            budget_per_day=$((remaining_budget * 10 / remaining_days_x10))
+            budget_per_day=$((100 / 7))
             # Color: green = under budget, orange = near budget, red = over budget
             overspend=$((spend_per_day - budget_per_day))
             if [ "$overspend" -le -3 ] 2>/dev/null; then
@@ -738,9 +814,9 @@ _fetch_provider_usage() {
 if [ "$session_provider" != "anthropic" ]; then
     provider_usage=""
     provider_keyfile=""
-    if [ -f "$pai_config" ] && command -v jq >/dev/null 2>&1; then
-        provider_usage=$(jq -c --arg p "$session_provider" '.workers.providers[$p].usage // empty' "$pai_config" 2>/dev/null)
-        provider_keyfile=$(jq -r --arg p "$session_provider" '.workers.providers[$p].keyFile // empty' "$pai_config" 2>/dev/null)
+    if [ -n "$providers_file" ] && command -v jq >/dev/null 2>&1; then
+        provider_usage=$(jq -c --arg p "$session_provider" '.[$p].usage // empty' "$providers_file" 2>/dev/null)
+        provider_keyfile=$(jq -r --arg p "$session_provider" '.[$p].keyFile // empty' "$providers_file" 2>/dev/null)
         case "$provider_keyfile" in "~/"*) provider_keyfile="$HOME/${provider_keyfile#\~/}" ;; esac
     fi
 
@@ -828,10 +904,21 @@ if [ "$session_provider" != "anthropic" ]; then
 fi
 
 # LINE 3 - Context meter + usage limits
-# Auto-compact remaining: how much context left until compaction triggers
+# Auto-compact remaining: how much context left until compaction triggers.
+# Claude Code fires the auto-compact hook at pct/100 * (window - 20000)
+# tokens, not at pct% of the raw window — the first 20k tokens of any window
+# are reserved and never count toward the trigger. Computing "% left" against
+# the raw window (as a plain threshold-context_pct subtraction did) reads as
+# "the window is full" on a 1M-token session that still has 80% of its real
+# capacity free. Work in tokens, then re-express as a percent of the real
+# window so the figure is comparable across window sizes.
 ac_threshold="${CLAUDE_AUTOCOMPACT_PCT_OVERRIDE:-80}"
-ac_remaining=$((ac_threshold - context_pct))
-[ "$ac_remaining" -lt 0 ] && ac_remaining=0
+ac_trigger_tokens=$((ac_threshold * (context_size - 20000) / 100))
+ac_used_tokens=$((context_pct * context_size / 100))
+ac_left_tokens=$((ac_trigger_tokens - ac_used_tokens))
+[ "$ac_left_tokens" -lt 0 ] && ac_left_tokens=0
+ac_remaining=$((ac_left_tokens * 100 / context_size))
+ac_left_k=$((ac_left_tokens / 1000))
 # Color the remaining %: red ≤5, yellow ≤15, green otherwise
 if [ "$ac_remaining" -le 5 ] 2>/dev/null; then
     ac_color="$BRIGHT_RED"
@@ -840,7 +927,7 @@ elif [ "$ac_remaining" -le 15 ] 2>/dev/null; then
 else
     ac_color="$BRIGHT_GREEN"
 fi
-ac_suffix=" ${ac_color}(${ac_remaining}%% left)${RESET}"
+ac_suffix=" ${ac_color}(${ac_remaining}%% left, ${ac_left_k}K)${RESET}"
 
 if [ "$context_pct" -gt 0 ] 2>/dev/null; then
     # Color based on usage: green < 50%, yellow 50-75%, red > 75%

package/dist/config-DCu8THKi.mjs

@@ -1,228 +0,0 @@
-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 { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir, userInfo } from "node:os";
-import { dirname, join } from "node:path";
-
-//#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/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()}`;
-}
-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: [] },
-	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);
-/**
-* `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 from CONFIG_FILE (see paiConfigFilePath).
-* Returns defaults merged with any values found in the file.
-*/
-function loadConfig() {
-	if (!existsSync(CONFIG_FILE)) return { ...DEFAULTS };
-	let raw;
-	try {
-		raw = readFileSync(CONFIG_FILE, "utf-8");
-	} catch (e) {
-		process.stderr.write(`[pai-daemon] Could not read config file at ${CONFIG_FILE}: ${e}\n`);
-		return { ...DEFAULTS };
-	}
-	let parsed;
-	try {
-		parsed = JSON.parse(raw);
-	} catch (e) {
-		process.stderr.write(`[pai-daemon] Config file is not valid JSON: ${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)) 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 { expandHome as a, paiConfigFilePath as c, DEFAULT_NOTIFICATION_CONFIG as d, ensureConfigDir as i, OWNER_LABEL_PREFIX as l, CONFIG_FILE as n, loadConfig as o, DEFAULTS as r, migrateConfigFile as s, CONFIG_DIR as t, UNROUTED as u };
-//# sourceMappingURL=config-DCu8THKi.mjs.map