@automagik/omni 2.260524.1 → 2.260525.2

package/dist/index.js

@@ -4663,40 +4663,157 @@ var require_cli_spinners = __commonJS((exports, module) => {
 // src/lib/embedded-canonical-migration.ts
 var exports_embedded_canonical_migration = {};
 __export(exports_embedded_canonical_migration, {
+  readDataDirMajor: () => readDataDirMajor,
   migrateUnmountedEmbeddedToCanonical: () => migrateUnmountedEmbeddedToCanonical,
+  embeddedPostgresPackage: () => embeddedPostgresPackage,
+  compareVersionDesc: () => compareVersionDesc,
   compareEmbeddedVsCanonicalCounts: () => compareEmbeddedVsCanonicalCounts,
+  MIGRATION_SKIP_TABLES: () => MIGRATION_SKIP_TABLES,
   EMBEDDED_PGSERVE_DATA_DIR: () => EMBEDDED_PGSERVE_DATA_DIR
 });
-import { spawn, spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync9, mkdtempSync } from "fs";
+import { execFileSync as execFileSync3, spawn, spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, mkdtempSync, readFileSync as readFileSync6, readdirSync as readdirSync2, symlinkSync } from "fs";
 import { createServer } from "net";
-import { homedir as homedir7, tmpdir } from "os";
-import { join as join11 } from "path";
+import { arch, homedir as homedir7, platform, tmpdir } from "os";
+import { dirname as dirname2, join as join11 } from "path";
 import { setTimeout as sleep2 } from "timers/promises";
 function defaultLog(line) {
   process.stdout.write(`${line}
 `);
 }
-function findAutopgPostgresBinary() {
+function readDataDirMajor(dataDir) {
+  try {
+    const major = Number.parseInt(readFileSync6(join11(dataDir, "PG_VERSION"), "utf8").trim(), 10);
+    return Number.isFinite(major) ? major : null;
+  } catch {
+    return null;
+  }
+}
+function binaryMajor(binary) {
+  try {
+    const out = execFileSync3(binary, ["--version"], { encoding: "utf8", timeout: 5000 });
+    const m = out.match(/(\d+)(?:[.\s]|$)/);
+    return m ? Number.parseInt(m[1], 10) : null;
+  } catch {
+    return null;
+  }
+}
+function findAutopgPostgresBinary(wantMajor) {
   const autopgRoot = join11(homedir7(), ".local", "share", "autopg");
   if (!existsSync9(autopgRoot))
     return null;
-  let bestPath = null;
-  for (const entry of safeReaddir(autopgRoot)) {
-    const candidate = join11(autopgRoot, entry, "postgres", "bin", "postgres");
-    if (existsSync9(candidate))
-      bestPath = candidate;
+  const candidates = safeReaddir(autopgRoot).sort((a, b) => compareVersionDesc(a, b)).map((entry) => join11(autopgRoot, entry, "postgres", "bin", "postgres")).filter((candidate) => existsSync9(candidate));
+  if (candidates.length === 0)
+    return null;
+  if (wantMajor === null)
+    return candidates[0];
+  for (const candidate of candidates) {
+    if (binaryMajor(candidate) === wantMajor)
+      return candidate;
+  }
+  return null;
+}
+function compareVersionDesc(a, b) {
+  const parse = (s) => (s.match(/\d+/g) ?? []).map(Number);
+  const pa = parse(a);
+  const pb = parse(b);
+  for (let i = 0;i < Math.max(pa.length, pb.length); i++) {
+    const diff = (pb[i] ?? 0) - (pa[i] ?? 0);
+    if (diff !== 0)
+      return diff;
   }
-  return bestPath;
+  return b.localeCompare(a);
 }
 function safeReaddir(path) {
   try {
-    const { readdirSync: readdirSync2 } = __require("fs");
     return readdirSync2(path);
   } catch {
     return [];
   }
 }
+function embeddedPostgresPackage() {
+  const a = arch() === "arm64" ? "arm64" : arch() === "x64" ? "x64" : null;
+  if (!a)
+    return null;
+  if (platform() === "linux")
+    return `@embedded-postgres/linux-${a}`;
+  if (platform() === "darwin")
+    return `@embedded-postgres/darwin-${a}`;
+  if (platform() === "win32" && a === "x64")
+    return "@embedded-postgres/windows-x64";
+  return null;
+}
+function latestReaderVersion(pkg, major) {
+  try {
+    const raw2 = execFileSync3("npm", ["view", pkg, "versions", "--json"], { encoding: "utf8", timeout: 30000 });
+    const versions = JSON.parse(raw2);
+    const list2 = Array.isArray(versions) ? versions : [versions];
+    const matching = list2.filter((v) => v.startsWith(`${major}.`)).sort(compareVersionDesc);
+    return matching.length ? matching[0] : null;
+  } catch {
+    return null;
+  }
+}
+function materializeReaderLibs(nativeDir) {
+  const libDir = join11(nativeDir, "lib");
+  try {
+    const pkgRoot = dirname2(nativeDir);
+    const pairs = JSON.parse(readFileSync6(join11(nativeDir, "pg-symlinks.json"), "utf8"));
+    for (const { source, target } of pairs) {
+      const tgt = join11(pkgRoot, target);
+      if (!existsSync9(tgt)) {
+        try {
+          symlinkSync(join11(pkgRoot, source), tgt);
+        } catch {}
+      }
+    }
+  } catch {}
+  for (const f of safeReaddir(libDir)) {
+    const m = f.match(/^(.*\.so\.\d+)\.\d+/);
+    if (!m)
+      continue;
+    const base = join11(libDir, m[1]);
+    if (!existsSync9(base)) {
+      try {
+        symlinkSync(join11(libDir, f), base);
+      } catch {}
+    }
+  }
+}
+function fetchEmbeddedReader(major, log) {
+  const pkg = embeddedPostgresPackage();
+  if (!pkg)
+    return null;
+  const cacheDir = join11(homedir7(), ".omni", "cache", `pg-reader-${major}`);
+  const nativeDir = join11(cacheDir, "node_modules", pkg, "native");
+  const binary = join11(nativeDir, "bin", "postgres");
+  if (existsSync9(binary) && binaryMajor(binary) === major) {
+    materializeReaderLibs(nativeDir);
+    return { binary, libDir: join11(nativeDir, "lib") };
+  }
+  const version = latestReaderVersion(pkg, major);
+  if (!version)
+    return null;
+  log(`  fetching PG ${major} reader (${pkg}@${version}) \u2014 one-time, cached at ${cacheDir}`);
+  try {
+    mkdirSync6(cacheDir, { recursive: true });
+    const res = spawnSync2("bun", ["add", `${pkg}@${version}`], { cwd: cacheDir, encoding: "utf8", timeout: 180000 });
+    if (res.status !== 0 || !existsSync9(binary))
+      return null;
+    materializeReaderLibs(nativeDir);
+    return binaryMajor(binary) === major ? { binary, libDir: join11(nativeDir, "lib") } : null;
+  } catch {
+    return null;
+  }
+}
+function resolveReaderForMajor(wantMajor, log) {
+  const installed = findAutopgPostgresBinary(wantMajor);
+  if (installed)
+    return { binary: installed };
+  if (wantMajor === null)
+    return null;
+  return fetchEmbeddedReader(wantMajor, log);
+}
 async function findFreePort() {
   return new Promise((resolve, reject) => {
     const server = createServer();
@@ -4714,10 +4831,17 @@ async function findFreePort() {
     });
   });
 }
-async function spawnTempPostmaster(binary, dataDir, port, log) {
+async function spawnTempPostmaster(reader, dataDir, port, log) {
   const socketDir = mkdtempSync(join11(tmpdir(), "omni-migrate-pg-"));
   log(`  spawning temp postmaster: pid=\u2026 port=${port} socket=${socketDir}`);
-  const child = spawn(binary, [
+  let env2 = process.env;
+  if (reader.libDir) {
+    const loaderVar = platform() === "darwin" ? "DYLD_LIBRARY_PATH" : platform() === "win32" ? "PATH" : "LD_LIBRARY_PATH";
+    const sep = platform() === "win32" ? ";" : ":";
+    const prev = process.env[loaderVar];
+    env2 = { ...process.env, [loaderVar]: prev ? `${reader.libDir}${sep}${prev}` : reader.libDir };
+  }
+  const child = spawn(reader.binary, [
     "-D",
     dataDir,
     "-p",
@@ -4728,7 +4852,8 @@ async function spawnTempPostmaster(binary, dataDir, port, log) {
     `unix_socket_directories=${socketDir}`
   ], {
     stdio: ["ignore", "pipe", "pipe"],
-    detached: false
+    detached: false,
+    env: env2
   });
   let started = false;
   let crashed = null;
@@ -4771,6 +4896,19 @@ async function spawnTempPostmaster(binary, dataDir, port, log) {
     }
   };
 }
+function listTables(args) {
+  return psqlCapture([...args, "-tAc", `SELECT tablename FROM pg_tables WHERE schemaname='public' ORDER BY tablename`]).split(`
+`).map((s) => s.trim()).filter(Boolean);
+}
+function listColumns(args, table, insertableOnly = false) {
+  const filter = insertableOnly ? `AND is_generated <> 'ALWAYS'` : "";
+  return psqlCapture([
+    ...args,
+    "-tAc",
+    `SELECT column_name FROM information_schema.columns WHERE table_schema='public' AND table_name='${table}' ${filter} ORDER BY ordinal_position`
+  ]).split(`
+`).map((s) => s.trim()).filter(Boolean);
+}
 function psqlCapture(args) {
   const result = spawnSync2("psql", args, {
     encoding: "utf-8",
@@ -4782,10 +4920,15 @@ function psqlCapture(args) {
   }
   return result.stdout ?? "";
 }
-async function copyTable(table, srcArgs, dstArgs, log) {
+async function copyTable(table, columns, srcArgs, dstArgs, log) {
+  if (columns.length === 0) {
+    log(`  skip ${table} (no shared columns)`);
+    return;
+  }
+  const colList = columns.map((c2) => `"${c2}"`).join(", ");
   const tmpFile = join11(tmpdir(), `omni-migrate-${table}-${process.pid}.copy`);
   try {
-    const srcResult = spawnSync2("psql", [...srcArgs, "-c", `\\copy public.${table} TO '${tmpFile}' WITH (FORMAT binary)`], {
+    const srcResult = spawnSync2("psql", [...srcArgs, "-c", `\\copy public."${table}" (${colList}) TO '${tmpFile}' WITH (FORMAT text)`], {
       stdio: ["ignore", "pipe", "pipe"],
       env: { ...process.env, PGPASSWORD: "postgres" },
       timeout: 600000,
@@ -4799,7 +4942,7 @@ async function copyTable(table, srcArgs, dstArgs, log) {
       "-c",
       `SET session_replication_role='replica';`,
       "-c",
-      `\\copy public.${table} FROM '${tmpFile}' WITH (FORMAT binary)`
+      `\\copy public."${table}" (${colList}) FROM '${tmpFile}' WITH (FORMAT text)`
     ], {
       stdio: ["ignore", "pipe", "pipe"],
       env: { ...process.env, PGPASSWORD: "postgres" },
@@ -4841,13 +4984,18 @@ async function compareEmbeddedVsCanonicalCounts(opts = {}) {
   if (!existsSync9(EMBEDDED_DIR) || !existsSync9(join11(EMBEDDED_DIR, "PG_VERSION"))) {
     return { kind: "skipped", reason: "embedded dir absent" };
   }
-  const binary = findAutopgPostgresBinary();
-  if (!binary)
-    return { kind: "skipped", reason: "autopg postgres binary not found" };
+  const wantMajor = readDataDirMajor(EMBEDDED_DIR);
+  const reader = resolveReaderForMajor(wantMajor, () => {});
+  if (!reader) {
+    return {
+      kind: "skipped",
+      reason: wantMajor ? `no PostgreSQL ${wantMajor} reader available (autopg or fetchable embedded-postgres) for the PG ${wantMajor} embedded dir` : "autopg postgres binary not found"
+    };
+  }
   const tempPort = await findFreePort();
   let temp = null;
   try {
-    temp = await spawnTempPostmaster(binary, EMBEDDED_DIR, tempPort, () => {});
+    temp = await spawnTempPostmaster(reader, EMBEDDED_DIR, tempPort, () => {});
     const srcArgs = ["-h", "127.0.0.1", "-p", String(tempPort), "-U", "postgres", "-d", "omni"];
     const dstArgs = ["-h", "127.0.0.1", "-p", String(canonicalPort), "-U", "postgres", "-d", "omni"];
     const tablesRaw = psqlCapture([
@@ -4863,8 +5011,8 @@ async function compareEmbeddedVsCanonicalCounts(opts = {}) {
     let totalExtra = 0;
     for (const t of tables) {
       try {
-        const em = Number.parseInt(psqlCapture([...srcArgs, "-tAc", `SELECT count(*) FROM public.${t}`]).trim(), 10);
-        const ca = Number.parseInt(psqlCapture([...dstArgs, "-tAc", `SELECT count(*) FROM public.${t}`]).trim(), 10);
+        const em = Number.parseInt(psqlCapture([...srcArgs, "-tAc", `SELECT count(*) FROM public."${t}"`]).trim(), 10);
+        const ca = Number.parseInt(psqlCapture([...dstArgs, "-tAc", `SELECT count(*) FROM public."${t}"`]).trim(), 10);
         if (Number.isFinite(em) && Number.isFinite(ca) && em > ca) {
           divergent.push(t);
           totalExtra += em - ca;
@@ -4892,37 +5040,43 @@ async function migrateUnmountedEmbeddedToCanonical(opts = {}) {
   if (!existsSync9(join11(EMBEDDED_DIR, "PG_VERSION"))) {
     return { status: "skipped", reason: "embedded dir missing PG_VERSION" };
   }
-  const binary = findAutopgPostgresBinary();
-  if (!binary) {
-    return { status: "skipped", reason: "autopg postgres binary not found \u2014 install autopg first" };
+  const wantMajor = readDataDirMajor(EMBEDDED_DIR);
+  const reader = resolveReaderForMajor(wantMajor, log);
+  if (!reader) {
+    return {
+      status: "skipped",
+      reason: wantMajor ? `could not obtain a PostgreSQL ${wantMajor} reader (no installed autopg match and embedded-postgres fetch unavailable \u2014 unsupported platform or offline)` : "autopg postgres binary not found \u2014 install autopg first"
+    };
   }
-  log(`  using postgres binary: ${binary}`);
+  log(`  using postgres binary: ${reader.binary} (matched PG ${wantMajor ?? "?"}${reader.libDir ? ", fetched reader" : ""})`);
   log("  stopping omni-api during data copy");
   spawnSync2("pm2", ["stop", "omni-api"], { stdio: "inherit" });
   const tempPort = await findFreePort();
   const t0 = Date.now();
-  const temp = await spawnTempPostmaster(binary, EMBEDDED_DIR, tempPort, log);
+  const temp = await spawnTempPostmaster(reader, EMBEDDED_DIR, tempPort, log);
   let apiRestarted = false;
   try {
     const srcBaseArgs = ["-h", "127.0.0.1", "-p", String(tempPort), "-U", "postgres", "-d", "omni"];
     const dstBaseArgs = ["-h", "127.0.0.1", "-p", String(canonicalPort), "-U", "postgres", "-d", "omni"];
-    const tablesRaw = psqlCapture([
-      ...srcBaseArgs,
-      "-tAc",
-      `SELECT tablename FROM pg_tables WHERE schemaname='public' ORDER BY tablename`
-    ]);
-    const tables = tablesRaw.split(`
-`).map((s) => s.trim()).filter(Boolean);
-    if (tables.length === 0) {
+    const srcTables = new Set(listTables(srcBaseArgs));
+    if (srcTables.size === 0) {
       return { status: "skipped", reason: "embedded omni has no public tables" };
     }
-    const SKIP_TABLES = new Set(["media_content"]);
-    const filteredTables = tables.filter((t) => !SKIP_TABLES.has(t));
-    const skipped = tables.filter((t) => SKIP_TABLES.has(t));
+    const dstTables = listTables(dstBaseArgs);
+    const tables = dstTables.filter((t) => srcTables.has(t));
+    const onlyEmbedded = [...srcTables].filter((t) => !dstTables.includes(t));
+    if (onlyEmbedded.length > 0) {
+      log(`  ${onlyEmbedded.length} obsolete embedded-only table(s) skipped: ${onlyEmbedded.join(", ")}`);
+    }
+    if (tables.length === 0) {
+      return { status: "skipped", reason: "no tables shared between embedded and canonical schemas" };
+    }
+    const filteredTables = tables.filter((t) => !MIGRATION_SKIP_TABLES.has(t));
+    const skipped = tables.filter((t) => MIGRATION_SKIP_TABLES.has(t));
     if (skipped.length > 0)
       log(`  skipping ${skipped.length} table(s) (rebuilt at runtime): ${skipped.join(", ")}`);
     log(`  ${filteredTables.length} tables to migrate`);
-    const truncateList = filteredTables.map((t) => `public.${t}`).join(",");
+    const truncateList = filteredTables.map((t) => `public."${t}"`).join(",");
     psqlCapture([
       ...dstBaseArgs,
       "-c",
@@ -4930,7 +5084,9 @@ async function migrateUnmountedEmbeddedToCanonical(opts = {}) {
     ]);
     log("  truncated canonical (CASCADE)");
     for (const t of filteredTables) {
-      await copyTable(t, srcBaseArgs, dstBaseArgs, log);
+      const srcCols = new Set(listColumns(srcBaseArgs, t));
+      const sharedCols = listColumns(dstBaseArgs, t, true).filter((c2) => srcCols.has(c2));
+      await copyTable(t, sharedCols, srcBaseArgs, dstBaseArgs, log);
     }
     resetSequences(dstBaseArgs, log);
     return { status: "migrated", tables: filteredTables.length, durationMs: Date.now() - t0 };
@@ -4941,9 +5097,10 @@ async function migrateUnmountedEmbeddedToCanonical(opts = {}) {
     apiRestarted = true;
   }
 }
-var EMBEDDED_DIR, EMBEDDED_PGSERVE_DATA_DIR;
+var EMBEDDED_DIR, MIGRATION_SKIP_TABLES, EMBEDDED_PGSERVE_DATA_DIR;
 var init_embedded_canonical_migration = __esm(() => {
   EMBEDDED_DIR = join11(homedir7(), ".omni", "data", "pgserve");
+  MIGRATION_SKIP_TABLES = new Set(["media_content", "api_keys", "api_key_audit_logs"]);
   EMBEDDED_PGSERVE_DATA_DIR = EMBEDDED_DIR;
 });
 
@@ -35933,10 +36090,10 @@ var init_agno_client = __esm(() => {
 // ../core/src/providers/claude-code-executable.ts
 import { existsSync as nodeExistsSync } from "fs";
 import { createRequire } from "module";
-function archLinkerNames(arch) {
-  if (arch === "x64")
+function archLinkerNames(arch2) {
+  if (arch2 === "x64")
     return { musl: "x86_64", glibc: "x86-64" };
-  if (arch === "arm64")
+  if (arch2 === "arm64")
     return { musl: "aarch64", glibc: "aarch64" };
   return null;
 }
@@ -35949,41 +36106,41 @@ function glibcLinkerCandidates(glibcName, muslName, nodeArch) {
   return [`/lib64/${fileName}`, `/lib/${muslName}-linux-gnu/${fileName}`, `/lib/${fileName}`];
 }
 function detectLinuxLibc(options = {}) {
-  const platform = options.platform ?? process.platform;
-  if (platform !== "linux")
+  const platform2 = options.platform ?? process.platform;
+  if (platform2 !== "linux")
     return "unknown";
-  const arch = options.arch ?? process.arch;
-  const names = archLinkerNames(arch);
+  const arch2 = options.arch ?? process.arch;
+  const names = archLinkerNames(arch2);
   if (!names)
     return "unknown";
   const exists = options.existsSync ?? nodeExistsSync;
   if (exists(muslLinkerPath(names.musl)))
     return "musl";
-  if (glibcLinkerCandidates(names.glibc, names.musl, arch).some(exists))
+  if (glibcLinkerCandidates(names.glibc, names.musl, arch2).some(exists))
     return "glibc";
   return "unknown";
 }
 function resolveClaudeCodeExecutable(options = {}) {
-  const platform = options.platform ?? process.platform;
-  if (platform !== "linux")
+  const platform2 = options.platform ?? process.platform;
+  if (platform2 !== "linux")
     return;
-  const libc = options.libc ?? detectLinuxLibc({ platform, arch: options.arch });
+  const libc = options.libc ?? detectLinuxLibc({ platform: platform2, arch: options.arch });
   if (libc === "unknown")
     return;
-  const arch = options.arch ?? process.arch;
-  if (arch !== "x64" && arch !== "arm64")
+  const arch2 = options.arch ?? process.arch;
+  if (arch2 !== "x64" && arch2 !== "arm64")
     return;
-  const suffix = libc === "musl" ? `-${arch}-musl` : `-${arch}`;
+  const suffix = libc === "musl" ? `-${arch2}-musl` : `-${arch2}`;
   const specifier = `@anthropic-ai/claude-agent-sdk-linux${suffix}/claude`;
   const resolve2 = options.resolve ?? createRequire(import.meta.url).resolve;
   try {
     const resolved = resolve2(specifier);
-    log6.debug("Resolved Claude Code executable for host libc", { libc, arch, resolved });
+    log6.debug("Resolved Claude Code executable for host libc", { libc, arch: arch2, resolved });
     return resolved;
   } catch (error2) {
     log6.debug("Claude Code subpackage not installed; falling back to SDK default", {
       libc,
-      arch,
+      arch: arch2,
       specifier,
       error: String(error2)
     });
@@ -35992,9 +36149,9 @@ function resolveClaudeCodeExecutable(options = {}) {
 }
 function describeClaudeCodeStartupError(error2, options = {}) {
   const raw2 = String(error2);
-  const platform = options.platform ?? process.platform;
+  const platform2 = options.platform ?? process.platform;
   const isStartupCrash = /process exited with code 1/i.test(raw2);
-  if (!isStartupCrash || platform !== "linux")
+  if (!isStartupCrash || platform2 !== "linux")
     return raw2;
   const configuredHint = options.explicitExecutablePath ? `Configured pathToClaudeCodeExecutable=${options.explicitExecutablePath} did not launch \u2014 verify the binary is executable on this host.` : "Set `pathToClaudeCodeExecutable` on the provider to the correct SDK binary for this host, " + "or remove the mismatched optional subpackage " + "(e.g. `bun remove @anthropic-ai/claude-agent-sdk-linux-x64-musl` on glibc).";
   return `${raw2} \u2014 Claude Code binary failed to start. This is typically a glibc/musl ABI mismatch: the SDK resolved an optional subpackage whose native binary cannot execute on this host's dynamic linker. ${configuredHint}`;
@@ -82813,7 +82970,7 @@ var require_path = __commonJS((exports) => {
   function join21(...args) {
     return normalizePath(args.join("/"));
   }
-  function dirname6(path) {
+  function dirname7(path) {
     const result = splitPath(path);
     const root = result[0] || "";
     let dir = result[1];
@@ -82833,7 +82990,7 @@ var require_path = __commonJS((exports) => {
     return f10;
   }
   exports.basename = basename6;
-  exports.dirname = dirname6;
+  exports.dirname = dirname7;
   exports.isAbsolute = isAbsolute;
   exports.join = join21;
   exports.normalizePath = normalizePath;
@@ -124460,7 +124617,7 @@ import { fileURLToPath } from "url";
 // package.json
 var package_default = {
   name: "@automagik/omni",
-  version: "2.260524.1",
+  version: "2.260525.2",
   description: "LLM-optimized CLI for Omni",
   type: "module",
   bin: {
@@ -125965,7 +126122,7 @@ function resolveOmniScopedCredentials() {
 // src/runtime-env.ts
 var LEGACY_DEFAULT_DATABASE_URL = "postgresql://postgres:postgres@localhost:5432/omni";
 var LEGACY_PHASE2_DATABASE_URL = "postgresql://postgres:postgres@localhost:8432/omni";
-var DEFAULT_PGSERVE_PORT = 8432;
+var DEFAULT_PGSERVE_PORT = CANONICAL_PG_PORT;
 function buildEmbeddedDatabaseUrl(pgservePort = DEFAULT_PGSERVE_PORT) {
   return `postgresql://postgres:postgres@localhost:${pgservePort}/omni`;
 }
@@ -128331,7 +128488,7 @@ function createDeadLettersCommand() {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync10, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { existsSync as existsSync10, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
 import { homedir as homedir8 } from "os";
 import { join as join13, resolve } from "path";
 init_config();
@@ -129734,12 +129891,12 @@ init_output();
 
 // src/server-bundle.ts
 init_output();
-import { dirname as dirname2, join as join12 } from "path";
+import { dirname as dirname3, join as join12 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function getServerBundlePath() {
   try {
     const thisFile = fileURLToPath2(import.meta.url);
-    const distDir = dirname2(thisFile);
+    const distDir = dirname3(thisFile);
     return join12(distDir, "server", "index.js");
   } catch {
     return join12(process.cwd(), "dist", "server", "index.js");
@@ -129748,7 +129905,7 @@ function getServerBundlePath() {
 function getServerLauncherPath() {
   try {
     const thisFile = fileURLToPath2(import.meta.url);
-    const distDir = dirname2(thisFile);
+    const distDir = dirname3(thisFile);
     return join12(distDir, "..", "bin", "omni-server");
   } catch {
     return join12(process.cwd(), "bin", "omni-server");
@@ -129920,7 +130077,7 @@ function scanForOrphans(dir, acc, depth, maxDepth = 4) {
     return;
   let entries;
   try {
-    entries = readdirSync2(dir);
+    entries = readdirSync3(dir);
   } catch {
     return;
   }
@@ -130607,7 +130764,7 @@ Safety:
 }
 
 // src/commands/done.ts
-import { existsSync as existsSync11, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync7 } from "fs";
 import { basename, extname } from "path";
 
 // src/context.ts
@@ -130721,7 +130878,7 @@ async function handleMedia(client, ctx, mediaPath, caption) {
   }
   try {
     const mediaType = getMediaType(mediaPath);
-    const buffer = readFileSync6(mediaPath);
+    const buffer = readFileSync7(mediaPath);
     const base64 = buffer.toString("base64");
     const filename = basename(mediaPath);
     await client.messages.sendMedia({
@@ -131241,7 +131398,7 @@ function createFilmCommand() {
 }
 
 // src/commands/follow-up.ts
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 init_output();
 var VALID_SCOPES = ["agents", "instances", "chats"];
 function assertScope(scope) {
@@ -131259,9 +131416,9 @@ async function resolveScopedId(scope, id) {
 function readJsonArg(raw2) {
   let body = raw2;
   if (body === "-") {
-    body = readFileSync7(0, "utf8");
+    body = readFileSync8(0, "utf8");
   } else if (body.startsWith("@")) {
-    body = readFileSync7(body.slice(1), "utf8");
+    body = readFileSync8(body.slice(1), "utf8");
   }
   try {
     return JSON.parse(body);
@@ -131414,7 +131571,7 @@ function createHistoryCommand() {
 
 // src/commands/imagine.ts
 import { writeFileSync as writeFileSync8 } from "fs";
-import { basename as basename2, dirname as dirname3, extname as extname2, join as join14 } from "path";
+import { basename as basename2, dirname as dirname4, extname as extname2, join as join14 } from "path";
 init_output();
 var ALLOWED_ASPECT_RATIOS = ["1:1", "4:3", "3:4", "16:9", "9:16", "3:2", "2:3"];
 function extensionForMime(mimeType) {
@@ -131425,7 +131582,7 @@ function extensionForMime(mimeType) {
   return ".png";
 }
 function buildOutputPath(outputBase, index, total, mimeType) {
-  const dir = dirname3(outputBase);
+  const dir = dirname4(outputBase);
   const ext = extname2(outputBase) || extensionForMime(mimeType);
   const stem = basename2(outputBase, extname2(outputBase));
   if (total <= 1) {
@@ -131549,7 +131706,7 @@ function createImagineCommand() {
 }
 
 // src/commands/install.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync6 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync7 } from "fs";
 import { homedir as homedir9 } from "os";
 import { join as join15 } from "path";
 init_config();
@@ -131659,7 +131816,7 @@ async function startServices(cfg, forceCleanup, forceSystemd, useCanonicalPgserv
   Or build locally: make cli-build-full`);
     return false;
   }
-  mkdirSync6(getPm2LogDir(), { recursive: true });
+  mkdirSync7(getPm2LogDir(), { recursive: true });
   await installPm2Logrotate();
   const runtimeEnv = buildInstallRuntimeEnv(cfg, forceCleanup, useCanonicalPgserve);
   await runPm2(["delete", PM2_PROCESSES.api]);
@@ -131680,7 +131837,7 @@ async function startServices(cfg, forceCleanup, forceSystemd, useCanonicalPgserv
   if (existsSync12(NATS_BINARY_PATH)) {
     const natsSpinner = ora(`Starting ${PM2_PROCESSES.nats}...`).start();
     const natsDataDir = join15(cfg.dataDir, "nats");
-    mkdirSync6(natsDataDir, { recursive: true });
+    mkdirSync7(natsDataDir, { recursive: true });
     const natsArgs = buildPm2StartArgs({
       kind: "nats",
       script: NATS_BINARY_PATH,
@@ -133357,8 +133514,8 @@ function createLogsCommand() {
 }
 
 // src/commands/media.ts
-import { createWriteStream as createWriteStream2, existsSync as existsSync14, mkdirSync as mkdirSync8, statSync as statSync4 } from "fs";
-import { basename as basename4, dirname as dirname4, resolve as resolve2 } from "path";
+import { createWriteStream as createWriteStream2, existsSync as existsSync14, mkdirSync as mkdirSync9, statSync as statSync4 } from "fs";
+import { basename as basename4, dirname as dirname5, resolve as resolve2 } from "path";
 import { Readable } from "stream";
 import { pipeline } from "stream/promises";
 init_config();
@@ -133425,9 +133582,9 @@ function resolveOutputPath(outputPath, result) {
   return resolved;
 }
 async function downloadToFile(url, apiKey, destinationPath) {
-  const destDir = dirname4(destinationPath);
+  const destDir = dirname5(destinationPath);
   if (!existsSync14(destDir))
-    mkdirSync8(destDir, { recursive: true });
+    mkdirSync9(destDir, { recursive: true });
   const resp = await fetch(url, {
     method: "GET",
     headers: apiKey ? { "x-api-key": apiKey } : undefined
@@ -134378,11 +134535,11 @@ init_output();
 
 // src/commands/providers-setup.ts
 init_src();
-import { execFileSync as execFileSync3, execSync } from "child_process";
+import { execFileSync as execFileSync4, execSync } from "child_process";
 import * as nodeCrypto2 from "crypto";
-import { existsSync as existsSync15, mkdirSync as mkdirSync9, readFileSync as readFileSync9, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync10, readFileSync as readFileSync10, writeFileSync as writeFileSync9 } from "fs";
 import { homedir as homedir11 } from "os";
-import { dirname as dirname5, resolve as resolve3 } from "path";
+import { dirname as dirname6, resolve as resolve3 } from "path";
 import { createInterface as createInterface2 } from "readline";
 init_config();
 init_output();
@@ -134613,13 +134770,13 @@ var PLUGIN_MARKER = "plugin-openclaw/omni.ts";
 function readOpenClawConfig(configPath) {
   if (!existsSync15(configPath))
     return {};
-  const raw2 = readFileSync9(configPath, "utf-8").trim();
+  const raw2 = readFileSync10(configPath, "utf-8").trim();
   if (!raw2)
     return {};
   return JSON.parse(raw2);
 }
 function writeOpenClawConfig(configPath, config2) {
-  mkdirSync9(dirname5(configPath), { recursive: true, mode: 448 });
+  mkdirSync10(dirname6(configPath), { recursive: true, mode: 448 });
   writeFileSync9(configPath, `${JSON.stringify(config2, null, 2)}
 `, { mode: 384 });
 }
@@ -134660,7 +134817,7 @@ function resolvePluginPath(explicit) {
 function registerPlugin(config2, pluginPath, configPath) {
   if (hasOpenClawCli()) {
     try {
-      execFileSync3("openclaw", ["plugins", "install", "--link", pluginPath], { stdio: "ignore" });
+      execFileSync4("openclaw", ["plugins", "install", "--link", pluginPath], { stdio: "ignore" });
       try {
         return { config: readOpenClawConfig(configPath), registered: true };
       } catch {
@@ -135705,7 +135862,7 @@ function createSayCommand() {
 }
 
 // src/commands/see.ts
-import { existsSync as existsSync16, readFileSync as readFileSync10, statSync as statSync5 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync11, statSync as statSync5 } from "fs";
 import { extname as extname4 } from "path";
 init_output();
 var MIME_BY_EXT = {
@@ -135748,7 +135905,7 @@ function loadMedia(file) {
     error(`File is empty: ${file}`);
   }
   try {
-    return { buffer: readFileSync10(file), mimeType: guessMimeType(file) };
+    return { buffer: readFileSync11(file), mimeType: guessMimeType(file) };
   } catch (err2) {
     const message2 = err2 instanceof Error ? err2.message : "Unknown error";
     return error(`Failed to read ${file}: ${message2}`);
@@ -135823,7 +135980,7 @@ function createSeeCommand() {
 }
 
 // src/commands/send.ts
-import { existsSync as existsSync17, readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync12 } from "fs";
 import { basename as basename5, extname as extname5 } from "path";
 init_source();
 init_config();
@@ -135843,7 +136000,7 @@ function getMediaType2(path) {
   return "document";
 }
 function readFileAsBase64(path) {
-  const buffer3 = readFileSync11(path);
+  const buffer3 = readFileSync12(path);
   return buffer3.toString("base64");
 }
 var messageSenders = {
@@ -136396,7 +136553,7 @@ function pickFilename(mimeType, provider) {
 }
 
 // src/commands/start.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync10 } from "fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync11 } from "fs";
 import { homedir as homedir12 } from "os";
 import { join as join17 } from "path";
 init_config();
@@ -136412,7 +136569,7 @@ async function runStart() {
   }
   const serverConfig = loadServerConfig();
   const apiPort = serverConfig.port;
-  mkdirSync10(getPm2LogDir(), { recursive: true });
+  mkdirSync11(getPm2LogDir(), { recursive: true });
   info(`Starting ${PM2_PROCESSES.api} (port ${apiPort})...`);
   const cliConfig = loadConfig();
   const env2 = buildRuntimeEnv(serverConfig, cliConfig);
@@ -136432,7 +136589,7 @@ async function runStart() {
   if (existsSync18(natsPath)) {
     info(`Starting ${PM2_PROCESSES.nats}...`);
     const natsDataDir = join17(serverConfig.dataDir, "nats");
-    mkdirSync10(natsDataDir, { recursive: true });
+    mkdirSync11(natsDataDir, { recursive: true });
     const natsArgs = buildPm2StartArgs({
       kind: "nats",
       script: natsPath,
@@ -137135,7 +137292,7 @@ async function cleanupLegacyArtifacts(skipList) {
 init_output();
 
 // src/update-diagnostics.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync11, readFileSync as readFileSync12, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync12, readFileSync as readFileSync13, writeFileSync as writeFileSync10 } from "fs";
 import { homedir as homedir13 } from "os";
 import { join as join18 } from "path";
 var UPDATE_DIAGNOSTICS_SCHEMA_VERSION = 1;
@@ -137170,7 +137327,7 @@ function tailFileLines(path, maxLines) {
   if (!existsSync19(path))
     return [];
   try {
-    const raw2 = readFileSync12(path, "utf8");
+    const raw2 = readFileSync13(path, "utf8");
     const lines = raw2.split(/\r?\n/);
     if (lines.length > 0 && lines[lines.length - 1] === "")
       lines.pop();
@@ -137204,7 +137361,7 @@ function writeDiagnostics(state, exitCode) {
   const path = getDiagnosticsPath(state.startedAt);
   try {
     if (!existsSync19(dir)) {
-      mkdirSync11(dir, { recursive: true, mode: 448 });
+      mkdirSync12(dir, { recursive: true, mode: 448 });
     }
     writeFileSync10(path, `${JSON.stringify(state, null, 2)}
 `, { mode: 384 });
@@ -137784,9 +137941,9 @@ function createVoiceCommand() {
     const startTime = Date.now();
     let saveDir = "";
     if (opts.save) {
-      const { mkdirSync: mkdirSync12 } = await import("fs");
+      const { mkdirSync: mkdirSync13 } = await import("fs");
       saveDir = opts.save;
-      mkdirSync12(saveDir, { recursive: true });
+      mkdirSync13(saveDir, { recursive: true });
       info(`Saving audio to: ${saveDir}`);
     }
     ws.onopen = () => {
@@ -138010,7 +138167,7 @@ init_config();
 init_output();
 
 // src/manifest-pin.ts
-import { existsSync as existsSync21, readFileSync as readFileSync13, renameSync as renameSync3, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync14, renameSync as renameSync3, writeFileSync as writeFileSync11 } from "fs";
 import { homedir as homedir14 } from "os";
 import { join as join20 } from "path";
 var PACKAGE_NAME2 = "@automagik/omni";
@@ -138020,7 +138177,7 @@ function pinManifestEntry(manifestPath, exactVersion) {
     return false;
   let manifest;
   try {
-    manifest = JSON.parse(readFileSync13(manifestPath, "utf-8"));
+    manifest = JSON.parse(readFileSync14(manifestPath, "utf-8"));
   } catch {
     return false;
   }
@@ -138095,7 +138252,7 @@ function getConfigSummary() {
 
 // src/telemetry.ts
 init_config();
-import { arch, platform, release } from "os";
+import { arch as arch2, platform as platform2, release } from "os";
 var OMNI_SENTRY_DSN = "https://2b2ca6f407e3d13409aa7dd8d12483f2@o4509714066571264.ingest.us.sentry.io/4510982636371968";
 var SENSITIVE_FLAGS = new Set([
   "--api-key",
@@ -138177,8 +138334,8 @@ function ensureSentry() {
       }
     });
     Sentry.setTag("cli.version", VERSION);
-    Sentry.setTag("os.platform", platform());
-    Sentry.setTag("os.arch", arch());
+    Sentry.setTag("os.platform", platform2());
+    Sentry.setTag("os.arch", arch2());
     Sentry.setTag("os.release", release());
     Sentry.setTag("runtime", `bun/${process.versions.bun ?? "unknown"}`);
     sentryModule = Sentry;

package/dist/lib/embedded-canonical-migration.d.ts

@@ -24,13 +24,20 @@
  *
  * Solution
  * --------
- * Spawn autopg's bundled `postgres` binary against the unmounted embedded
- * data dir on a free TCP port, copy every public-schema table over to
- * canonical via psql `COPY ... TO STDOUT | COPY ... FROM STDIN` pipes
- * (psql 17 happily connects to a PG18 server — only pg_dump is strict),
- * then shut the temp postmaster down. Postgres version compatibility is
- * sidestepped: both embedded and canonical use the same autopg-bundled
- * postgres binary on this host.
+ * Spawn a matching-major `postgres` reader against the unmounted embedded
+ * data dir on a free TCP port, copy the shared public-schema tables over to
+ * canonical via psql `\copy`, then shut the temp postmaster down.
+ *
+ * Cross-major + cross-schema seamless: a PostgreSQL server can only open a
+ * data dir of its OWN major, so the reader major MUST match the embedded
+ * cluster (e.g. legacy PG17 data → reader PG17 even though canonical is PG18).
+ * {@link resolveReaderForMajor} finds an installed autopg binary of that major
+ * or AUTO-FETCHES one (`@embedded-postgres/<platform>@<major>`, cached under
+ * `~/.omni/cache/`) — the operator never deals with PG versions. The copy is
+ * TEXT format over the INTERSECTION of each table's columns, so it survives
+ * both the major-version wire gap and schema drift between an old embedded
+ * schema and the current canonical one. Install-local auth tables are
+ * preserved (see SKIP_TABLES) so the live CLI key keeps working.
  *
  * Idempotency: caller is expected to gate on `canonical omni DB is
  * empty + embedded dir has data` so re-running this isn't destructive.
@@ -61,6 +68,22 @@ export interface MigrateOptions {
     /** Logger sink — defaults to writing prefixed lines to process.stdout. */
     log?: (line: string) => void;
 }
+/** Read the catalog major (e.g. 17, 18) recorded in a data dir's PG_VERSION. */
+export declare function readDataDirMajor(dataDir: string): number | null;
+/** Compare two `vX.Y.Z`-ish dir names numerically, newest first. */
+export declare function compareVersionDesc(a: string, b: string): number;
+/**
+ * Tables NOT copied embedded→canonical.
+ *  - media_content: large blobs that overflow the COPY pipe; omni-api re-syncs
+ *    media from the source channel on next message.
+ *  - api_keys / api_key_audit_logs: INSTALL-LOCAL auth state the canonical
+ *    install created fresh (the operator's live CLI key). Overwriting them with
+ *    the stale embedded `__primary__` key breaks `omni` CLI auth immediately,
+ *    and copying the audit logs would violate their FK to the preserved keys.
+ */
+export declare const MIGRATION_SKIP_TABLES: Set<string>;
+/** Map the host to its `@embedded-postgres/<platform>` package name. */
+export declare function embeddedPostgresPackage(): string | null;
 /**
  * Public entry point — call this from `omni doctor --fix` when the
  * `embedded-data-orphaned` check FAILs (canonical omni DB empty AND

package/dist/lib/embedded-canonical-migration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"embedded-canonical-migration.d.ts","sourceRoot":"","sources":["../../src/lib/embedded-canonical-migration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAWH,MAAM,MAAM,eAAe,GACvB;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAC1D;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1C,MAAM,WAAW,cAAc;IAC7B,2EAA2E;IAC3E,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,0EAA0E;IAC1E,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9B;AAmPD;;;;;;;;GAQG;AACH;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,mBAAmB,CAAC;IAAC,eAAe,EAAE,MAAM,EAAE,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GAC9E;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAExC,MAAM,WAAW,cAAc;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;GAMG;AACH,wBAAsB,gCAAgC,CAAC,IAAI,GAAE,cAAmB,GAAG,OAAO,CAAC,aAAa,CAAC,CAiDxG;AAED,wBAAsB,mCAAmC,CAAC,IAAI,GAAE,cAAmB,GAAG,OAAO,CAAC,eAAe,CAAC,CAuF7G;AAED,yEAAyE;AACzE,eAAO,MAAM,yBAAyB,QAAe,CAAC"}
+{"version":3,"file":"embedded-canonical-migration.d.ts","sourceRoot":"","sources":["../../src/lib/embedded-canonical-migration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AAWH,MAAM,MAAM,eAAe,GACvB;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAC1D;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1C,MAAM,WAAW,cAAc;IAC7B,2EAA2E;IAC3E,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,0EAA0E;IAC1E,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9B;AAMD,gFAAgF;AAChF,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAO/D;AAoDD,oEAAoE;AACpE,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAS/D;AAUD;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,aAA+D,CAAC;AASlG,wEAAwE;AACxE,wBAAgB,uBAAuB,IAAI,MAAM,GAAG,IAAI,CAOvD;AA6WD;;;;;;;;GAQG;AACH;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,mBAAmB,CAAC;IAAC,eAAe,EAAE,MAAM,EAAE,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GAC9E;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAExC,MAAM,WAAW,cAAc;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;GAMG;AACH,wBAAsB,gCAAgC,CAAC,IAAI,GAAE,cAAmB,GAAG,OAAO,CAAC,aAAa,CAAC,CAyDxG;AAED,wBAAsB,mCAAmC,CAAC,IAAI,GAAE,cAAmB,GAAG,OAAO,CAAC,eAAe,CAAC,CAwG7G;AAED,yEAAyE;AACzE,eAAO,MAAM,yBAAyB,QAAe,CAAC"}

package/dist/runtime-env.d.ts

@@ -46,20 +46,20 @@ export type RuntimeEnv = {
     LOG_LEVEL: string;
 };
 /**
- * Default pgserve port when none is set explicitly.
+ * Default pgserve port when none is set explicitly — the CANONICAL port.
  *
  * Phase 2 of the canonical-pgserve cutover (omni#595/#596/#597) used the
  * bun-bridge port `8432`. Phase 3 (`pgserve-singleton-no-proxy`) lands the
- * postmaster directly on **5432** (canonical postgres port) and listens
- * on the canonical UDS at `$XDG_RUNTIME_DIR/pgserve/.s.PGSQL.5432`.
- *
- * Kept as the module-level default for backwards compatibility with the
- * stored `~/.omni/config.json` entries that still record `8432`. Use
- * {@link resolveDatabaseUrl} as the entry point — it prefers the canonical
- * UDS when available and falls back to the legacy port only when the
- * socket is missing AND the operator hasn't migrated their config.
+ * postmaster directly on **5432** (the canonical postgres port) and listens
+ * on the canonical UDS at `$XDG_RUNTIME_DIR/pgserve/.s.PGSQL.5432`. There is
+ * no embedded 8432 listener anymore, so the default MUST be canonical — a
+ * hardcoded 8432 here leaked into `resolvePgservePort` (→ the `PGSERVE_PORT`
+ * env that `omni doctor`'s `pgserve-reachable` check probes), making doctor
+ * false-FAIL "cannot connect to pgserve on :8432" on every healthy host.
+ * Stored `8432` entries in `~/.omni/config.json` are treated as a stale
+ * default and re-resolved by {@link resolveDatabaseUrl} (UDS-first).
  */
-export declare const DEFAULT_PGSERVE_PORT = 8432;
+export declare const DEFAULT_PGSERVE_PORT = 5432;
 /** Canonical postgres TCP port the postmaster binds in singleton mode. */
 export { CANONICAL_PG_PORT } from './lib/pgserve-transport.js';
 /**
@@ -77,9 +77,13 @@ export declare function buildEmbeddedDatabaseUrl(pgservePort?: number): string;
 export declare function buildCanonicalSocketDatabaseUrl(): string;
 /**
  * Extract the effective pgserve port. Honors an explicit override on the
- * server config first (`server.pgservePort`, if ever added), then the
- * hard-coded default. This function intentionally does NOT read
- * `process.env.PGSERVE_PORT` — env pollution is the bug we're fixing.
+ * server config first (`server.pgservePort`), then falls back to
+ * {@link DEFAULT_PGSERVE_PORT} — which is now the CANONICAL port (5432), not
+ * the legacy 8432. This value feeds the runtime `PGSERVE_PORT` env that
+ * `omni doctor`'s `pgserve-reachable` check probes.
+ *
+ * This function intentionally does NOT read `process.env.PGSERVE_PORT` —
+ * env pollution is the bug we're fixing.
  */
 export declare function resolvePgservePort(serverConfig: ServerConfig): number;
 /**

package/dist/runtime-env.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-env.d.ts","sourceRoot":"","sources":["../src/runtime-env.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AASxD;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IAQrB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAQF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,OAAO,CAAC;AAEzC,0EAA0E;AAC1E,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAE/D;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,WAAW,GAAE,MAA6B,GAAG,MAAM,CAE3F;AAED;;;;;GAKG;AACH,wBAAgB,+BAA+B,IAAI,MAAM,CAKxD;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,YAAY,GAAG,MAAM,CAMrE;AAgBD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,YAAY,GAAG,MAAM,CAiBrE;AAoBD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,GAAG,UAAU,CAqCzF"}
+{"version":3,"file":"runtime-env.d.ts","sourceRoot":"","sources":["../src/runtime-env.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AASxD;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IAQrB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAQF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,OAAoB,CAAC;AAEtD,0EAA0E;AAC1E,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAE/D;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,WAAW,GAAE,MAA6B,GAAG,MAAM,CAE3F;AAED;;;;;GAKG;AACH,wBAAgB,+BAA+B,IAAI,MAAM,CAKxD;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,YAAY,GAAG,MAAM,CAMrE;AAgBD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,YAAY,GAAG,MAAM,CAiBrE;AAoBD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,GAAG,UAAU,CAqCzF"}

package/dist/server/index.js

@@ -230186,7 +230186,7 @@ var init_sentry_scrub = __esm(() => {
 var require_package8 = __commonJS((exports, module) => {
   module.exports = {
     name: "@omni/api",
-    version: "2.260524.1",
+    version: "2.260525.2",
     type: "module",
     exports: {
       ".": {
@@ -330333,6 +330333,7 @@ class MessageService {
       status,
       hasMedia,
       senderPersonId,
+      externalId,
       since,
       until,
       search,
@@ -330357,6 +330358,8 @@ class MessageService {
       conditions3.push(eq(messages2.hasMedia, hasMedia));
     if (senderPersonId)
       conditions3.push(eq(messages2.senderPersonId, senderPersonId));
+    if (externalId)
+      conditions3.push(eq(messages2.externalId, externalId));
     if (since)
       conditions3.push(gte(messages2.platformTimestamp, since));
     if (until)
@@ -349864,6 +349867,7 @@ var init_messages5 = __esm(() => {
     status: exports_external.string().optional().transform((v2) => v2?.split(",")),
     hasMedia: exports_external.coerce.boolean().optional(),
     senderPersonId: exports_external.string().uuid().optional(),
+    externalId: exports_external.string().min(1).optional(),
     since: optionalDateParam("since"),
     until: optionalDateParam("until"),
     search: exports_external.string().optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automagik/omni",
-  "version": "2.260524.1",
+  "version": "2.260525.2",
   "description": "LLM-optimized CLI for Omni",
   "type": "module",
   "bin": {