@withone/cli 1.42.0 → 1.43.3

package/dist/chunk-IAFQVFCB.js

@@ -0,0 +1,1708 @@
+import {
+  DEFAULT_MEMORY_CONFIG,
+  defaultSearchableText,
+  embed,
+  getMemoryConfig,
+  getMemoryConfigOrDefault,
+  getOpenAiApiKey,
+  updateMemoryConfig
+} from "./chunk-AU2ZEEMS.js";
+
+// src/lib/memory/schema.ts
+var SCHEMA_VERSION = "2.1.0";
+var EXTENSIONS_SQL = ``;
+var VECTOR_EXTENSION_SQL = `
+CREATE EXTENSION IF NOT EXISTS vector;
+`;
+var TABLES_SQL = `
+CREATE TABLE IF NOT EXISTS mem_records (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+
+    type TEXT NOT NULL,
+    data JSONB NOT NULL,
+    tags TEXT[],
+    keys TEXT[],
+
+    sources JSONB NOT NULL DEFAULT '{}',
+
+    searchable_text TEXT,
+    searchable tsvector GENERATED ALWAYS AS (to_tsvector('english', COALESCE(searchable_text, ''))) STORED,
+
+    content_hash TEXT,
+
+    weight SMALLINT NOT NULL DEFAULT 5 CHECK (weight BETWEEN 1 AND 10),
+    access_count INTEGER NOT NULL DEFAULT 0,
+    last_accessed_at TIMESTAMPTZ,
+
+    status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'archived')),
+    archived_reason TEXT,
+
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS mem_links (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    from_id UUID NOT NULL REFERENCES mem_records(id) ON DELETE CASCADE,
+    to_id UUID NOT NULL REFERENCES mem_records(id) ON DELETE CASCADE,
+    relation TEXT NOT NULL,
+    bidirectional BOOLEAN NOT NULL DEFAULT false,
+    metadata JSONB,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    UNIQUE(from_id, to_id, relation)
+);
+
+CREATE TABLE IF NOT EXISTS mem_sync_state (
+    platform TEXT NOT NULL,
+    model TEXT NOT NULL,
+    last_sync_at TIMESTAMPTZ,
+    last_cursor JSONB,
+    since TIMESTAMPTZ,
+    total_records INTEGER NOT NULL DEFAULT 0,
+    pages_processed INTEGER NOT NULL DEFAULT 0,
+    status TEXT NOT NULL DEFAULT 'idle' CHECK (status IN ('idle', 'syncing', 'failed')),
+    last_error TEXT,
+    PRIMARY KEY (platform, model)
+);
+
+CREATE TABLE IF NOT EXISTS mem_meta (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL,
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+`;
+var VECTOR_COLUMNS_SQL = `
+ALTER TABLE mem_records ADD COLUMN IF NOT EXISTS embedding vector(1536);
+ALTER TABLE mem_records ADD COLUMN IF NOT EXISTS embedded_at TIMESTAMPTZ;
+ALTER TABLE mem_records ADD COLUMN IF NOT EXISTS embedding_model TEXT;
+`;
+var INDEXES_SQL = `
+CREATE INDEX IF NOT EXISTS idx_records_type         ON mem_records(type);
+CREATE INDEX IF NOT EXISTS idx_records_status       ON mem_records(status);
+CREATE INDEX IF NOT EXISTS idx_records_keys         ON mem_records USING GIN(keys);
+CREATE INDEX IF NOT EXISTS idx_records_tags         ON mem_records USING GIN(tags);
+CREATE INDEX IF NOT EXISTS idx_records_data         ON mem_records USING GIN(data jsonb_path_ops);
+CREATE INDEX IF NOT EXISTS idx_records_sources      ON mem_records USING GIN(sources jsonb_path_ops);
+CREATE INDEX IF NOT EXISTS idx_records_searchable   ON mem_records USING GIN(searchable);
+CREATE INDEX IF NOT EXISTS idx_records_relevance    ON mem_records(status, weight DESC, access_count DESC, last_accessed_at DESC NULLS LAST);
+CREATE INDEX IF NOT EXISTS idx_records_content_hash ON mem_records(content_hash);
+
+CREATE INDEX IF NOT EXISTS idx_links_from           ON mem_links(from_id);
+CREATE INDEX IF NOT EXISTS idx_links_to             ON mem_links(to_id);
+CREATE INDEX IF NOT EXISTS idx_links_relation       ON mem_links(relation);
+CREATE INDEX IF NOT EXISTS idx_links_bidirectional  ON mem_links(bidirectional) WHERE bidirectional = true;
+`;
+var VECTOR_INDEX_SQL = `
+DO $$
+BEGIN
+  IF NOT EXISTS (SELECT 1 FROM pg_indexes WHERE indexname = 'idx_records_embedding') THEN
+    CREATE INDEX idx_records_embedding
+      ON mem_records USING HNSW(embedding vector_cosine_ops)
+      WHERE embedding IS NOT NULL;
+  END IF;
+END $$;
+`;
+var FUNCTIONS_SQL = `
+-- Enforce global uniqueness of the "keys" array across records.
+CREATE OR REPLACE FUNCTION mem_enforce_key_uniqueness()
+RETURNS TRIGGER LANGUAGE plpgsql AS $$
+DECLARE
+    conflicting_id UUID;
+BEGIN
+    IF NEW.keys IS NULL THEN RETURN NEW; END IF;
+    SELECT id INTO conflicting_id
+    FROM mem_records
+    WHERE keys && NEW.keys AND id != NEW.id
+    LIMIT 1;
+    IF conflicting_id IS NOT NULL THEN
+        RAISE EXCEPTION 'Key conflict: one or more keys in % already exist on record %',
+            NEW.keys, conflicting_id USING ERRCODE = 'unique_violation';
+    END IF;
+    RETURN NEW;
+END;
+$$;
+
+DROP TRIGGER IF EXISTS mem_enforce_key_uniqueness_trigger ON mem_records;
+CREATE TRIGGER mem_enforce_key_uniqueness_trigger
+BEFORE INSERT OR UPDATE ON mem_records
+FOR EACH ROW EXECUTE FUNCTION mem_enforce_key_uniqueness();
+
+-- Bump updated_at on write. searchable_text is owned by the caller (profile-driven).
+CREATE OR REPLACE FUNCTION mem_records_touch()
+RETURNS TRIGGER LANGUAGE plpgsql AS $$
+BEGIN
+    NEW.updated_at := NOW();
+    RETURN NEW;
+END;
+$$;
+
+DROP TRIGGER IF EXISTS mem_records_touch_trigger ON mem_records;
+CREATE TRIGGER mem_records_touch_trigger
+BEFORE UPDATE ON mem_records
+FOR EACH ROW EXECUTE FUNCTION mem_records_touch();
+
+-- Relevance scoring (mirrors TS scoring.ts). See docs/plans/unified-memory.md \xA74.5.
+CREATE OR REPLACE FUNCTION mem_calculate_relevance(
+    p_weight INTEGER,
+    p_access_count INTEGER,
+    p_last_accessed_at TIMESTAMPTZ,
+    p_created_at TIMESTAMPTZ,
+    max_access_count INTEGER DEFAULT 100
+) RETURNS FLOAT LANGUAGE plpgsql AS $$
+DECLARE
+    weight_score FLOAT;
+    access_score FLOAT;
+    recency_score FLOAT;
+    days_since_access FLOAT;
+BEGIN
+    weight_score := (p_weight - 1) / 9.0;
+    access_score := LEAST(p_access_count::FLOAT / max_access_count, 1.0);
+
+    IF p_last_accessed_at IS NOT NULL THEN
+        days_since_access := EXTRACT(EPOCH FROM (NOW() - p_last_accessed_at)) / 86400.0;
+        recency_score := GREATEST(1.0 - (days_since_access / 30.0) * 0.9, 0.1);
+    ELSE
+        days_since_access := EXTRACT(EPOCH FROM (NOW() - p_created_at)) / 86400.0;
+        recency_score := GREATEST(0.5 - (days_since_access / 60.0) * 0.4, 0.1);
+    END IF;
+
+    RETURN (weight_score * 0.4) + (access_score * 0.3) + (recency_score * 0.3);
+END;
+$$;
+
+-- Access tracking for search results.
+CREATE OR REPLACE FUNCTION mem_increment_access(record_ids UUID[])
+RETURNS VOID LANGUAGE plpgsql AS $$
+BEGIN
+    UPDATE mem_records
+    SET access_count = access_count + 1,
+        last_accessed_at = NOW()
+    WHERE id = ANY(record_ids);
+END;
+$$;
+
+-- Upsert by keys: merge (or replace) into the first record whose keys overlap, else insert new.
+-- Returns the resulting record id + whether the operation was insert or update.
+--
+-- p_replace=FALSE (default): shallow-merge existing data with p_data. Right
+--   semantics for user-authored memories that get progressively enriched.
+-- p_replace=TRUE: REPLACE data with p_data. Right for synced rows \u2014 if the
+--   source removed a field, it must disappear from memory too.
+--
+-- Upsert-by-keys is the self-heal primitive for --full-refresh reconcile:
+-- if the upsert finds an archived row, the source re-surfaced it, so flip
+-- status back to 'active' and clear archived_reason. Without this, rows
+-- archived by a buggy reconcile would stay dead until manually un-archived.
+-- Core (no-vector) variant of mem_upsert_by_keys. p_embedding and
+-- p_embedding_model are accepted for source compatibility with the
+-- vector variant but are ignored \u2014 the embedding column doesn't exist
+-- in this schema. The vector variant (VECTOR_FUNCTIONS_SQL) overrides
+-- this with CREATE OR REPLACE when caps.vectorSearch is true.
+--
+-- p_embedding is TEXT (not vector(1536)) so this function compiles on
+-- backends without pgvector loaded. The vector variant uses the same
+-- TEXT signature and casts to vector inside the body.
+CREATE OR REPLACE FUNCTION mem_upsert_by_keys(
+    p_type TEXT,
+    p_data JSONB,
+    p_tags TEXT[],
+    p_keys TEXT[],
+    p_sources JSONB,
+    p_searchable_text TEXT,
+    p_content_hash TEXT,
+    p_weight INTEGER DEFAULT NULL,
+    p_embedding TEXT DEFAULT NULL,
+    p_embedding_model TEXT DEFAULT NULL,
+    p_replace BOOLEAN DEFAULT FALSE
+) RETURNS TABLE (id UUID, action TEXT) LANGUAGE plpgsql AS $$
+DECLARE
+    existing_id UUID;
+    result_id UUID;
+    result_action TEXT;
+BEGIN
+    -- Deterministic pick when more than one row's keys[] overlap p_keys
+    -- (e.g. the incoming row identity-merges with an old Attio-id row AND
+    -- a newer email-keyed row from a separate sync). Newest-updated wins;
+    -- ties broken by id. Without ORDER BY, PG returns whichever row the
+    -- planner happens to surface first, leaving the loser persisted with
+    -- overlapping keys and breaking the keys-are-unique invariant.
+    SELECT r.id INTO existing_id
+    FROM mem_records r
+    WHERE r.keys && p_keys
+    ORDER BY r.updated_at DESC NULLS LAST, r.id ASC
+    LIMIT 1;
+
+    IF existing_id IS NOT NULL THEN
+        -- p_replace=TRUE: this call is the new ground truth for the row's
+        -- content (typical for sync runs where a field disappearing
+        -- upstream must disappear in memory). Replace data, tags,
+        -- searchable_text, content_hash with what the caller supplied.
+        -- Keys still union (never lose a key \u2014 losing the identity key
+        -- would orphan the row), and sources still merge (multi-source
+        -- provenance is independent of any single source's payload).
+        UPDATE mem_records r
+        SET data = CASE WHEN p_replace THEN p_data ELSE r.data || p_data END,
+            tags = CASE
+                WHEN p_replace THEN COALESCE(p_tags, '{}'::text[])
+                ELSE (SELECT ARRAY(SELECT DISTINCT unnest FROM unnest(COALESCE(r.tags, '{}') || COALESCE(p_tags, '{}'))))
+            END,
+            keys = (SELECT ARRAY(SELECT DISTINCT unnest FROM unnest(COALESCE(r.keys, '{}') || COALESCE(p_keys, '{}')))),
+            sources = r.sources || COALESCE(p_sources, '{}'::jsonb),
+            searchable_text = CASE
+                WHEN p_replace THEN p_searchable_text
+                ELSE COALESCE(p_searchable_text, r.searchable_text)
+            END,
+            content_hash = CASE
+                WHEN p_replace THEN p_content_hash
+                ELSE COALESCE(p_content_hash, r.content_hash)
+            END,
+            weight = COALESCE(p_weight, r.weight),
+            status = 'active',
+            archived_reason = NULL
+        WHERE r.id = existing_id;
+
+        result_id := existing_id;
+        result_action := 'updated';
+    ELSE
+        INSERT INTO mem_records (
+            type, data, tags, keys, sources, searchable_text, content_hash, weight
+        ) VALUES (
+            p_type,
+            p_data,
+            p_tags,
+            p_keys,
+            COALESCE(p_sources, '{}'::jsonb),
+            p_searchable_text,
+            p_content_hash,
+            COALESCE(p_weight, 5)
+        )
+        RETURNING mem_records.id INTO result_id;
+        result_action := 'inserted';
+    END IF;
+
+    RETURN QUERY SELECT result_id, result_action;
+END;
+$$;
+`;
+var VECTOR_FUNCTIONS_SQL = `
+CREATE OR REPLACE FUNCTION mem_upsert_by_keys(
+    p_type TEXT,
+    p_data JSONB,
+    p_tags TEXT[],
+    p_keys TEXT[],
+    p_sources JSONB,
+    p_searchable_text TEXT,
+    p_content_hash TEXT,
+    p_weight INTEGER DEFAULT NULL,
+    p_embedding TEXT DEFAULT NULL,
+    p_embedding_model TEXT DEFAULT NULL,
+    p_replace BOOLEAN DEFAULT FALSE
+) RETURNS TABLE (id UUID, action TEXT) LANGUAGE plpgsql AS $$
+DECLARE
+    existing_id UUID;
+    result_id UUID;
+    result_action TEXT;
+    v_embedding vector(1536);
+BEGIN
+    v_embedding := CASE WHEN p_embedding IS NOT NULL THEN p_embedding::vector ELSE NULL END;
+
+    -- See no-vector variant for ORDER BY rationale (deterministic pick
+    -- when multiple rows' keys overlap p_keys).
+    SELECT r.id INTO existing_id
+    FROM mem_records r
+    WHERE r.keys && p_keys
+    ORDER BY r.updated_at DESC NULLS LAST, r.id ASC
+    LIMIT 1;
+
+    IF existing_id IS NOT NULL THEN
+        -- See no-vector variant for p_replace gating rationale (replace
+        -- data, tags, searchable_text, content_hash; keys union, sources
+        -- merge; embedding follows existing v_embedding logic).
+        UPDATE mem_records r
+        SET data = CASE WHEN p_replace THEN p_data ELSE r.data || p_data END,
+            tags = CASE
+                WHEN p_replace THEN COALESCE(p_tags, '{}'::text[])
+                ELSE (SELECT ARRAY(SELECT DISTINCT unnest FROM unnest(COALESCE(r.tags, '{}') || COALESCE(p_tags, '{}'))))
+            END,
+            keys = (SELECT ARRAY(SELECT DISTINCT unnest FROM unnest(COALESCE(r.keys, '{}') || COALESCE(p_keys, '{}')))),
+            sources = r.sources || COALESCE(p_sources, '{}'::jsonb),
+            searchable_text = CASE
+                WHEN p_replace THEN p_searchable_text
+                ELSE COALESCE(p_searchable_text, r.searchable_text)
+            END,
+            content_hash = CASE
+                WHEN p_replace THEN p_content_hash
+                ELSE COALESCE(p_content_hash, r.content_hash)
+            END,
+            weight = COALESCE(p_weight, r.weight),
+            embedding = COALESCE(v_embedding, r.embedding),
+            embedded_at = CASE WHEN v_embedding IS NOT NULL THEN NOW() ELSE r.embedded_at END,
+            embedding_model = COALESCE(p_embedding_model, r.embedding_model),
+            status = 'active',
+            archived_reason = NULL
+        WHERE r.id = existing_id;
+
+        result_id := existing_id;
+        result_action := 'updated';
+    ELSE
+        INSERT INTO mem_records (
+            type, data, tags, keys, sources, searchable_text, content_hash,
+            weight, embedding, embedded_at, embedding_model
+        ) VALUES (
+            p_type,
+            p_data,
+            p_tags,
+            p_keys,
+            COALESCE(p_sources, '{}'::jsonb),
+            p_searchable_text,
+            p_content_hash,
+            COALESCE(p_weight, 5),
+            v_embedding,
+            CASE WHEN v_embedding IS NOT NULL THEN NOW() ELSE NULL END,
+            p_embedding_model
+        )
+        RETURNING mem_records.id INTO result_id;
+        result_action := 'inserted';
+    END IF;
+
+    RETURN QUERY SELECT result_id, result_action;
+END;
+$$;
+`;
+var HYBRID_SEARCH_SQL = `
+CREATE OR REPLACE FUNCTION mem_hybrid_search(
+    query_text TEXT,
+    query_embedding vector(1536),
+    match_count INT DEFAULT 10,
+    filter_type TEXT DEFAULT NULL,
+    full_text_weight FLOAT DEFAULT 0.3,
+    semantic_weight FLOAT DEFAULT 0.7,
+    rrf_k INT DEFAULT 50,
+    include_archived BOOLEAN DEFAULT FALSE
+) RETURNS TABLE (
+    id UUID,
+    type TEXT,
+    data JSONB,
+    tags TEXT[],
+    fts_rank FLOAT,
+    semantic_rank FLOAT,
+    combined_score FLOAT
+) LANGUAGE plpgsql AS $$
+BEGIN
+    RETURN QUERY
+    WITH fts_results AS (
+        SELECT r.id,
+               ROW_NUMBER() OVER (ORDER BY ts_rank_cd(r.searchable, websearch_to_tsquery('english', query_text)) DESC) AS rank
+        FROM mem_records r
+        WHERE r.searchable @@ websearch_to_tsquery('english', query_text)
+          AND (filter_type IS NULL OR r.type = filter_type)
+          AND (include_archived OR r.status = 'active')
+        LIMIT match_count * 2
+    ),
+    semantic_results AS (
+        SELECT r.id,
+               ROW_NUMBER() OVER (ORDER BY r.embedding <=> query_embedding) AS rank
+        FROM mem_records r
+        WHERE r.embedding IS NOT NULL
+          AND (filter_type IS NULL OR r.type = filter_type)
+          AND (include_archived OR r.status = 'active')
+        ORDER BY r.embedding <=> query_embedding
+        LIMIT match_count * 2
+    ),
+    combined AS (
+        SELECT COALESCE(fts.id, sem.id) AS id,
+               COALESCE(1.0 / (rrf_k + fts.rank), 0.0) AS fts_score,
+               COALESCE(1.0 / (rrf_k + sem.rank), 0.0) AS sem_score
+        FROM fts_results fts
+        FULL OUTER JOIN semantic_results sem ON fts.id = sem.id
+    )
+    SELECT r.id,
+           r.type,
+           r.data,
+           r.tags,
+           c.fts_score::FLOAT AS fts_rank,
+           c.sem_score::FLOAT AS semantic_rank,
+           (c.fts_score * full_text_weight + c.sem_score * semantic_weight)::FLOAT AS combined_score
+    FROM combined c
+    JOIN mem_records r ON r.id = c.id
+    ORDER BY (c.fts_score * full_text_weight + c.sem_score * semantic_weight) DESC
+    LIMIT match_count;
+END;
+$$;
+`;
+function getMetaInsertSQL(version) {
+  return `INSERT INTO mem_meta (key, value) VALUES ('version', '${version}')
+          ON CONFLICT (key) DO UPDATE SET value = '${version}', updated_at = NOW();`;
+}
+
+// src/lib/memory/plugins/postgres-core/sql-guard.ts
+var ALLOWED_LEADING = /^\s*(SELECT|WITH|EXPLAIN)\b/i;
+var FORBIDDEN = /\b(INSERT|UPDATE|DELETE|DROP|ALTER|CREATE|REPLACE|TRUNCATE|COPY|GRANT|REVOKE|VACUUM|ATTACH|DETACH|PRAGMA|CALL|LOAD|RESET|SET\s+SESSION|SET\s+LOCAL|DO|COMMIT|ROLLBACK|BEGIN|START)\b/i;
+function validateReadOnlySql(sql) {
+  const trimmed = sql.trim();
+  if (!trimmed) {
+    throw new Error("SQL is empty.");
+  }
+  if (!ALLOWED_LEADING.test(trimmed)) {
+    throw new Error(
+      "Only SELECT / WITH / EXPLAIN statements are allowed. The unified memory store is read-only from this surface \u2014 use `one mem add` / `one sync run` for writes."
+    );
+  }
+  const stripped = trimmed.replace(/;\s*$/, "");
+  if (stripped.includes(";")) {
+    throw new Error("Multi-statement SQL is not allowed \u2014 submit a single SELECT / WITH / EXPLAIN.");
+  }
+  if (FORBIDDEN.test(stripped)) {
+    throw new Error(
+      "DDL / DML / session-control keywords are blocked. Allowed: SELECT, WITH, EXPLAIN, plus standard read-only operators (JOIN, WHERE, GROUP BY, aggregates, JSONB path operators)."
+    );
+  }
+}
+
+// src/lib/memory/plugins/postgres-core/client.ts
+function vectorLiteral(embedding) {
+  if (!embedding || embedding.length === 0) return null;
+  return "[" + embedding.join(",") + "]";
+}
+function jsonPathArray(dotPath) {
+  const parts = dotPath.split(".").map((p) => p.replace(/"/g, '""'));
+  return "{" + parts.map((p) => `"${p}"`).join(",") + "}";
+}
+function hotColumnIndexName(type, jsonPath) {
+  const slug = (s) => s.replace(/[^a-zA-Z0-9]+/g, "_").toLowerCase();
+  const name = `idx_records_${slug(type)}_${slug(jsonPath)}`;
+  return name.slice(0, 63);
+}
+
+// src/lib/memory/plugins/postgres-core/backend.ts
+var SCHEMA_LOCK_ID = 7193095520723763200n.toString();
+function toRecord(row) {
+  return {
+    id: row.id,
+    type: row.type,
+    data: row.data,
+    tags: row.tags ?? void 0,
+    keys: row.keys ?? void 0,
+    sources: row.sources ?? {},
+    searchable_text: row.searchable_text,
+    embedded_at: row.embedded_at,
+    embedding_model: row.embedding_model,
+    content_hash: row.content_hash,
+    weight: row.weight,
+    access_count: row.access_count,
+    last_accessed_at: row.last_accessed_at,
+    status: row.status,
+    archived_reason: row.archived_reason,
+    created_at: row.created_at,
+    updated_at: row.updated_at
+  };
+}
+var CoreBackend = class {
+  constructor(client, caps) {
+    this.client = client;
+    this.caps = caps;
+  }
+  // ── Lifecycle ────────────────────────────────────────────────────────
+  async init() {
+  }
+  async close() {
+    await this.client.close();
+  }
+  async ensureSchema() {
+    const caps = this.caps;
+    await this.client.transaction(async (tx) => {
+      try {
+        await tx.query(`SELECT pg_advisory_xact_lock(${SCHEMA_LOCK_ID}::bigint)`);
+      } catch {
+      }
+      if (EXTENSIONS_SQL.trim()) await tx.query(EXTENSIONS_SQL);
+      await tx.query(TABLES_SQL);
+      await tx.query(INDEXES_SQL);
+      await tx.query(FUNCTIONS_SQL);
+      if (caps.vectorSearch) {
+        await tx.query(VECTOR_EXTENSION_SQL);
+        await tx.query(VECTOR_COLUMNS_SQL);
+        await tx.query(VECTOR_FUNCTIONS_SQL);
+        await tx.query(VECTOR_INDEX_SQL);
+        await tx.query(HYBRID_SEARCH_SQL);
+      }
+      await tx.query(getMetaInsertSQL(SCHEMA_VERSION));
+    });
+  }
+  async getSchemaVersion() {
+    const res = await this.client.query(
+      `SELECT value FROM mem_meta WHERE key = 'version'`
+    );
+    return res.rows[0]?.value ?? null;
+  }
+  // ── Records ──────────────────────────────────────────────────────────
+  async insert(row) {
+    const embedding = vectorLiteral(row.embedding ?? null);
+    const sql = this.caps.vectorSearch ? `INSERT INTO mem_records
+          (type, data, tags, keys, sources, searchable_text, content_hash, weight,
+           embedding, embedded_at, embedding_model)
+         VALUES ($1, $2::jsonb, $3::text[], $4::text[], $5::jsonb, $6, $7, $8,
+                 $9::vector, CASE WHEN $9 IS NOT NULL THEN NOW() ELSE NULL END, $10)
+         RETURNING *` : `INSERT INTO mem_records
+          (type, data, tags, keys, sources, searchable_text, content_hash, weight)
+         VALUES ($1, $2::jsonb, $3::text[], $4::text[], $5::jsonb, $6, $7, $8)
+         RETURNING *`;
+    const params = this.caps.vectorSearch ? [
+      row.type,
+      JSON.stringify(row.data),
+      row.tags ?? null,
+      row.keys ?? null,
+      JSON.stringify(row.sources ?? {}),
+      row.searchable_text ?? null,
+      row.content_hash ?? null,
+      row.weight ?? 5,
+      embedding,
+      row.embedding_model ?? null
+    ] : [
+      row.type,
+      JSON.stringify(row.data),
+      row.tags ?? null,
+      row.keys ?? null,
+      JSON.stringify(row.sources ?? {}),
+      row.searchable_text ?? null,
+      row.content_hash ?? null,
+      row.weight ?? 5
+    ];
+    const res = await this.client.query(sql, params);
+    return toRecord(res.rows[0]);
+  }
+  async upsertByKeys(row, opts = {}) {
+    const embedding = vectorLiteral(row.embedding ?? null);
+    const embeddingModel = row.embedding_model ?? null;
+    const res = await this.client.query(
+      `SELECT id, action FROM mem_upsert_by_keys(
+          $1::text, $2::jsonb, $3::text[], $4::text[], $5::jsonb, $6::text, $7::text,
+          $8::integer, $9::text, $10::text, $11::boolean
+       )`,
+      [
+        row.type,
+        JSON.stringify(row.data),
+        row.tags ?? null,
+        row.keys ?? null,
+        JSON.stringify(row.sources ?? {}),
+        row.searchable_text ?? null,
+        row.content_hash ?? null,
+        row.weight ?? null,
+        embedding,
+        embeddingModel,
+        opts.replace ?? false
+      ]
+    );
+    const { id, action } = res.rows[0];
+    const record = await this.getById(id);
+    if (!record) throw new Error(`upsertByKeys: record ${id} vanished mid-operation`);
+    return { record, action };
+  }
+  async getById(id, opts = {}) {
+    const res = await this.client.query(
+      `SELECT * FROM mem_records WHERE id = $1`,
+      [id]
+    );
+    const row = res.rows[0];
+    if (!row) return null;
+    const rec = toRecord(row);
+    if (!opts.withLinks) return rec;
+    const outgoing = await this.linked(id, { direction: "outgoing" });
+    const incoming = await this.linked(id, { direction: "incoming" });
+    return { ...rec, outgoing, incoming };
+  }
+  async update(id, patch) {
+    const existing = await this.getById(id);
+    if (!existing) return null;
+    const data = patch.data ? { ...existing.data, ...patch.data } : existing.data;
+    const tags = patch.tags ?? existing.tags ?? null;
+    const keys = patch.keys ?? existing.keys ?? null;
+    const sources = patch.sources ? { ...existing.sources, ...patch.sources } : existing.sources;
+    const searchable = patch.searchable_text ?? existing.searchable_text ?? null;
+    const hash = patch.content_hash ?? existing.content_hash ?? null;
+    const weight = patch.weight ?? existing.weight;
+    const res = await this.client.query(
+      `UPDATE mem_records
+         SET data = $2::jsonb,
+             tags = $3::text[],
+             keys = $4::text[],
+             sources = $5::jsonb,
+             searchable_text = $6,
+             content_hash = $7,
+             weight = $8
+       WHERE id = $1
+       RETURNING *`,
+      [id, JSON.stringify(data), tags, keys, JSON.stringify(sources), searchable, hash, weight]
+    );
+    return res.rows[0] ? toRecord(res.rows[0]) : null;
+  }
+  async remove(id) {
+    const res = await this.client.query(`DELETE FROM mem_records WHERE id = $1`, [id]);
+    return (res.rowCount ?? 0) > 0;
+  }
+  async archive(id, reason) {
+    const res = await this.client.query(
+      `UPDATE mem_records SET status = 'archived', archived_reason = $2
+       WHERE id = $1 AND status = 'active'`,
+      [id, reason ?? null]
+    );
+    return (res.rowCount ?? 0) > 0;
+  }
+  async unarchive(id) {
+    const res = await this.client.query(
+      `UPDATE mem_records SET status = 'active', archived_reason = NULL
+       WHERE id = $1 AND status = 'archived'`,
+      [id]
+    );
+    return (res.rowCount ?? 0) > 0;
+  }
+  async list(type, opts = {}) {
+    const limit = opts.limit ?? 100;
+    const offset = opts.offset ?? 0;
+    const status = opts.status ?? "active";
+    const res = await this.client.query(
+      `SELECT * FROM mem_records
+        WHERE type = $1 AND status = $2
+        ORDER BY updated_at DESC
+        LIMIT $3 OFFSET $4`,
+      [type, status, limit, offset]
+    );
+    return res.rows.map(toRecord);
+  }
+  async count(type, opts = {}) {
+    const status = opts.status ?? "active";
+    if (status === "all") {
+      const res2 = await this.client.query(
+        `SELECT COUNT(*)::text AS count FROM mem_records WHERE type = $1`,
+        [type]
+      );
+      return Number(res2.rows[0]?.count ?? 0);
+    }
+    const res = await this.client.query(
+      `SELECT COUNT(*)::text AS count FROM mem_records WHERE type = $1 AND status = $2`,
+      [type, status]
+    );
+    return Number(res.rows[0]?.count ?? 0);
+  }
+  async listForReindex(opts = {}) {
+    if (!this.caps.vectorSearch) return [];
+    const limit = opts.limit ?? 1e3;
+    const offset = opts.offset ?? 0;
+    const params = [];
+    const clauses = [
+      `status = 'active'`,
+      `searchable_text IS NOT NULL`,
+      `searchable_text <> ''`
+    ];
+    if (opts.type) {
+      params.push(opts.type);
+      clauses.push(`type = $${params.length}`);
+    }
+    if (!opts.includeAlreadyEmbedded) {
+      if (opts.targetEmbeddingModel) {
+        params.push(opts.targetEmbeddingModel);
+        clauses.push(`(embedded_at IS NULL OR embedding_model IS DISTINCT FROM $${params.length})`);
+      } else {
+        clauses.push(`embedded_at IS NULL`);
+      }
+    }
+    params.push(limit);
+    params.push(offset);
+    const res = await this.client.query(
+      `SELECT id, type, searchable_text, content_hash, embedding_model
+         FROM mem_records
+        WHERE ${clauses.join(" AND ")}
+        ORDER BY embedded_at ASC NULLS FIRST, id ASC
+        LIMIT $${params.length - 1} OFFSET $${params.length}`,
+      params
+    );
+    return res.rows;
+  }
+  async updateEmbedding(id, vector, model) {
+    if (!this.caps.vectorSearch) return;
+    const literal = vectorLiteral(vector);
+    if (literal === null) return;
+    await this.client.query(
+      `UPDATE mem_records
+          SET embedding = $2::vector,
+              embedding_model = $3,
+              embedded_at = NOW()
+        WHERE id = $1`,
+      [id, literal, model]
+    );
+  }
+  async listKeysByType(type) {
+    const res = await this.client.query(
+      `SELECT id, keys FROM mem_records WHERE type = $1 AND status = 'active'`,
+      [type]
+    );
+    return res.rows;
+  }
+  // ── Search ───────────────────────────────────────────────────────────
+  async search(q, opts) {
+    const limit = opts.limit ?? 10;
+    const type = opts.type ?? null;
+    const includeArchived = opts.includeArchived ?? false;
+    const ftsWeight = opts.ftsWeight ?? 0.3;
+    const semanticWeight = opts.semanticWeight ?? 0.7;
+    const embedding = vectorLiteral(opts.queryEmbedding ?? null);
+    const canSemantic = this.caps.vectorSearch && embedding !== null;
+    let rows;
+    if (canSemantic) {
+      const res = await this.client.query(
+        `SELECT * FROM mem_hybrid_search($1, $2::vector, $3, $4, $5, $6, 50, $7)`,
+        [q, embedding, limit, type, ftsWeight, semanticWeight, includeArchived]
+      );
+      rows = res.rows;
+    } else {
+      const res = await this.client.query(
+        `SELECT r.id,
+                r.type,
+                r.data,
+                r.tags,
+                ts_rank_cd(r.searchable, websearch_to_tsquery('english', $1))::float AS fts_rank,
+                0.0::float AS semantic_rank,
+                ts_rank_cd(r.searchable, websearch_to_tsquery('english', $1))::float AS combined_score
+           FROM mem_records r
+          WHERE r.searchable @@ websearch_to_tsquery('english', $1)
+            AND ($2::text IS NULL OR r.type = $2)
+            AND ($3 OR r.status = 'active')
+          ORDER BY combined_score DESC
+          LIMIT $4`,
+        [q, type, includeArchived, limit]
+      );
+      rows = res.rows;
+    }
+    if (opts.trackAccess !== false && rows.length > 0) {
+      await this.trackAccess(rows.map((r) => r.id));
+    }
+    return rows;
+  }
+  async context(opts) {
+    const limit = opts.limit ?? 20;
+    const types = opts.types ?? null;
+    const res = await this.client.query(
+      `SELECT id, type, data, tags, keys, weight, access_count,
+              mem_calculate_relevance(weight, access_count, last_accessed_at, created_at)::float AS relevance_score
+         FROM mem_records
+        WHERE status = 'active'
+          AND ($1::text[] IS NULL OR type = ANY($1))
+        ORDER BY relevance_score DESC
+        LIMIT $2`,
+      [types, limit]
+    );
+    return res.rows;
+  }
+  async trackAccess(ids) {
+    if (ids.length === 0) return;
+    await this.client.query(`SELECT mem_increment_access($1::uuid[])`, [ids]);
+  }
+  // ── Graph ────────────────────────────────────────────────────────────
+  async link(fromId, toId, relation, opts = {}) {
+    const bidirectional = opts.bidirectional ?? false;
+    const metadata = opts.metadata ? JSON.stringify(opts.metadata) : null;
+    const res = await this.client.query(
+      `INSERT INTO mem_links (from_id, to_id, relation, bidirectional, metadata)
+       VALUES ($1, $2, $3, $4, $5::jsonb)
+       ON CONFLICT (from_id, to_id, relation) DO UPDATE
+         SET bidirectional = EXCLUDED.bidirectional,
+             metadata = COALESCE(EXCLUDED.metadata, mem_links.metadata)
+       RETURNING id`,
+      [fromId, toId, relation, bidirectional, metadata]
+    );
+    return res.rows[0].id;
+  }
+  async unlink(fromId, toId, relation) {
+    const res = await this.client.query(
+      `DELETE FROM mem_links WHERE from_id = $1 AND to_id = $2 AND relation = $3`,
+      [fromId, toId, relation]
+    );
+    return (res.rowCount ?? 0) > 0;
+  }
+  async linked(id, opts = {}) {
+    const relation = opts.relation ?? null;
+    const direction = opts.direction ?? "outgoing";
+    const includeOutgoing = direction === "outgoing" || direction === "both";
+    const includeIncoming = direction === "incoming" || direction === "both";
+    const includeBidiAsIncoming = direction === "outgoing";
+    const res = await this.client.query(
+      `SELECT r.id, r.type, r.data, l.relation, l.bidirectional, l.metadata
+         FROM mem_links l
+         JOIN mem_records r ON r.id = l.to_id
+        WHERE l.from_id = $1
+          AND ($2::text IS NULL OR l.relation = $2)
+          AND $3::boolean
+       UNION ALL
+       SELECT r.id, r.type, r.data, l.relation, l.bidirectional, l.metadata
+         FROM mem_links l
+         JOIN mem_records r ON r.id = l.from_id
+        WHERE l.to_id = $1
+          AND ($2::text IS NULL OR l.relation = $2)
+          AND ($4::boolean OR ($5::boolean AND l.bidirectional = true))`,
+      [id, relation, includeOutgoing, includeIncoming, includeBidiAsIncoming]
+    );
+    return res.rows;
+  }
+  // ── Sources ──────────────────────────────────────────────────────────
+  async addSource(recordId, ref) {
+    const entry = {
+      url: ref.url ?? null,
+      metadata: ref.metadata ?? {},
+      last_synced_at: ref.last_synced_at ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.client.query(
+      `UPDATE mem_records
+          SET sources = sources || jsonb_build_object($2::text, $3::jsonb),
+              keys = (SELECT ARRAY(SELECT DISTINCT unnest FROM unnest(COALESCE(keys, '{}') || ARRAY[$2::text])))
+        WHERE id = $1`,
+      [recordId, ref.sourceKey, JSON.stringify(entry)]
+    );
+  }
+  async removeSource(recordId, sourceKey) {
+    const res = await this.client.query(
+      `UPDATE mem_records
+          SET sources = sources - $2::text
+        WHERE id = $1 AND sources ? $2`,
+      [recordId, sourceKey]
+    );
+    return (res.rowCount ?? 0) > 0;
+  }
+  async findBySource(sourceKey) {
+    const res = await this.client.query(
+      `SELECT * FROM mem_records WHERE $1 = ANY(keys) LIMIT 1`,
+      [sourceKey]
+    );
+    return res.rows[0] ? toRecord(res.rows[0]) : null;
+  }
+  async listSources(recordId) {
+    const res = await this.client.query(
+      `SELECT sources FROM mem_records WHERE id = $1`,
+      [recordId]
+    );
+    return res.rows[0]?.sources ?? {};
+  }
+  // ── Sync state ───────────────────────────────────────────────────────
+  async getSyncState(platform, model) {
+    const res = await this.client.query(
+      `SELECT * FROM mem_sync_state WHERE platform = $1 AND model = $2`,
+      [platform, model]
+    );
+    return res.rows[0] ?? null;
+  }
+  async setSyncState(state) {
+    await this.client.query(
+      `INSERT INTO mem_sync_state (platform, model, last_sync_at, last_cursor, since,
+                                   total_records, pages_processed, status, last_error)
+       VALUES ($1, $2, $3, $4::jsonb, $5, $6, $7, $8, $9)
+       ON CONFLICT (platform, model) DO UPDATE SET
+         last_sync_at = EXCLUDED.last_sync_at,
+         last_cursor = EXCLUDED.last_cursor,
+         since = EXCLUDED.since,
+         total_records = EXCLUDED.total_records,
+         pages_processed = EXCLUDED.pages_processed,
+         status = EXCLUDED.status,
+         last_error = EXCLUDED.last_error`,
+      [
+        state.platform,
+        state.model,
+        state.last_sync_at ?? null,
+        JSON.stringify(state.last_cursor ?? null),
+        state.since ?? null,
+        state.total_records,
+        state.pages_processed,
+        state.status,
+        state.last_error ?? null
+      ]
+    );
+  }
+  async listSyncStates() {
+    const res = await this.client.query(
+      `SELECT * FROM mem_sync_state ORDER BY platform, model`
+    );
+    return res.rows;
+  }
+  async removeSyncState(platform, model) {
+    if (model) {
+      await this.client.query(
+        `DELETE FROM mem_sync_state WHERE platform = $1 AND model = $2`,
+        [platform, model]
+      );
+    } else {
+      await this.client.query(`DELETE FROM mem_sync_state WHERE platform = $1`, [platform]);
+    }
+  }
+  // ── Raw read-only SQL ───────────────────────────────────────────────
+  //
+  // Exposed to users via `one mem sql` and `one sync sql` so they can run
+  // joins / aggregates / JSONB paths that the high-level helpers can't.
+  // The guard rejects anything that isn't SELECT / WITH / EXPLAIN before
+  // the query reaches the client.
+  async raw(sql, params) {
+    validateReadOnlySql(sql);
+    const res = await this.client.query(sql, params ?? []);
+    const columns = res.rows.length > 0 ? Object.keys(res.rows[0]) : [];
+    return {
+      columns,
+      rows: res.rows,
+      rowCount: res.rows.length
+    };
+  }
+  // ── Hot columns ──────────────────────────────────────────────────────
+  async ensureHotColumn(type, jsonPath) {
+    if (!this.caps.partialIndexes) return;
+    const name = hotColumnIndexName(type, jsonPath);
+    const pathArr = jsonPathArray(jsonPath);
+    await this.client.query(
+      `CREATE INDEX IF NOT EXISTS ${name}
+        ON mem_records ((data #>> '${pathArr}'::text[]))
+        WHERE type = $1`,
+      [type]
+    );
+  }
+  async dropHotColumn(type, jsonPath) {
+    const name = hotColumnIndexName(type, jsonPath);
+    await this.client.query(`DROP INDEX IF EXISTS ${name}`);
+  }
+  // ── Maintenance ──────────────────────────────────────────────────────
+  async vacuum() {
+    await this.client.query(`VACUUM ANALYZE mem_records`);
+    await this.client.query(`VACUUM ANALYZE mem_links`);
+    await this.client.query(`VACUUM ANALYZE mem_sync_state`);
+  }
+  async stats() {
+    const embeddedCountSql = this.caps.vectorSearch ? `(SELECT COUNT(*) FROM mem_records WHERE embedding IS NOT NULL)` : `(SELECT 0)`;
+    const res = await this.client.query(
+      `SELECT
+         (SELECT COUNT(*) FROM mem_records)                              AS record_count,
+         (SELECT COUNT(*) FROM mem_records WHERE status = 'active')      AS active_count,
+         (SELECT COUNT(*) FROM mem_records WHERE status = 'archived')    AS archived_count,
+         (SELECT COUNT(*) FROM mem_links)                                AS link_count,
+         ${embeddedCountSql}                                             AS embedded_count`
+    );
+    const r = res.rows[0];
+    return {
+      recordCount: Number(r.record_count),
+      activeCount: Number(r.active_count),
+      archivedCount: Number(r.archived_count),
+      linkCount: Number(r.link_count),
+      embeddedCount: Number(r.embedded_count)
+    };
+  }
+  capabilities() {
+    return this.caps;
+  }
+};
+
+// src/lib/memory/plugins/postgres/index.ts
+var CAPABILITIES = {
+  vectorSearch: true,
+  fullTextSearch: true,
+  partialIndexes: true,
+  jsonPathQuery: true,
+  triggers: true,
+  concurrentWriters: true,
+  maxVectorDims: 2e3,
+  rawSql: true
+};
+function parseConfig(raw) {
+  const r = raw ?? {};
+  const envOverride = process.env.MEM_DATABASE_URL;
+  const connectionString = envOverride ?? r.connectionString ?? "";
+  if (!connectionString) {
+    throw new Error(
+      "Postgres backend requires a connection string. Set MEM_DATABASE_URL, or run `one mem config set memory.postgres.connectionString <url>`."
+    );
+  }
+  const schema = typeof r.schema === "string" && r.schema ? r.schema : "public";
+  return { connectionString, schema };
+}
+function wrapClient(pool) {
+  return {
+    async query(text, params) {
+      const res = await pool.query(text, params);
+      return { rows: res.rows, rowCount: res.rowCount ?? void 0 };
+    },
+    async transaction(fn) {
+      const tx = await pool.connect();
+      const txClient = {
+        async query(text, params) {
+          const res = await tx.query(text, params);
+          return { rows: res.rows, rowCount: res.rowCount ?? void 0 };
+        },
+        async transaction() {
+          throw new Error("Nested transactions are not supported.");
+        },
+        async close() {
+          tx.release();
+        }
+      };
+      try {
+        await tx.query("BEGIN");
+        const result = await fn(txClient);
+        await tx.query("COMMIT");
+        return result;
+      } catch (err) {
+        try {
+          await tx.query("ROLLBACK");
+        } catch {
+        }
+        throw err;
+      } finally {
+        tx.release();
+      }
+    },
+    async close() {
+      await pool.end();
+    }
+  };
+}
+var LazyPostgresBackend = class {
+  backend = null;
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async ensure() {
+    if (this.backend) return this.backend;
+    const pg = await import("pg").catch((err) => {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(
+        `pg is not installed. Run \`npm i -g pg\` or pick a different backend. (${msg})`
+      );
+    });
+    const PoolCtor = pg.Pool ?? pg.default.Pool;
+    const pool = new PoolCtor({ connectionString: this.config.connectionString });
+    this.backend = new CoreBackend(wrapClient(pool), CAPABILITIES);
+    return this.backend;
+  }
+  capabilities() {
+    return CAPABILITIES;
+  }
+  async init() {
+    await this.ensure();
+  }
+  async close() {
+    if (this.backend) await this.backend.close();
+    this.backend = null;
+  }
+  async ensureSchema() {
+    return (await this.ensure()).ensureSchema();
+  }
+  async getSchemaVersion() {
+    return (await this.ensure()).getSchemaVersion();
+  }
+  async insert(...a) {
+    return (await this.ensure()).insert(...a);
+  }
+  async upsertByKeys(...a) {
+    return (await this.ensure()).upsertByKeys(...a);
+  }
+  async getById(...a) {
+    return (await this.ensure()).getById(...a);
+  }
+  async update(...a) {
+    return (await this.ensure()).update(...a);
+  }
+  async remove(...a) {
+    return (await this.ensure()).remove(...a);
+  }
+  async archive(...a) {
+    return (await this.ensure()).archive(...a);
+  }
+  async unarchive(...a) {
+    return (await this.ensure()).unarchive(...a);
+  }
+  async list(...a) {
+    return (await this.ensure()).list(...a);
+  }
+  async count(...a) {
+    return (await this.ensure()).count(...a);
+  }
+  async listForReindex(...a) {
+    return (await this.ensure()).listForReindex(...a);
+  }
+  async listKeysByType(...a) {
+    return (await this.ensure()).listKeysByType(...a);
+  }
+  async updateEmbedding(...a) {
+    return (await this.ensure()).updateEmbedding(...a);
+  }
+  async raw(sql, params) {
+    const b = await this.ensure();
+    if (!b.raw) throw new Error("Backend does not support raw SQL");
+    return b.raw(sql, params);
+  }
+  async search(...a) {
+    return (await this.ensure()).search(...a);
+  }
+  async context(...a) {
+    return (await this.ensure()).context(...a);
+  }
+  async trackAccess(...a) {
+    return (await this.ensure()).trackAccess(...a);
+  }
+  async link(...a) {
+    return (await this.ensure()).link(...a);
+  }
+  async unlink(...a) {
+    return (await this.ensure()).unlink(...a);
+  }
+  async linked(...a) {
+    return (await this.ensure()).linked(...a);
+  }
+  async addSource(...a) {
+    return (await this.ensure()).addSource(...a);
+  }
+  async removeSource(...a) {
+    return (await this.ensure()).removeSource(...a);
+  }
+  async findBySource(...a) {
+    return (await this.ensure()).findBySource(...a);
+  }
+  async listSources(...a) {
+    return (await this.ensure()).listSources(...a);
+  }
+  async getSyncState(...a) {
+    return (await this.ensure()).getSyncState(...a);
+  }
+  async setSyncState(...a) {
+    return (await this.ensure()).setSyncState(...a);
+  }
+  async listSyncStates() {
+    return (await this.ensure()).listSyncStates();
+  }
+  async removeSyncState(...a) {
+    return (await this.ensure()).removeSyncState(...a);
+  }
+  async ensureHotColumn(...a) {
+    return (await this.ensure()).ensureHotColumn(...a);
+  }
+  async dropHotColumn(...a) {
+    return (await this.ensure()).dropHotColumn(...a);
+  }
+  async vacuum() {
+    return (await this.ensure()).vacuum();
+  }
+  async stats() {
+    return (await this.ensure()).stats();
+  }
+};
+var postgresPlugin = {
+  name: "postgres",
+  description: "Postgres over node-pg. Works with Supabase, Neon, self-hosted.",
+  version: "0.1.0",
+  schemaVersion: SCHEMA_VERSION,
+  capabilities: CAPABILITIES,
+  parseConfig,
+  create(config) {
+    return new LazyPostgresBackend(config);
+  }
+};
+
+// src/lib/memory/plugins/embedded-postgres/index.ts
+import fs from "fs";
+import net from "net";
+import path from "path";
+import os from "os";
+import { createRequire } from "module";
+import { spawn } from "child_process";
+var requireFromHere = createRequire(import.meta.url);
+var BASE_CAPABILITIES = {
+  vectorSearch: true,
+  fullTextSearch: true,
+  partialIndexes: true,
+  jsonPathQuery: true,
+  triggers: true,
+  concurrentWriters: true,
+  maxVectorDims: 2e3,
+  rawSql: true
+};
+var DEFAULTS = {
+  dataDir: path.join(os.homedir(), ".one", "pg"),
+  database: "one_mem",
+  schema: "public",
+  pgvector: true,
+  host: "127.0.0.1",
+  port: 5434,
+  // 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.
+  user: "postgres",
+  password: "",
+  logLevel: "warn",
+  startupTimeoutMs: 3e4
+};
+function parseConfig2(raw) {
+  const r = raw ?? {};
+  return {
+    dataDir: r.dataDir ?? DEFAULTS.dataDir,
+    database: r.database ?? DEFAULTS.database,
+    schema: r.schema ?? DEFAULTS.schema,
+    pgvector: r.pgvector ?? DEFAULTS.pgvector,
+    host: r.host ?? DEFAULTS.host,
+    port: r.port ?? DEFAULTS.port,
+    user: r.user ?? DEFAULTS.user,
+    password: r.password ?? DEFAULTS.password,
+    logLevel: r.logLevel ?? DEFAULTS.logLevel,
+    startupTimeoutMs: r.startupTimeoutMs ?? DEFAULTS.startupTimeoutMs
+  };
+}
+function wrapClient2(pool) {
+  return {
+    async query(text, params) {
+      const res = await pool.query(text, params);
+      return { rows: res.rows, rowCount: res.rowCount ?? void 0 };
+    },
+    async transaction(fn) {
+      const tx = await pool.connect();
+      const txClient = {
+        async query(text, params) {
+          const res = await tx.query(text, params);
+          return { rows: res.rows, rowCount: res.rowCount ?? void 0 };
+        },
+        async transaction() {
+          throw new Error("Nested transactions are not supported.");
+        },
+        async close() {
+          tx.release();
+        }
+      };
+      try {
+        await tx.query("BEGIN");
+        const result = await fn(txClient);
+        await tx.query("COMMIT");
+        return result;
+      } catch (err) {
+        try {
+          await tx.query("ROLLBACK");
+        } catch {
+        }
+        throw err;
+      } finally {
+        tx.release();
+      }
+    },
+    async close() {
+      await pool.end();
+    }
+  };
+}
+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");
+    return true;
+  } catch {
+    return false;
+  }
+}
+var LazyEmbeddedPostgresBackend = class {
+  backend = null;
+  config;
+  resolvedCaps = BASE_CAPABILITIES;
+  constructor(config) {
+    this.config = config;
+  }
+  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 pool = new PoolCtor({
+      host: this.config.host,
+      port: this.config.port,
+      database: this.config.database,
+      user: this.config.user,
+      password: this.config.password
+    });
+    const client = wrapClient2(pool);
+    const hasVector = await probePgvector(client);
+    this.resolvedCaps = hasVector ? BASE_CAPABILITIES : { ...BASE_CAPABILITIES, vectorSearch: false, maxVectorDims: null };
+    this.backend = new CoreBackend(client, this.resolvedCaps);
+    return this.backend;
+  }
+  capabilities() {
+    return this.resolvedCaps;
+  }
+  async init() {
+    await this.ensure();
+  }
+  async close() {
+    if (this.backend) await this.backend.close();
+    this.backend = null;
+  }
+  async ensureSchema() {
+    return (await this.ensure()).ensureSchema();
+  }
+  async getSchemaVersion() {
+    return (await this.ensure()).getSchemaVersion();
+  }
+  async insert(...a) {
+    return (await this.ensure()).insert(...a);
+  }
+  async upsertByKeys(...a) {
+    return (await this.ensure()).upsertByKeys(...a);
+  }
+  async getById(...a) {
+    return (await this.ensure()).getById(...a);
+  }
+  async update(...a) {
+    return (await this.ensure()).update(...a);
+  }
+  async remove(...a) {
+    return (await this.ensure()).remove(...a);
+  }
+  async archive(...a) {
+    return (await this.ensure()).archive(...a);
+  }
+  async unarchive(...a) {
+    return (await this.ensure()).unarchive(...a);
+  }
+  async list(...a) {
+    return (await this.ensure()).list(...a);
+  }
+  async count(...a) {
+    return (await this.ensure()).count(...a);
+  }
+  async listForReindex(...a) {
+    return (await this.ensure()).listForReindex(...a);
+  }
+  async listKeysByType(...a) {
+    return (await this.ensure()).listKeysByType(...a);
+  }
+  async updateEmbedding(...a) {
+    return (await this.ensure()).updateEmbedding(...a);
+  }
+  async raw(sql, params) {
+    const b = await this.ensure();
+    if (!b.raw) throw new Error("Backend does not support raw SQL");
+    return b.raw(sql, params);
+  }
+  async search(...a) {
+    return (await this.ensure()).search(...a);
+  }
+  async context(...a) {
+    return (await this.ensure()).context(...a);
+  }
+  async trackAccess(...a) {
+    return (await this.ensure()).trackAccess(...a);
+  }
+  async link(...a) {
+    return (await this.ensure()).link(...a);
+  }
+  async unlink(...a) {
+    return (await this.ensure()).unlink(...a);
+  }
+  async linked(...a) {
+    return (await this.ensure()).linked(...a);
+  }
+  async addSource(...a) {
+    return (await this.ensure()).addSource(...a);
+  }
+  async removeSource(...a) {
+    return (await this.ensure()).removeSource(...a);
+  }
+  async findBySource(...a) {
+    return (await this.ensure()).findBySource(...a);
+  }
+  async listSources(...a) {
+    return (await this.ensure()).listSources(...a);
+  }
+  async getSyncState(...a) {
+    return (await this.ensure()).getSyncState(...a);
+  }
+  async setSyncState(...a) {
+    return (await this.ensure()).setSyncState(...a);
+  }
+  async listSyncStates() {
+    return (await this.ensure()).listSyncStates();
+  }
+  async removeSyncState(...a) {
+    return (await this.ensure()).removeSyncState(...a);
+  }
+  async ensureHotColumn(...a) {
+    return (await this.ensure()).ensureHotColumn(...a);
+  }
+  async dropHotColumn(...a) {
+    return (await this.ensure()).dropHotColumn(...a);
+  }
+  async vacuum() {
+    return (await this.ensure()).vacuum();
+  }
+  async stats() {
+    return (await this.ensure()).stats();
+  }
+};
+var embeddedPostgresPlugin = {
+  name: "embedded-postgres",
+  description: "Local Postgres 18 bootstrapped on-demand via pgserve. Default backend for new installs. Semantic search (pgvector) auto-enables when the extension is locally installed; otherwise FTS-only with an upgrade hint.",
+  version: "0.1.0",
+  schemaVersion: SCHEMA_VERSION,
+  capabilities: BASE_CAPABILITIES,
+  parseConfig: parseConfig2,
+  create(config) {
+    return new LazyEmbeddedPostgresBackend(config);
+  }
+};
+
+// src/lib/memory/plugins.ts
+var registry = /* @__PURE__ */ new Map();
+function registerBackend(plugin) {
+  if (registry.has(plugin.name)) {
+    const existing = registry.get(plugin.name);
+    if (existing.version === plugin.version) return;
+    throw new Error(
+      `Backend plugin name conflict: "${plugin.name}" already registered (v${existing.version}); refusing to overwrite with v${plugin.version}.`
+    );
+  }
+  registry.set(plugin.name, plugin);
+}
+function getBackendPlugin(name) {
+  const plugin = registry.get(name);
+  if (!plugin) {
+    const available = [...registry.keys()].join(", ") || "(none registered)";
+    throw new Error(
+      `Backend plugin "${name}" is not registered. Available: ${available}. If this is a third-party plugin, add it to "memory.plugins" in your config.`
+    );
+  }
+  return plugin;
+}
+function listBackendPlugins() {
+  return [...registry.values()];
+}
+async function loadBackendFromConfig(cfg) {
+  for (const spec of cfg.plugins ?? []) {
+    try {
+      const mod = await import(spec);
+      const plugin2 = mod.default ?? mod;
+      if (!plugin2 || typeof plugin2 !== "object" || typeof plugin2.name !== "string") {
+        throw new Error(
+          `Package "${spec}" does not export a MemBackendPlugin as default. Ensure the package's default export is the plugin descriptor.`
+        );
+      }
+      registerBackend(plugin2);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to load memory plugin "${spec}": ${message}`);
+    }
+  }
+  const plugin = getBackendPlugin(cfg.backend);
+  const backendConfig = plugin.parseConfig(cfg[cfg.backend] ?? {});
+  return plugin.create(backendConfig);
+}
+registerBackend(embeddedPostgresPlugin);
+registerBackend(postgresPlugin);
+
+// src/lib/memory/canonical.ts
+import { createHash } from "crypto";
+function canonicalize(value) {
+  return JSON.stringify(canonicalValue(value));
+}
+function canonicalValue(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map(canonicalValue);
+  const obj = value;
+  const sorted = {};
+  for (const key of Object.keys(obj).sort()) {
+    sorted[key] = canonicalValue(obj[key]);
+  }
+  return sorted;
+}
+function contentHash(data) {
+  return createHash("sha256").update(canonicalize(data)).digest("hex");
+}
+
+// src/lib/memory/runtime.ts
+var cached = null;
+async function getBackend() {
+  if (cached) return cached;
+  if (!getMemoryConfig()) {
+    bootstrapMemoryDefaults();
+  }
+  const cfg = getMemoryConfigOrDefault();
+  cached = (async () => {
+    const backend = await loadBackendFromConfig(cfg);
+    await backend.init();
+    await backend.ensureSchema();
+    return backend;
+  })();
+  return cached;
+}
+function bootstrapMemoryDefaults() {
+  const hasOpenAiKey = !!getOpenAiApiKey();
+  const next = {
+    ...DEFAULT_MEMORY_CONFIG,
+    embedding: {
+      ...DEFAULT_MEMORY_CONFIG.embedding,
+      provider: hasOpenAiKey ? "openai" : "none"
+    }
+  };
+  updateMemoryConfig(next);
+  if (process.stderr.isTTY) {
+    process.stderr.write(
+      `one mem: initialized ${hasOpenAiKey ? "(embeddings enabled)" : "(FTS only; set OpenAI key for semantic search)"}
+`
+    );
+  }
+}
+function resetBackendSingleton() {
+  cached = null;
+}
+async function closeBackendIfCached() {
+  if (!cached) return;
+  try {
+    const backend = await cached;
+    await backend.close();
+  } catch {
+  }
+  cached = null;
+}
+async function addRecord(input, opts = {}) {
+  const backend = await getBackend();
+  const { searchable_text, content_hash, embedding, embedding_model } = await prepareRecord(input, opts, "add");
+  const prepared = {
+    ...input,
+    searchable_text: input.searchable_text ?? searchable_text,
+    content_hash: input.content_hash ?? content_hash,
+    embedding,
+    embedding_model
+  };
+  return backend.insert(prepared);
+}
+async function upsertRecord(input, opts = {}) {
+  const backend = await getBackend();
+  const { searchable_text, content_hash, embedding, embedding_model } = await prepareRecord(input, opts, "sync");
+  const prepared = {
+    ...input,
+    searchable_text: input.searchable_text ?? searchable_text,
+    content_hash: input.content_hash ?? content_hash,
+    embedding,
+    embedding_model
+  };
+  const backendOpts = { replace: opts.replace ?? false };
+  return backend.upsertByKeys(prepared, backendOpts);
+}
+async function prepareRecord(input, opts, ctx) {
+  const cfg = getMemoryConfigOrDefault();
+  const searchable_text = input.searchable_text ?? defaultSearchableText(input.data);
+  const content_hash = input.content_hash ?? contentHash(input.data);
+  const wantEmbed = opts.embed ?? input.embed ?? (ctx === "add" ? cfg.defaults.embedOnAdd : cfg.defaults.embedOnSync);
+  if (!wantEmbed || cfg.embedding.provider === "none" || !searchable_text) {
+    return { searchable_text, content_hash, embedding: null, embedding_model: null };
+  }
+  const result = await embed(searchable_text, { model: opts.embeddingModel });
+  if (!result) return { searchable_text, content_hash, embedding: null, embedding_model: null };
+  return { searchable_text, content_hash, embedding: result.vector, embedding_model: result.model };
+}
+
+export {
+  SCHEMA_VERSION,
+  getBackendPlugin,
+  listBackendPlugins,
+  loadBackendFromConfig,
+  getBackend,
+  resetBackendSingleton,
+  closeBackendIfCached,
+  addRecord,
+  upsertRecord
+};