@withone/cli 1.57.0 → 1.57.1

package/README.md

@@ -377,7 +377,7 @@ Note: execution responses are never cached — the action always runs live. Only
 
 ### `one mem` — unified memory store
 
-One ships a local memory store (a real Postgres process bootstrapped on demand via the bundled `embedded-postgres` plugin, with a `postgres` plugin for remote/self-hosted) that backs both user-authored notes and synced platform data. **Zero-config** — the first `one mem` call on a fresh machine auto-initializes the cluster at `~/.one/pg/cluster/` and writes a daemon PID file so subsequent CLI invocations reuse it.
+One ships a local memory store (a real Postgres process bootstrapped on demand via the bundled `embedded-postgres` plugin, with a `postgres` plugin for remote/self-hosted) that backs both user-authored notes and synced platform data. **Zero-config** — the first `one mem` call on a fresh machine auto-initializes the cluster at `~/.one/pg/cluster/` and writes a daemon PID file so subsequent CLI invocations reuse it. The daemon listens on port 5434, moving to the next free port if another program already holds it; pin a port with `one mem config set embedded-postgres.port <n>`.
 
 ```bash
 # User memories — works immediately on a new install

package/dist/{chunk-KAF5SVJS.js → chunk-GKAIRI4Y.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-OLQ55K6B.js";
 import {
   getBackend
-} from "./chunk-VH46MAE4.js";
+} from "./chunk-IMU2X3ZV.js";
 
 // src/commands/mem/sql.ts
 async function memSqlCommand(sql) {

package/dist/{chunk-VH46MAE4.js → chunk-IMU2X3ZV.js}

@@ -1456,12 +1456,333 @@ var postgresPlugin = {
 };
 
 // src/lib/memory/plugins/embedded-postgres/index.ts
+import path2 from "path";
+
+// src/lib/memory/plugins/embedded-postgres/daemon.ts
 import fs from "fs";
 import net from "net";
 import path from "path";
 import { createRequire } from "module";
-import { spawn } from "child_process";
+import { spawn, spawnSync } from "child_process";
 var requireFromHere = createRequire(import.meta.url);
+var PG_PORT_OFFSET = 1e3;
+var PORT_SEARCH_SPAN = 20;
+var LOG_MAX_BYTES = 10 * 1024 * 1024;
+var LOG_KEEP_BYTES = 1024 * 1024;
+var DEFAULT_STOP_TIMEOUT_MS = 15e3;
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function pidFilePath(dataDir) {
+  return path.join(dataDir, ".pgserve.json");
+}
+function readPidFile(dataDir) {
+  try {
+    return JSON.parse(fs.readFileSync(pidFilePath(dataDir), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writePidFile(dataDir, rec) {
+  fs.mkdirSync(dataDir, { recursive: true });
+  fs.writeFileSync(pidFilePath(dataDir), JSON.stringify(rec, null, 2), { mode: 384 });
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function waitForExit(pid, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (isPidAlive(pid)) {
+    if (Date.now() >= deadline) return false;
+    await sleep(50);
+  }
+  return true;
+}
+function signal(pid, sig) {
+  try {
+    process.kill(pid, sig);
+  } catch {
+  }
+}
+function canBind(host, port) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once("error", () => resolve(false));
+    server.listen({ port, host, exclusive: true }, () => server.close(() => resolve(true)));
+  });
+}
+async function portPairFree(host, port) {
+  return port + PG_PORT_OFFSET <= 65535 && await canBind(host, port) && await canBind("127.0.0.1", port + PG_PORT_OFFSET);
+}
+async function choosePort(host, preferred, explicit) {
+  if (await portPairFree(host, preferred)) return preferred;
+  const hint = 'set a different "memory.embedded-postgres.port" in ~/.one/config.json';
+  if (explicit) {
+    throw new Error(
+      `Port ${preferred} (or ${preferred + PG_PORT_OFFSET}, its internal Postgres port) on ${host} is already in use by another program, so the embedded Postgres can't start there. Free it, or ${hint}.`
+    );
+  }
+  for (let port = preferred + 1; port <= preferred + PORT_SEARCH_SPAN; port++) {
+    if (await portPairFree(host, port)) return port;
+  }
+  throw new Error(
+    `Ports ${preferred}-${preferred + PORT_SEARCH_SPAN} on ${host} are all already in use, so the embedded Postgres can't start. Free one, or ${hint}.`
+  );
+}
+function readRange(file, start, length) {
+  const fd = fs.openSync(file, "r");
+  try {
+    const buf = Buffer.alloc(length);
+    const n = fs.readSync(fd, buf, 0, length, start);
+    return buf.subarray(0, n);
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+function fileSize(file) {
+  try {
+    return fs.statSync(file).size;
+  } catch {
+    return 0;
+  }
+}
+function trimLog(logPath, maxBytes = LOG_MAX_BYTES, keepBytes = LOG_KEEP_BYTES) {
+  const size = fileSize(logPath);
+  if (size <= maxBytes) return;
+  const tail = readRange(logPath, size - keepBytes, keepBytes);
+  const nl = tail.indexOf(10);
+  const kept = nl === -1 ? tail : tail.subarray(nl + 1);
+  const notice = `[one] pgserve.log passed ${maxBytes} bytes; kept the last ${kept.length} (${(/* @__PURE__ */ new Date()).toISOString()})
+`;
+  fs.writeFileSync(logPath, Buffer.concat([Buffer.from(notice), kept]));
+}
+function logSince(logPath, offset, maxBytes = 2e3) {
+  const size = fileSize(logPath);
+  const start = Math.max(offset, size - maxBytes);
+  if (size <= start) return "";
+  return readRange(logPath, start, size - start).toString("utf8").replace(/\x1b\[[0-9;]*m/g, "").trim();
+}
+function lockIsStale(lockPath, ttlMs) {
+  try {
+    if (Date.now() - fs.statSync(lockPath).mtimeMs > ttlMs) return true;
+    const { pid } = JSON.parse(fs.readFileSync(lockPath, "utf8"));
+    return typeof pid === "number" && !isPidAlive(pid);
+  } catch {
+    return false;
+  }
+}
+async function withStartupLock(dataDir, waitMs, fn) {
+  const lockPath = path.join(dataDir, ".pgserve.lock");
+  const deadline = Date.now() + waitMs;
+  for (; ; ) {
+    try {
+      fs.writeFileSync(lockPath, JSON.stringify({ pid: process.pid, startedAt: Date.now() }), { flag: "wx" });
+      break;
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+    }
+    if (lockIsStale(lockPath, waitMs)) {
+      fs.rmSync(lockPath, { force: true });
+      continue;
+    }
+    if (Date.now() >= deadline) {
+      throw new Error(`Timed out waiting for another \`one\` process to start the embedded Postgres (lock: ${lockPath}).`);
+    }
+    await sleep(100);
+  }
+  try {
+    return await fn();
+  } finally {
+    fs.rmSync(lockPath, { force: true });
+  }
+}
+function readPostmasterPid(clusterDir) {
+  try {
+    const lines = fs.readFileSync(path.join(clusterDir, "postmaster.pid"), "utf8").split("\n");
+    const pid = Number.parseInt(lines[0] ?? "", 10);
+    const port = Number.parseInt(lines[3] ?? "", 10);
+    return pid > 0 && port > 0 ? { pid, port } : null;
+  } catch {
+    return null;
+  }
+}
+function pgserveOwner(postmasterPid, deps) {
+  const ppid = deps.processInfo(postmasterPid)?.ppid;
+  if (!ppid || ppid <= 1) return null;
+  const command = deps.processInfo(ppid)?.command ?? "";
+  return /pgserve[\\/]bin[\\/]postgres-server\.js/.test(command) ? ppid : null;
+}
+async function stopStaleCluster(clusterDir, deps, timeoutMs) {
+  const holder = readPostmasterPid(clusterDir);
+  if (!holder || !isPidAlive(holder.pid)) return;
+  if (await deps.probe(holder.port, "postmaster") !== "ours") return;
+  const owner = pgserveOwner(holder.pid, deps);
+  if (owner !== null) {
+    signal(owner, "SIGTERM");
+    if (!await waitForExit(owner, timeoutMs)) signal(owner, "SIGKILL");
+  }
+  if (!isPidAlive(holder.pid)) return;
+  signal(holder.pid, "SIGINT");
+  if (!await waitForExit(holder.pid, timeoutMs)) {
+    throw new Error(
+      `The embedded Postgres (PID ${holder.pid}) is holding ${clusterDir} and did not stop. Stop it (kill ${holder.pid}) and retry.`
+    );
+  }
+}
+async function findHealthyDaemon(dataDir, deps) {
+  const rec = readPidFile(dataDir);
+  if (!rec || !isPidAlive(rec.pid)) return null;
+  return await deps.probe(rec.port, "router") === "ours" ? rec.port : null;
+}
+function pgserveArgs(cfg, clusterDir, port) {
+  const args = [
+    "--data",
+    clusterDir,
+    "--port",
+    String(port),
+    "--host",
+    cfg.host,
+    "--log",
+    cfg.logLevel,
+    "--no-stats",
+    // Single process. In cluster mode a worker that can't bind the port is
+    // re-forked immediately, forever, each crash logging a full stack trace.
+    "--no-cluster"
+  ];
+  if (cfg.pgvector) args.push("--pgvector");
+  return args;
+}
+async function waitUntilServing(child, cfg, port, deps, log) {
+  const deadline = Date.now() + cfg.startupTimeoutMs;
+  const details = () => {
+    const tail = logSince(log.path, log.offset);
+    return `
+Log: ${log.path}${tail ? `
+${tail}` : ""}`;
+  };
+  for (; ; ) {
+    const exit = child.exitStatus();
+    if (exit) throw new Error(`pgserve exited (${exit}) before it was ready.${details()}`);
+    if (await deps.probe(port, "router") === "ours") return;
+    if (Date.now() >= deadline) {
+      throw new Error(
+        `pgserve did not start serving on ${cfg.host}:${port} within ${Math.round(cfg.startupTimeoutMs / 1e3)}s.${details()}`
+      );
+    }
+    await sleep(250);
+  }
+}
+async function ensureRunning(cfg, deps) {
+  const reused = await findHealthyDaemon(cfg.dataDir, deps);
+  if (reused !== null) return reused;
+  fs.mkdirSync(cfg.dataDir, { recursive: true });
+  const stopTimeoutMs = deps.stopTimeoutMs ?? DEFAULT_STOP_TIMEOUT_MS;
+  return withStartupLock(cfg.dataDir, cfg.startupTimeoutMs + 3 * stopTimeoutMs, async () => {
+    const raced = await findHealthyDaemon(cfg.dataDir, deps);
+    if (raced !== null) return raced;
+    const clusterDir = path.join(cfg.dataDir, "cluster");
+    fs.mkdirSync(clusterDir, { recursive: true });
+    await stopStaleCluster(clusterDir, deps, stopTimeoutMs);
+    const port = await choosePort(cfg.host, cfg.port, cfg.portExplicit);
+    const logPath = path.join(cfg.dataDir, "pgserve.log");
+    trimLog(logPath);
+    const log = { path: logPath, offset: fileSize(logPath) };
+    const fd = fs.openSync(logPath, "a");
+    let child;
+    try {
+      child = deps.spawnPgserve(pgserveArgs(cfg, clusterDir, port), fd);
+    } finally {
+      fs.closeSync(fd);
+    }
+    await waitUntilServing(child, cfg, port, deps, log);
+    writePidFile(cfg.dataDir, {
+      pid: child.pid,
+      port,
+      dataDir: cfg.dataDir,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return port;
+  });
+}
+function sameDir(a, b) {
+  const norm = (p) => {
+    let r = path.resolve(p);
+    try {
+      r = fs.realpathSync.native(r);
+    } catch {
+    }
+    return process.platform === "win32" ? r.toLowerCase() : r;
+  };
+  return a !== "" && norm(a) === norm(b);
+}
+async function probeDataDirectory(Client, target, clusterDir) {
+  const client = new Client({ ...target, connectionTimeoutMillis: 3e3, query_timeout: 3e3 });
+  client.on("error", () => {
+  });
+  try {
+    await client.connect();
+  } catch (err) {
+    return err.code === "ECONNREFUSED" ? "down" : "other";
+  }
+  try {
+    const { rows } = await client.query("SHOW data_directory");
+    return sameDir(String(rows[0]?.data_directory ?? ""), clusterDir) ? "ours" : "other";
+  } catch {
+    return "other";
+  } finally {
+    await client.end().catch(() => {
+    });
+  }
+}
+function resolvePgserveBin() {
+  const pkg = requireFromHere.resolve("pgserve/package.json");
+  return path.resolve(path.dirname(pkg), "bin/pgserve-wrapper.cjs");
+}
+function spawnPgserve(args, logFd, cwd) {
+  const child = spawn(process.execPath, [resolvePgserveBin(), ...args], {
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    // pgserve resolves the bundled bun binary relative to its own package
+    // location, not cwd, so cwd doesn't matter — but pin it for clarity.
+    cwd
+  });
+  let status = null;
+  child.once("error", (err) => {
+    status = `failed to start: ${err.message}`;
+  });
+  child.once("exit", (code, sig) => {
+    status = sig ? `signal ${sig}` : `code ${code}`;
+  });
+  child.unref();
+  if (typeof child.pid !== "number") {
+    throw new Error("Failed to spawn pgserve \u2014 no PID returned.");
+  }
+  return { pid: child.pid, exitStatus: () => status };
+}
+function processInfo(pid) {
+  if (process.platform === "win32") return null;
+  const res = spawnSync("ps", ["-o", "ppid=", "-o", "command=", "-p", String(pid)], { encoding: "utf8" });
+  const match = /^(\d+)\s+(.*)$/.exec((res.stdout ?? "").trim());
+  return match ? { ppid: Number(match[1]), command: match[2] } : null;
+}
+function nodeDaemonDeps(cfg, Client, router) {
+  const clusterDir = path.join(cfg.dataDir, "cluster");
+  const direct = { user: "postgres", password: "postgres", database: "postgres" };
+  return {
+    probe: (port, via) => probeDataDirectory(
+      Client,
+      via === "router" ? { host: cfg.host, port, ...router } : { host: "127.0.0.1", port, ...direct },
+      clusterDir
+    ),
+    spawnPgserve: (args, logFd) => spawnPgserve(args, logFd, cfg.dataDir),
+    processInfo
+  };
+}
+
+// src/lib/memory/plugins/embedded-postgres/index.ts
 var BASE_CAPABILITIES = {
   vectorSearch: true,
   fullTextSearch: true,
@@ -1477,13 +1798,14 @@ var DEFAULTS = {
   // `path.join(homeDir(), ...)` here would capture the home directory before
   // ONE_HOME could take effect. See lib/home.ts.
   get dataDir() {
-    return path.join(homeDir(), ".one", "pg");
+    return path2.join(homeDir(), ".one", "pg");
   },
   database: "one_mem",
   schema: "public",
   pgvector: true,
   host: "127.0.0.1",
   port: 5434,
+  portExplicit: false,
   // pgserve auto-provisions databases; the bundled superuser is `postgres`
   // with no password by default. We don't expose the password to the user
   // since the daemon only listens on 127.0.0.1.
@@ -1501,6 +1823,7 @@ function parseConfig2(raw) {
     pgvector: r.pgvector ?? DEFAULTS.pgvector,
     host: r.host ?? DEFAULTS.host,
     port: r.port ?? DEFAULTS.port,
+    portExplicit: r.port !== void 0,
     user: r.user ?? DEFAULTS.user,
     password: r.password ?? DEFAULTS.password,
     logLevel: r.logLevel ?? DEFAULTS.logLevel,
@@ -1547,104 +1870,6 @@ function wrapClient2(pool) {
     }
   };
 }
-function pidFilePath(dataDir) {
-  return path.join(dataDir, ".pgserve.json");
-}
-function readPidFile(dataDir) {
-  try {
-    const raw = fs.readFileSync(pidFilePath(dataDir), "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-function writePidFile(dataDir, rec) {
-  fs.mkdirSync(dataDir, { recursive: true });
-  fs.writeFileSync(pidFilePath(dataDir), JSON.stringify(rec, null, 2), { mode: 384 });
-}
-function isPidAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function isPortListening(host, port, timeoutMs = 1e3) {
-  return new Promise((resolve) => {
-    const socket = new net.Socket();
-    let resolved = false;
-    const finish = (ok) => {
-      if (resolved) return;
-      resolved = true;
-      socket.destroy();
-      resolve(ok);
-    };
-    socket.setTimeout(timeoutMs);
-    socket.once("connect", () => finish(true));
-    socket.once("timeout", () => finish(false));
-    socket.once("error", () => finish(false));
-    socket.connect(port, host);
-  });
-}
-async function waitForPort(host, port, deadlineAt) {
-  while (Date.now() < deadlineAt) {
-    if (await isPortListening(host, port)) return;
-    await new Promise((r) => setTimeout(r, 250));
-  }
-  throw new Error(
-    `pgserve did not start listening on ${host}:${port} within ${Math.round((deadlineAt - Date.now() + 3e4) / 1e3)}s. Check the data dir for the postgres log, or remove ${path.basename(pidFilePath("<dataDir>"))} and retry.`
-  );
-}
-function resolvePgserveBin() {
-  const pkg = requireFromHere.resolve("pgserve/package.json");
-  return path.resolve(path.dirname(pkg), "bin/pgserve-wrapper.cjs");
-}
-async function ensureRunning(cfg) {
-  const existing = readPidFile(cfg.dataDir);
-  if (existing && isPidAlive(existing.pid)) {
-    if (await isPortListening(cfg.host, existing.port)) {
-      cfg.port = existing.port;
-      return;
-    }
-  }
-  fs.mkdirSync(cfg.dataDir, { recursive: true });
-  const clusterDir = path.join(cfg.dataDir, "cluster");
-  fs.mkdirSync(clusterDir, { recursive: true });
-  const args = [
-    "--data",
-    clusterDir,
-    "--port",
-    String(cfg.port),
-    "--host",
-    cfg.host,
-    "--log",
-    cfg.logLevel,
-    "--no-stats"
-  ];
-  if (cfg.pgvector) args.push("--pgvector");
-  const bin = resolvePgserveBin();
-  const out = fs.openSync(path.join(cfg.dataDir, "pgserve.log"), "a");
-  const child = spawn(process.execPath, [bin, ...args], {
-    detached: true,
-    stdio: ["ignore", out, out],
-    // pgserve resolves the bundled bun binary relative to its own package
-    // location, not cwd, so cwd doesn't matter — but pin it for clarity.
-    cwd: cfg.dataDir
-  });
-  child.unref();
-  if (typeof child.pid !== "number") {
-    throw new Error("Failed to spawn pgserve \u2014 no PID returned.");
-  }
-  const deadlineAt = Date.now() + cfg.startupTimeoutMs;
-  await waitForPort(cfg.host, cfg.port, deadlineAt);
-  writePidFile(cfg.dataDir, {
-    pid: child.pid,
-    port: cfg.port,
-    dataDir: cfg.dataDir,
-    startedAt: (/* @__PURE__ */ new Date()).toISOString()
-  });
-}
 async function probePgvector(client) {
   try {
     await client.query("CREATE EXTENSION IF NOT EXISTS vector");
@@ -1662,12 +1887,20 @@ var LazyEmbeddedPostgresBackend = class {
   }
   async ensure() {
     if (this.backend) return this.backend;
-    await ensureRunning(this.config);
     const pgMod = await import("pg").catch((err) => {
       const msg = err instanceof Error ? err.message : String(err);
       throw new Error(`pg is not installed. Run \`npm i pg\` or pick a different backend. (${msg})`);
     });
-    const PoolCtor = pgMod.Pool ?? pgMod.default.Pool;
+    const pgExports = pgMod.Pool ? pgMod : pgMod.default;
+    const PoolCtor = pgExports.Pool;
+    this.config.port = await ensureRunning(
+      this.config,
+      nodeDaemonDeps(this.config, pgExports.Client, {
+        user: this.config.user,
+        password: this.config.password,
+        database: this.config.database
+      })
+    );
     const pool = new PoolCtor({
       host: this.config.host,
       port: this.config.port,

package/dist/{chunk-XWTV7FA3.js → chunk-YTM6HJKA.js}

@@ -10,7 +10,7 @@ import {
 import {
   getBackend,
   upsertRecord
-} from "./chunk-VH46MAE4.js";
+} from "./chunk-IMU2X3ZV.js";
 
 // src/commands/mem/migrate.ts
 import fs4 from "fs";

package/dist/index.js

@@ -35,7 +35,7 @@ import {
 } from "./chunk-QCXFSOTS.js";
 import {
   memSqlCommand
-} from "./chunk-KAF5SVJS.js";
+} from "./chunk-GKAIRI4Y.js";
 import {
   collectIdentityKeys,
   countRecords,
@@ -66,7 +66,7 @@ import {
   writeDraftProfile,
   writePageToMemory,
   writeProfile
-} from "./chunk-XWTV7FA3.js";
+} from "./chunk-YTM6HJKA.js";
 import {
   getByDotPath
 } from "./chunk-44CV5IMX.js";
@@ -100,7 +100,7 @@ import {
   listBackendPlugins,
   loadBackendFromConfig,
   updateRecord
-} from "./chunk-VH46MAE4.js";
+} from "./chunk-IMU2X3ZV.js";
 import {
   DEFAULT_MEMORY_CONFIG,
   defaultSearchableText,
@@ -7231,7 +7231,7 @@ async function syncModel(api, profile, options) {
         updateModelState(platform, model, { status: "failed", pagesProcessed, lastCursor }),
         (async () => {
           try {
-            const { getBackend: getBackend2 } = await import("./runtime-65IPTPVD.js");
+            const { getBackend: getBackend2 } = await import("./runtime-SX36HGBA.js");
             const backend = await getBackend2();
             await Promise.race([
               backend.close(),
@@ -7597,7 +7597,7 @@ async function syncModel(api, profile, options) {
         db.exec(`DROP TABLE IF EXISTS _seen_ids`);
       }
       if (options.toMemory !== false) {
-        const backend = await (await import("./runtime-65IPTPVD.js")).getBackend();
+        const backend = await (await import("./runtime-SX36HGBA.js")).getBackend();
         const type = `${platform}/${model}`;
         const existing = await backend.listKeysByType(type);
         const sourcePrefix = `${type}:`;
@@ -7698,7 +7698,7 @@ async function syncModel(api, profile, options) {
     let statusCounts;
     if (options.toMemory !== false) {
       try {
-        const backend = await (await import("./runtime-65IPTPVD.js")).getBackend();
+        const backend = await (await import("./runtime-SX36HGBA.js")).getBackend();
         const typeName = `${platform}/${model}`;
         const [active, archived] = await Promise.all([
           backend.count(typeName, { status: "active" }),
@@ -9420,7 +9420,7 @@ ${result.total} results`);
   }
 }
 async function syncSqlCommand(platformModel, sql) {
-  const { syncSqlCommand: runSyncSql } = await import("./sql-QIVDWTL3.js");
+  const { syncSqlCommand: runSyncSql } = await import("./sql-SYCWUPNP.js");
   await runSyncSql(platformModel, sql);
 }
 async function syncDeleteCommand(platformModel, options) {
@@ -9498,7 +9498,7 @@ async function syncDeleteCommand(platformModel, options) {
 async function maybeAutoMigrateLegacy(platform, models) {
   const dbSize = getDatabaseSize(platform);
   if (!dbSize || dbSize === "0 B") return;
-  const { getBackend: getBackend2 } = await import("./runtime-65IPTPVD.js");
+  const { getBackend: getBackend2 } = await import("./runtime-SX36HGBA.js");
   const backend = await getBackend2();
   let memoryHasData = false;
   for (const model of models) {
@@ -9514,7 +9514,7 @@ async function maybeAutoMigrateLegacy(platform, models) {
       `  detected legacy .one/sync/data/${platform}.db (${dbSize}) \u2014 auto-migrating into memory before sync.
 `
     );
-    const { memMigrateCommand: memMigrateCommand3 } = await import("./migrate-IJI3BTWL.js");
+    const { memMigrateCommand: memMigrateCommand3 } = await import("./migrate-TACDLGPD.js");
     await memMigrateCommand3({ platform, yes: true });
     return;
   }
@@ -9523,7 +9523,7 @@ async function maybeAutoMigrateLegacy(platform, models) {
     initialValue: true
   });
   if (p7.isCancel(shouldMigrate) || !shouldMigrate) return;
-  const { memMigrateCommand: memMigrateCommand2 } = await import("./migrate-IJI3BTWL.js");
+  const { memMigrateCommand: memMigrateCommand2 } = await import("./migrate-TACDLGPD.js");
   await memMigrateCommand2({ platform, yes: true });
 }
 async function syncSuggestSearchableCommand(platformModel, options = {}) {
@@ -9584,7 +9584,7 @@ async function syncSuggestSearchableCommand(platformModel, options = {}) {
 async function syncListCommand(platform) {
   const profiles = listProfiles(platform);
   const state = await readSyncState();
-  const { getBackend: getBackend2 } = await import("./runtime-65IPTPVD.js");
+  const { getBackend: getBackend2 } = await import("./runtime-SX36HGBA.js");
   const backend = await getBackend2();
   const syncs = await Promise.all(profiles.map(async (p10) => {
     const modelState = state[p10.platform]?.[p10.model];
@@ -9860,7 +9860,7 @@ function registerSyncSubcommands(sync) {
     await syncSqlCommand(platformModel, sql);
   });
   sync.command("schema <platform/model>").description("Inspect the JSON structure of synced records (field paths, types, examples) \u2014 useful before writing `sync sql` queries").action(async (platformModel) => {
-    const { syncSchemaCommand } = await import("./schema-OO4WK5ND.js");
+    const { syncSchemaCommand } = await import("./schema-RJC2WQQ6.js");
     await syncSchemaCommand(platformModel);
   });
   sync.command("delete <platform/model>").description('Delete records from local sync data (e.g. one sync delete notion/pages --id "abc-123")').option("--id <value>", "Delete record by ID").option("--where <conditions>", 'Delete records matching conditions (e.g. "status=archived")').option("--where-sql <predicate>", `Delete using a raw SQL WHERE clause (e.g. "json_extract(data, '$.type') = 'promotion'")`).option("--yes", "Skip confirmation prompt").action(async (platformModel, options) => {
@@ -11627,6 +11627,8 @@ The unified memory store is a local, pluggable database (\`embedded-postgres\` b
 The first \`one mem\` call on a fresh install auto-initializes:
 - Backend: \`embedded-postgres\` (Postgres 18 via pgserve; downloads ~52MB of binaries on first use, ~2s on later boots)
 - Cluster path: \`~/.one/pg/cluster/\`, daemon PID/port at \`~/.one/pg/.pgserve.json\`
+- Port: \`5434\` by default. If another program already holds it (a database tunnel, another Postgres), the daemon starts on the next free port and records it in \`.pgserve.json\`. A port pinned with \`mem config set embedded-postgres.port <n>\` is never moved \u2014 a conflict there is an error naming the port.
+- Self-healing: a running daemon is reused only when the Postgres on its port reports this cluster's data directory. A Postgres left holding the cluster by a dead or stuck pgserve is stopped and a fresh daemon started. \`pgserve.log\` is trimmed to its last 1 MB once it passes 10 MB.
 - Embedding provider: \`openai\` if a key is already resolvable AND pgvector is loadable; else \`none\`
 
 If pgvector isn't installed in the bundled Postgres (the default binary distribution doesn't ship it yet), the schema applies cleanly without an \`embedding\` column, all FTS paths work, and \`mem doctor\` emits an \`_upgrade\` block pointing at \`brew install pgvector\` when an OpenAI key is present.
@@ -12277,8 +12279,9 @@ Every \`sync X\` command is also exposed as \`mem sync X\` \u2014 same handlers,
   logs/{platform}.log                 # cron run logs
   locks/{platform}_{model}/           # cross-process sync locks
 ~/.one/pg/cluster/                    # unified memory store \u2014 embedded Postgres data dir
-~/.one/pg/.pgserve.json               # daemon PID/port file (cleared on stop)
-~/.one/pg/pgserve.log                 # daemon stdout/stderr
+~/.one/pg/.pgserve.json               # daemon PID/port file
+~/.one/pg/.pgserve.lock               # held while a CLI process starts the daemon
+~/.one/pg/pgserve.log                 # daemon stdout/stderr (trimmed to 1 MB past 10 MB)
 ~/.one/config.json                    # apiKey + openaiApiKey + memory config block
 ~/.one/sync/
   schedules.json                      # global schedule registry

package/dist/{migrate-IJI3BTWL.js → migrate-TACDLGPD.js}

@@ -3,10 +3,10 @@ import {
   dotPathToJsonbExpr,
   memMigrateCommand,
   reviveStringifiedJson
-} from "./chunk-XWTV7FA3.js";
+} from "./chunk-YTM6HJKA.js";
 import "./chunk-44CV5IMX.js";
 import "./chunk-OLQ55K6B.js";
-import "./chunk-VH46MAE4.js";
+import "./chunk-IMU2X3ZV.js";
 import "./chunk-YMUY55U2.js";
 import "./chunk-6UB623BG.js";
 export {

package/dist/{runtime-65IPTPVD.js → runtime-SX36HGBA.js}

@@ -5,7 +5,7 @@ import {
   resetBackendSingleton,
   updateRecord,
   upsertRecord
-} from "./chunk-VH46MAE4.js";
+} from "./chunk-IMU2X3ZV.js";
 import "./chunk-YMUY55U2.js";
 import "./chunk-6UB623BG.js";
 export {

package/dist/{schema-OO4WK5ND.js → schema-RJC2WQQ6.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-OLQ55K6B.js";
 import {
   getBackend
-} from "./chunk-VH46MAE4.js";
+} from "./chunk-IMU2X3ZV.js";
 import "./chunk-YMUY55U2.js";
 import "./chunk-6UB623BG.js";
 

package/dist/{sql-QIVDWTL3.js → sql-SYCWUPNP.js}

@@ -1,9 +1,9 @@
 import {
   memSqlCommand,
   syncSqlCommand
-} from "./chunk-KAF5SVJS.js";
+} from "./chunk-GKAIRI4Y.js";
 import "./chunk-OLQ55K6B.js";
-import "./chunk-VH46MAE4.js";
+import "./chunk-IMU2X3ZV.js";
 import "./chunk-YMUY55U2.js";
 import "./chunk-6UB623BG.js";
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@withone/cli",
-  "version": "1.57.0",
+  "version": "1.57.1",
   "description": "CLI for managing One",
   "type": "module",
   "files": [

package/skills/one/SKILL.md

@@ -192,7 +192,7 @@ Knowledge and search responses are cached locally (`~/.one/cache/`). Subsequent
 
 One ships a local memory store (a real Postgres process bootstrapped on demand via the bundled `embedded-postgres` plugin, with a `postgres` plugin available for remote/self-hosted Postgres) that backs both user-authored notes and synced platform data. `one mem <cmd>` is the primary surface; `one sync` is a namespaced alias (`one mem sync ...`) that writes synced rows into the same store.
 
-**Zero-config.** The first `one mem` call on a new machine auto-initializes — no separate `mem init` step required. The `embedded-postgres` plugin downloads its Postgres binaries on first run (~52MB) and writes a daemon PID/port file at `~/.one/pg/.pgserve.json` so subsequent CLI invocations reuse the running cluster. If an OpenAI key is already resolvable (env, `.onerc`, or `config.openaiApiKey`), embeddings enable automatically and search becomes hybrid FTS + semantic. Otherwise you get FTS-only with a structured `_upgrade` hint on every response telling the user how to upgrade.
+**Zero-config.** The first `one mem` call on a new machine auto-initializes — no separate `mem init` step required. The `embedded-postgres` plugin downloads its Postgres binaries on first run (~52MB) and writes a daemon PID/port file at `~/.one/pg/.pgserve.json` so subsequent CLI invocations reuse the running cluster. The daemon listens on 5434, or the next free port if another program holds it; pin one with `one --agent mem config set embedded-postgres.port <n>` (a conflict on a pinned port is an error, not a silent move). If an OpenAI key is already resolvable (env, `.onerc`, or `config.openaiApiKey`), embeddings enable automatically and search becomes hybrid FTS + semantic. Otherwise you get FTS-only with a structured `_upgrade` hint on every response telling the user how to upgrade.
 
 **Listing synced rows.** `mem list <type>` takes a positional namespaced type — there is no `--platform` flag. Synced rows live under `<platform>/<model>` types: