@hasna/mementos 0.14.47 → 0.14.49

package/dist/index.js

@@ -51,6 +51,8 @@ import { Database } from "bun:sqlite";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
+import { fileURLToPath } from "url";
+import { Worker } from "worker_threads";
 import pg from "pg";
 function normalizeParams(params) {
   const flat = params.length === 1 && Array.isArray(params[0]) ? params[0] : params;
@@ -113,13 +115,15 @@ class SqliteAdapter {
 function translateSql(sql) {
   let parameterIndex = 0;
   let translated = sql.replace(/\?/g, () => `$${++parameterIndex}`);
-  translated = translated.replace(/datetime\s*\(\s*'now'\s*\)/gi, "NOW()");
+  const ISO_FMT = `'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"'`;
+  translated = translated.replace(/datetime\s*\(\s*'now'\s*\)/gi, `to_char(now() AT TIME ZONE 'UTC', ${ISO_FMT})`);
   translated = translated.replace(/datetime\s*\(\s*'now'\s*,\s*'(-?\d+)\s+(minutes?|hours?|days?|seconds?)'\s*\)/gi, (_match, amount, unit) => {
     const parsed = parseInt(String(amount), 10);
     const absolute = Math.abs(parsed);
     const normalizedUnit = String(unit).toLowerCase().replace(/s$/, "");
     const pluralUnit = absolute === 1 ? normalizedUnit : `${normalizedUnit}s`;
-    return parsed < 0 ? `NOW() - INTERVAL '${absolute} ${pluralUnit}'` : `NOW() + INTERVAL '${absolute} ${pluralUnit}'`;
+    const op = parsed < 0 ? "-" : "+";
+    return `to_char((now() ${op} INTERVAL '${absolute} ${pluralUnit}') AT TIME ZONE 'UTC', ${ISO_FMT})`;
   });
   translated = translated.replace(/lower\s*\(\s*hex\s*\(\s*randomblob\s*\(\s*\d+\s*\)\s*\)\s*\)/gi, "gen_random_uuid()::text");
   translated = translated.replace(/\bIFNULL\s*\(/gi, "COALESCE(");
@@ -176,56 +180,24 @@ function makePool(connectionString) {
 class PgAdapter {
   pool;
   constructor(input) {
-    this.pool = typeof input === "string" ? makePool(input) : input;
-  }
-  runSync(fn) {
-    let result;
-    let error;
-    let done = false;
-    fn().then((value) => {
-      result = value;
-      done = true;
-    }).catch((caught) => {
-      error = caught;
-      done = true;
-    });
-    const deadline = Date.now() + 30000;
-    while (!done && Date.now() < deadline) {
-      Bun.sleepSync(1);
-    }
-    if (error) {
-      throw error;
-    }
-    if (!done) {
-      throw new Error("PostgreSQL query timed out after 30s");
-    }
-    return result;
+    this.pool = typeof input === "string" ? new PgSyncPool(input) : input;
   }
   run(sql, ...params) {
-    return this.runSync(async () => {
-      const result = await this.pool.query(translateSql(sql), normalizeParams(params));
-      return {
-        changes: result.rowCount ?? 0,
-        lastInsertRowid: result.rows?.[0]?.id ?? 0
-      };
-    });
+    const result = this.pool.query(translateSql(sql), normalizeParams(params));
+    return {
+      changes: result.rowCount ?? 0,
+      lastInsertRowid: result.rows?.[0]?.id ?? 0
+    };
   }
   get(sql, ...params) {
-    return this.runSync(async () => {
-      const result = await this.pool.query(translateSql(sql), normalizeParams(params));
-      return result.rows[0] ?? null;
-    });
+    const result = this.pool.query(translateSql(sql), normalizeParams(params));
+    return result.rows[0] ?? null;
   }
   all(sql, ...params) {
-    return this.runSync(async () => {
-      const result = await this.pool.query(translateSql(sql), normalizeParams(params));
-      return result.rows;
-    });
+    return this.pool.query(translateSql(sql), normalizeParams(params)).rows;
   }
   exec(sql) {
-    this.runSync(async () => {
-      await this.pool.query(sql);
-    });
+    this.pool.query(sql, []);
   }
   prepare(sql) {
     return {
@@ -239,28 +211,20 @@ class PgAdapter {
     return this.prepare(sql);
   }
   close() {
-    this.runSync(async () => {
-      await this.pool.end();
-    });
+    this.pool.end();
   }
   transaction(fn) {
-    return this.runSync(async () => {
-      const client = await this.pool.connect();
-      const originalQuery = this.pool.query.bind(this.pool);
+    this.pool.query("BEGIN", []);
+    try {
+      const value = fn();
+      this.pool.query("COMMIT", []);
+      return value;
+    } catch (error) {
       try {
-        await client.query("BEGIN");
-        this.pool.query = client.query.bind(client);
-        const value = fn();
-        await client.query("COMMIT");
-        return value;
-      } catch (error) {
-        await client.query("ROLLBACK");
-        throw error;
-      } finally {
-        this.pool.query = originalQuery;
-        client.release();
-      }
-    });
+        this.pool.query("ROLLBACK", []);
+      } catch {}
+      throw error;
+    }
   }
   get raw() {
     return this.pool;
@@ -610,7 +574,7 @@ function resetAllSyncMeta(db) {
   ensureSyncMetaTable(db);
   db.run("DELETE FROM _sync_meta");
 }
-var MEMENTOS_STORAGE_TABLES, STORAGE_TABLES, MEMENTOS_STORAGE_ENV, MEMENTOS_STORAGE_FALLBACK_ENV, DEFAULT_STORAGE_CONFIG, STORAGE_CONFIG_DIR, STORAGE_CONFIG_PATH, DATABASE_ENV_NAMES, MODE_ENV_NAMES, warnedDeprecatedModes, getMementosStorageStatus, SYNC_EXCLUDED_TABLE_PATTERNS, SYNC_META_TABLE_SQL = `
+var PgSyncPool, MEMENTOS_STORAGE_TABLES, STORAGE_TABLES, MEMENTOS_STORAGE_ENV, MEMENTOS_STORAGE_FALLBACK_ENV, DEFAULT_STORAGE_CONFIG, STORAGE_CONFIG_DIR, STORAGE_CONFIG_PATH, DATABASE_ENV_NAMES, MODE_ENV_NAMES, warnedDeprecatedModes, getMementosStorageStatus, SYNC_EXCLUDED_TABLE_PATTERNS, SYNC_META_TABLE_SQL = `
 CREATE TABLE IF NOT EXISTS _sync_meta (
   table_name TEXT PRIMARY KEY,
   last_synced_at TEXT,
@@ -618,6 +582,74 @@ CREATE TABLE IF NOT EXISTS _sync_meta (
   direction TEXT DEFAULT 'push'
 )`;
 var init_storage = __esm(() => {
+  PgSyncPool = class PgSyncPool {
+    worker;
+    status;
+    data;
+    closed = false;
+    lastError = null;
+    static DATA_BYTES = 128 * 1024 * 1024;
+    static QUERY_TIMEOUT_MS = 60000;
+    static resolveWorkerPath() {
+      const ext = import.meta.url.endsWith(".ts") ? ".ts" : ".js";
+      const here = fileURLToPath(new URL(".", import.meta.url));
+      const candidates = [
+        join(here, `pg-sync-worker${ext}`),
+        join(here, "..", `pg-sync-worker${ext}`),
+        join(here, "..", "..", `pg-sync-worker${ext}`)
+      ];
+      for (const candidate of candidates) {
+        if (existsSync(candidate))
+          return candidate;
+      }
+      return candidates[0];
+    }
+    constructor(connectionString) {
+      const control = new SharedArrayBuffer(8);
+      const dataSab = new SharedArrayBuffer(PgSyncPool.DATA_BYTES);
+      this.status = new Int32Array(control);
+      this.data = new Uint8Array(dataSab);
+      this.worker = new Worker(PgSyncPool.resolveWorkerPath(), {
+        workerData: {
+          dsn: stripSslParams(connectionString),
+          ssl: sslConfigFor(connectionString),
+          control,
+          data: dataSab
+        }
+      });
+      this.worker.unref();
+      this.worker.on("error", (err) => {
+        this.lastError = err;
+      });
+    }
+    query(sql, params) {
+      if (this.closed)
+        throw new Error("PgSyncPool is closed");
+      if (this.lastError)
+        throw this.lastError;
+      Atomics.store(this.status, 0, 0);
+      this.worker.postMessage({ sql, params });
+      const waitResult = Atomics.wait(this.status, 0, 0, PgSyncPool.QUERY_TIMEOUT_MS);
+      const code = Atomics.load(this.status, 0);
+      if (code === 0 || waitResult === "timed-out") {
+        if (this.lastError)
+          throw this.lastError;
+        throw new Error("PostgreSQL query timed out after 60s");
+      }
+      const len = Atomics.load(this.status, 1);
+      const payload = JSON.parse(new TextDecoder().decode(this.data.subarray(0, len)));
+      if (code === 2) {
+        throw new Error(payload.message ?? "PostgreSQL error");
+      }
+      return payload;
+    }
+    end() {
+      if (this.closed)
+        return;
+      this.closed = true;
+      this.worker.terminate();
+    }
+  };
   MEMENTOS_STORAGE_TABLES = [
     "projects",
     "agents",

package/dist/mcp/index.js

@@ -139,6 +139,8 @@ import { Database } from "bun:sqlite";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
+import { fileURLToPath } from "url";
+import { Worker } from "worker_threads";
 import pg from "pg";
 function normalizeParams(params) {
   const flat = params.length === 1 && Array.isArray(params[0]) ? params[0] : params;
@@ -201,13 +203,15 @@ class SqliteAdapter {
 function translateSql(sql) {
   let parameterIndex = 0;
   let translated = sql.replace(/\?/g, () => `$${++parameterIndex}`);
-  translated = translated.replace(/datetime\s*\(\s*'now'\s*\)/gi, "NOW()");
+  const ISO_FMT = `'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"'`;
+  translated = translated.replace(/datetime\s*\(\s*'now'\s*\)/gi, `to_char(now() AT TIME ZONE 'UTC', ${ISO_FMT})`);
   translated = translated.replace(/datetime\s*\(\s*'now'\s*,\s*'(-?\d+)\s+(minutes?|hours?|days?|seconds?)'\s*\)/gi, (_match, amount, unit) => {
     const parsed = parseInt(String(amount), 10);
     const absolute = Math.abs(parsed);
     const normalizedUnit = String(unit).toLowerCase().replace(/s$/, "");
     const pluralUnit = absolute === 1 ? normalizedUnit : `${normalizedUnit}s`;
-    return parsed < 0 ? `NOW() - INTERVAL '${absolute} ${pluralUnit}'` : `NOW() + INTERVAL '${absolute} ${pluralUnit}'`;
+    const op = parsed < 0 ? "-" : "+";
+    return `to_char((now() ${op} INTERVAL '${absolute} ${pluralUnit}') AT TIME ZONE 'UTC', ${ISO_FMT})`;
   });
   translated = translated.replace(/lower\s*\(\s*hex\s*\(\s*randomblob\s*\(\s*\d+\s*\)\s*\)\s*\)/gi, "gen_random_uuid()::text");
   translated = translated.replace(/\bIFNULL\s*\(/gi, "COALESCE(");
@@ -264,56 +268,24 @@ function makePool(connectionString) {
 class PgAdapter {
   pool;
   constructor(input) {
-    this.pool = typeof input === "string" ? makePool(input) : input;
-  }
-  runSync(fn) {
-    let result;
-    let error;
-    let done = false;
-    fn().then((value) => {
-      result = value;
-      done = true;
-    }).catch((caught) => {
-      error = caught;
-      done = true;
-    });
-    const deadline = Date.now() + 30000;
-    while (!done && Date.now() < deadline) {
-      Bun.sleepSync(1);
-    }
-    if (error) {
-      throw error;
-    }
-    if (!done) {
-      throw new Error("PostgreSQL query timed out after 30s");
-    }
-    return result;
+    this.pool = typeof input === "string" ? new PgSyncPool(input) : input;
   }
   run(sql, ...params) {
-    return this.runSync(async () => {
-      const result = await this.pool.query(translateSql(sql), normalizeParams(params));
-      return {
-        changes: result.rowCount ?? 0,
-        lastInsertRowid: result.rows?.[0]?.id ?? 0
-      };
-    });
+    const result = this.pool.query(translateSql(sql), normalizeParams(params));
+    return {
+      changes: result.rowCount ?? 0,
+      lastInsertRowid: result.rows?.[0]?.id ?? 0
+    };
   }
   get(sql, ...params) {
-    return this.runSync(async () => {
-      const result = await this.pool.query(translateSql(sql), normalizeParams(params));
-      return result.rows[0] ?? null;
-    });
+    const result = this.pool.query(translateSql(sql), normalizeParams(params));
+    return result.rows[0] ?? null;
   }
   all(sql, ...params) {
-    return this.runSync(async () => {
-      const result = await this.pool.query(translateSql(sql), normalizeParams(params));
-      return result.rows;
-    });
+    return this.pool.query(translateSql(sql), normalizeParams(params)).rows;
   }
   exec(sql) {
-    this.runSync(async () => {
-      await this.pool.query(sql);
-    });
+    this.pool.query(sql, []);
   }
   prepare(sql) {
     return {
@@ -327,28 +299,20 @@ class PgAdapter {
     return this.prepare(sql);
   }
   close() {
-    this.runSync(async () => {
-      await this.pool.end();
-    });
+    this.pool.end();
   }
   transaction(fn) {
-    return this.runSync(async () => {
-      const client = await this.pool.connect();
-      const originalQuery = this.pool.query.bind(this.pool);
+    this.pool.query("BEGIN", []);
+    try {
+      const value = fn();
+      this.pool.query("COMMIT", []);
+      return value;
+    } catch (error) {
       try {
-        await client.query("BEGIN");
-        this.pool.query = client.query.bind(client);
-        const value = fn();
-        await client.query("COMMIT");
-        return value;
-      } catch (error) {
-        await client.query("ROLLBACK");
-        throw error;
-      } finally {
-        this.pool.query = originalQuery;
-        client.release();
-      }
-    });
+        this.pool.query("ROLLBACK", []);
+      } catch {}
+      throw error;
+    }
   }
   get raw() {
     return this.pool;
@@ -630,7 +594,7 @@ function getSyncMetaAll(db) {
   ensureSyncMetaTable(db);
   return db.all("SELECT table_name, last_synced_at, last_synced_row_count, direction FROM _sync_meta ORDER BY table_name");
 }
-var MEMENTOS_STORAGE_TABLES, MEMENTOS_STORAGE_ENV, MEMENTOS_STORAGE_FALLBACK_ENV, DEFAULT_STORAGE_CONFIG, STORAGE_CONFIG_DIR, STORAGE_CONFIG_PATH, DATABASE_ENV_NAMES, MODE_ENV_NAMES, warnedDeprecatedModes, SYNC_EXCLUDED_TABLE_PATTERNS, SYNC_META_TABLE_SQL = `
+var PgSyncPool, MEMENTOS_STORAGE_TABLES, MEMENTOS_STORAGE_ENV, MEMENTOS_STORAGE_FALLBACK_ENV, DEFAULT_STORAGE_CONFIG, STORAGE_CONFIG_DIR, STORAGE_CONFIG_PATH, DATABASE_ENV_NAMES, MODE_ENV_NAMES, warnedDeprecatedModes, SYNC_EXCLUDED_TABLE_PATTERNS, SYNC_META_TABLE_SQL = `
 CREATE TABLE IF NOT EXISTS _sync_meta (
   table_name TEXT PRIMARY KEY,
   last_synced_at TEXT,
@@ -638,6 +602,74 @@ CREATE TABLE IF NOT EXISTS _sync_meta (
   direction TEXT DEFAULT 'push'
 )`;
 var init_storage = __esm(() => {
+  PgSyncPool = class PgSyncPool {
+    worker;
+    status;
+    data;
+    closed = false;
+    lastError = null;
+    static DATA_BYTES = 128 * 1024 * 1024;
+    static QUERY_TIMEOUT_MS = 60000;
+    static resolveWorkerPath() {
+      const ext = import.meta.url.endsWith(".ts") ? ".ts" : ".js";
+      const here = fileURLToPath(new URL(".", import.meta.url));
+      const candidates = [
+        join(here, `pg-sync-worker${ext}`),
+        join(here, "..", `pg-sync-worker${ext}`),
+        join(here, "..", "..", `pg-sync-worker${ext}`)
+      ];
+      for (const candidate of candidates) {
+        if (existsSync(candidate))
+          return candidate;
+      }
+      return candidates[0];
+    }
+    constructor(connectionString) {
+      const control = new SharedArrayBuffer(8);
+      const dataSab = new SharedArrayBuffer(PgSyncPool.DATA_BYTES);
+      this.status = new Int32Array(control);
+      this.data = new Uint8Array(dataSab);
+      this.worker = new Worker(PgSyncPool.resolveWorkerPath(), {
+        workerData: {
+          dsn: stripSslParams(connectionString),
+          ssl: sslConfigFor(connectionString),
+          control,
+          data: dataSab
+        }
+      });
+      this.worker.unref();
+      this.worker.on("error", (err) => {
+        this.lastError = err;
+      });
+    }
+    query(sql, params) {
+      if (this.closed)
+        throw new Error("PgSyncPool is closed");
+      if (this.lastError)
+        throw this.lastError;
+      Atomics.store(this.status, 0, 0);
+      this.worker.postMessage({ sql, params });
+      const waitResult = Atomics.wait(this.status, 0, 0, PgSyncPool.QUERY_TIMEOUT_MS);
+      const code = Atomics.load(this.status, 0);
+      if (code === 0 || waitResult === "timed-out") {
+        if (this.lastError)
+          throw this.lastError;
+        throw new Error("PostgreSQL query timed out after 60s");
+      }
+      const len = Atomics.load(this.status, 1);
+      const payload = JSON.parse(new TextDecoder().decode(this.data.subarray(0, len)));
+      if (code === 2) {
+        throw new Error(payload.message ?? "PostgreSQL error");
+      }
+      return payload;
+    }
+    end() {
+      if (this.closed)
+        return;
+      this.closed = true;
+      this.worker.terminate();
+    }
+  };
   MEMENTOS_STORAGE_TABLES = [
     "projects",
     "agents",
@@ -11798,6 +11830,45 @@ var init_pg_migrations = __esm(() => {
     machine_id TEXT,
     created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
   );
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS tasks (
+    id TEXT PRIMARY KEY,
+    subject TEXT NOT NULL,
+    description TEXT DEFAULT '',
+    status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','in_progress','completed','failed','cancelled')),
+    priority TEXT NOT NULL DEFAULT 'medium' CHECK(priority IN ('critical','high','medium','low')),
+    tags TEXT NOT NULL DEFAULT '[]',
+    assigned_agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    session_id TEXT,
+    parent_task_id TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+    metadata TEXT NOT NULL DEFAULT '{}',
+    progress REAL NOT NULL DEFAULT 0 CHECK(progress >= 0 AND progress <= 1),
+    due_at TEXT,
+    started_at TEXT,
+    completed_at TEXT,
+    failed_at TEXT,
+    error TEXT,
+    created_at TEXT NOT NULL DEFAULT to_char((now() AT TIME ZONE 'UTC'), 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"'),
+    updated_at TEXT NOT NULL DEFAULT to_char((now() AT TIME ZONE 'UTC'), 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')
+  );
+  CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+  CREATE INDEX IF NOT EXISTS idx_tasks_priority ON tasks(priority);
+  CREATE INDEX IF NOT EXISTS idx_tasks_agent ON tasks(assigned_agent_id);
+  CREATE INDEX IF NOT EXISTS idx_tasks_project ON tasks(project_id);
+  CREATE INDEX IF NOT EXISTS idx_tasks_session ON tasks(session_id);
+  CREATE INDEX IF NOT EXISTS idx_tasks_parent ON tasks(parent_task_id);
+
+  CREATE TABLE IF NOT EXISTS task_comments (
+    id TEXT PRIMARY KEY,
+    task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
+    body TEXT NOT NULL,
+    created_at TEXT NOT NULL DEFAULT to_char((now() AT TIME ZONE 'UTC'), 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')
+  );
+  CREATE INDEX IF NOT EXISTS idx_task_comments_task ON task_comments(task_id);
+  CREATE INDEX IF NOT EXISTS idx_task_comments_agent ON task_comments(agent_id);
   `
   ];
 });

package/dist/pg-sync-worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pg-sync-worker.d.ts.map

package/dist/pg-sync-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pg-sync-worker.d.ts","sourceRoot":"","sources":["../src/pg-sync-worker.ts"],"names":[],"mappings":""}

package/dist/pg-sync-worker.js

@@ -0,0 +1,47 @@
+// @bun
+// src/pg-sync-worker.ts
+import { parentPort, workerData } from "worker_threads";
+import pg from "pg";
+var { dsn, ssl, control, data } = workerData;
+var status = new Int32Array(control);
+var dataView = new Uint8Array(data);
+var encoder = new TextEncoder;
+var client = new pg.Client({ connectionString: dsn, ssl });
+var connected = false;
+var connecting = null;
+async function ensureConnected() {
+  if (connected)
+    return;
+  if (!connecting) {
+    connecting = client.connect().then(() => {
+      connected = true;
+    });
+  }
+  await connecting;
+}
+function respond(statusCode, payload) {
+  const bytes = encoder.encode(JSON.stringify(payload));
+  if (bytes.length > dataView.length) {
+    const errBytes = encoder.encode(JSON.stringify({
+      message: `PgSyncWorker: response of ${bytes.length} bytes exceeds shared buffer (${dataView.length})`
+    }));
+    dataView.set(errBytes, 0);
+    Atomics.store(status, 1, errBytes.length);
+    Atomics.store(status, 0, 2);
+    Atomics.notify(status, 0);
+    return;
+  }
+  dataView.set(bytes, 0);
+  Atomics.store(status, 1, bytes.length);
+  Atomics.store(status, 0, statusCode);
+  Atomics.notify(status, 0);
+}
+parentPort?.on("message", async (msg) => {
+  try {
+    await ensureConnected();
+    const result = await client.query(msg.sql, msg.params);
+    respond(1, { rows: result.rows, rowCount: result.rowCount });
+  } catch (error) {
+    respond(2, { message: error instanceof Error ? error.message : String(error) });
+  }
+});

package/dist/sdk/index.d.ts

@@ -272,6 +272,18 @@ export interface ListTasksFilter {
 export interface MementosClientConfig {
     baseUrl?: string;
     fetch?: typeof globalThis.fetch;
+    /**
+     * API key issued by `contracts issue-key --app mementos`. Sent as both
+     * `Authorization: Bearer <key>` and `x-api-key`. Required against a
+     * self_hosted deployment with API-key auth enabled.
+     */
+    apiKey?: string;
+    /**
+     * Versioned route prefix. Defaults to the canonical `/v1`. The deployed
+     * service also serves the legacy `/api` prefix; set `prefix: "/api"` to target
+     * it explicitly.
+     */
+    prefix?: string;
 }
 export declare class MementosError extends Error {
     readonly status: number;
@@ -368,6 +380,8 @@ export interface SessionMemoryJob {
 export declare class MementosClient {
     private baseUrl;
     private _fetch;
+    private apiKey?;
+    private prefix;
     constructor(config?: MementosClientConfig);
     static fromEnv(overrides?: Partial<MementosClientConfig>): MementosClient;
     private request;
@@ -383,6 +397,7 @@ export declare class MementosClient {
     getHealth(): Promise<{
         status: "ok" | "warn";
         version: string;
+        mode: "local" | "cloud";
         profile: string;
         db_path: string;
         hostname: string;
@@ -394,6 +409,18 @@ export declare class MementosClient {
         agents: number;
         projects: number;
     }>;
+    /** Liveness/readiness probe — verifies backing-store connectivity. */
+    getReady(): Promise<{
+        status: "ready" | "not_ready";
+        version: string;
+        mode: "local" | "cloud";
+    }>;
+    /** Service version + storage mode. */
+    getVersion(): Promise<{
+        status: "ok";
+        version: string;
+        mode: "local" | "cloud";
+    }>;
     getReport(options?: {
         days?: number;
         project_id?: string;