@cohaku/cli 0.2.6

package/dist/chunk-HMH4HWDA.js

@@ -0,0 +1,1136 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+
+// src/shared/engine.ts
+import { join } from "path";
+import { homedir } from "os";
+import { execSync } from "child_process";
+
+// ../core/src/storage/sqlite-driver.ts
+import Database from "better-sqlite3";
+import * as sqliteVec from "sqlite-vec";
+
+// ../shared/src/constants.ts
+var DEFAULT_WEIGHTS = {
+  semantic: 0.4,
+  bm25: 0.25,
+  recency: 0.2,
+  salience: 0.15
+};
+var MEMORY_LAYER_PRIORITY = {
+  rule: 10,
+  working: 5,
+  long_term: 1
+};
+var DEFAULT_DECAY_RATE = 0.01;
+var DEFAULT_EMBEDDING_DIMENSIONS = 384;
+
+// ../core/src/storage/schema.ts
+var SCHEMA_VERSION = 2;
+var CREATE_TABLES = `
+  -- Memory (3-layer)
+  CREATE TABLE IF NOT EXISTS memories (
+    id TEXT PRIMARY KEY,
+    project_id TEXT,
+    content TEXT NOT NULL,
+    layer TEXT NOT NULL DEFAULT 'long_term',
+    type TEXT NOT NULL DEFAULT 'note',
+    priority INTEGER NOT NULL DEFAULT 1,
+    importance REAL NOT NULL DEFAULT 0.5,
+    tags TEXT,
+    expires_at TEXT,
+    last_accessed_at TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    deleted_at TEXT
+  );
+
+  -- FTS5 virtual table (BM25 search)
+  CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+    content,
+    tags,
+    content='memories',
+    content_rowid='rowid',
+    tokenize='porter'
+  );
+
+  -- FTS5 sync triggers
+  CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+    INSERT INTO memories_fts(rowid, content, tags)
+    VALUES (new.rowid, new.content, new.tags);
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
+    INSERT INTO memories_fts(memories_fts, rowid, content, tags)
+    VALUES ('delete', old.rowid, old.content, old.tags);
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
+    INSERT INTO memories_fts(memories_fts, rowid, content, tags)
+    VALUES ('delete', old.rowid, old.content, old.tags);
+    INSERT INTO memories_fts(rowid, content, tags)
+    VALUES (new.rowid, new.content, new.tags);
+  END;
+
+  -- Entity nodes
+  CREATE TABLE IF NOT EXISTS nodes (
+    id TEXT PRIMARY KEY,
+    project_id TEXT,
+    name TEXT NOT NULL,
+    name_embedding BLOB,
+    summary TEXT,
+    entity_type TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+
+  -- Edges (bi-temporal)
+  CREATE TABLE IF NOT EXISTS edges (
+    id TEXT PRIMARY KEY,
+    project_id TEXT,
+    source_id TEXT NOT NULL REFERENCES nodes(id),
+    target_id TEXT NOT NULL REFERENCES nodes(id),
+    relation TEXT NOT NULL,
+    fact TEXT,
+    fact_embedding BLOB,
+    created_at TEXT NOT NULL,
+    expired_at TEXT,
+    valid_at TEXT,
+    invalid_at TEXT
+  );
+
+  -- Episodes
+  CREATE TABLE IF NOT EXISTS episodes (
+    id TEXT PRIMARY KEY,
+    project_id TEXT,
+    content TEXT NOT NULL,
+    content_type TEXT,
+    source TEXT,
+    created_at TEXT NOT NULL
+  );
+
+  -- Episode references
+  CREATE TABLE IF NOT EXISTS episode_refs (
+    episode_id TEXT REFERENCES episodes(id),
+    ref_type TEXT,
+    ref_id TEXT,
+    PRIMARY KEY (episode_id, ref_type, ref_id)
+  );
+
+  -- Sessions
+  CREATE TABLE IF NOT EXISTS sessions (
+    id TEXT PRIMARY KEY,
+    project_id TEXT,
+    status TEXT NOT NULL DEFAULT 'active',
+    started_at TEXT NOT NULL,
+    ended_at TEXT,
+    checkpoint_count INTEGER NOT NULL DEFAULT 0,
+    working_memory_snapshot TEXT,
+    metadata TEXT
+  );
+
+  -- Config
+  CREATE TABLE IF NOT EXISTS config (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+  );
+
+  -- Indexes
+  CREATE INDEX IF NOT EXISTS idx_memories_layer ON memories(layer);
+  CREATE INDEX IF NOT EXISTS idx_memories_deleted ON memories(deleted_at);
+  CREATE INDEX IF NOT EXISTS idx_memories_project ON memories(project_id);
+  CREATE INDEX IF NOT EXISTS idx_nodes_project ON nodes(project_id);
+  CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source_id);
+  CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target_id);
+  CREATE INDEX IF NOT EXISTS idx_edges_expired ON edges(expired_at);
+  CREATE INDEX IF NOT EXISTS idx_edges_project ON edges(project_id);
+  CREATE INDEX IF NOT EXISTS idx_episodes_project ON episodes(project_id);
+  CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+  CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id);
+`;
+var MIGRATE_V1_TO_V2 = `
+  ALTER TABLE memories ADD COLUMN project_id TEXT;
+  ALTER TABLE nodes ADD COLUMN project_id TEXT;
+  ALTER TABLE edges ADD COLUMN project_id TEXT;
+  ALTER TABLE episodes ADD COLUMN project_id TEXT;
+  ALTER TABLE sessions ADD COLUMN project_id TEXT;
+
+  CREATE INDEX IF NOT EXISTS idx_memories_project ON memories(project_id);
+  CREATE INDEX IF NOT EXISTS idx_nodes_project ON nodes(project_id);
+  CREATE INDEX IF NOT EXISTS idx_edges_project ON edges(project_id);
+  CREATE INDEX IF NOT EXISTS idx_episodes_project ON episodes(project_id);
+  CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id);
+`;
+function createVecTables(dimensions) {
+  return `
+    CREATE VIRTUAL TABLE IF NOT EXISTS vec_memories USING vec0(
+      memory_id TEXT PRIMARY KEY,
+      embedding float[${dimensions}]
+    );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS vec_nodes USING vec0(
+      node_id TEXT PRIMARY KEY,
+      embedding float[${dimensions}]
+    );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS vec_edges USING vec0(
+      edge_id TEXT PRIMARY KEY,
+      embedding float[${dimensions}]
+    );
+  `;
+}
+
+// ../core/src/utils/temporal.ts
+function nowISO() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function toVecBlob(embedding) {
+  return Buffer.from(new Float32Array(embedding).buffer);
+}
+
+// ../core/src/storage/sqlite-driver.ts
+var SqliteDriver = class {
+  constructor(dbPath, dimensions = DEFAULT_EMBEDDING_DIMENSIONS) {
+    this.dbPath = dbPath;
+    this.dimensions = dimensions;
+  }
+  db;
+  async initialize() {
+    this.db = new Database(this.dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    sqliteVec.load(this.db);
+    this.db.exec("CREATE TABLE IF NOT EXISTS config (key TEXT PRIMARY KEY, value TEXT NOT NULL)");
+    const existing = this.db.prepare("SELECT value FROM config WHERE key = ?").get("schema_version");
+    const currentVersion = existing ? Number(existing.value) : 0;
+    if (currentVersion >= 1 && currentVersion < 2) {
+      for (const stmt of MIGRATE_V1_TO_V2.split(";").filter((s) => s.trim())) {
+        this.db.exec(stmt);
+      }
+    }
+    this.db.exec(CREATE_TABLES);
+    const vecSQL = createVecTables(this.dimensions);
+    for (const stmt of vecSQL.split(";").filter((s) => s.trim())) {
+      this.db.exec(stmt);
+    }
+    this.db.prepare("INSERT INTO config (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run("schema_version", String(SCHEMA_VERSION));
+  }
+  close() {
+    this.db.close();
+  }
+  // ── Project Filter Helper ──
+  buildProjectFilter(projectIds, tableAlias) {
+    if (!projectIds) return { clause: "", params: [] };
+    const hasNull = projectIds.includes(null);
+    const nonNull = projectIds.filter((id) => id !== null);
+    const conditions = [];
+    const params = [];
+    if (hasNull) {
+      conditions.push(`${tableAlias}.project_id IS NULL`);
+    }
+    if (nonNull.length > 0) {
+      conditions.push(`${tableAlias}.project_id IN (${nonNull.map(() => "?").join(", ")})`);
+      params.push(...nonNull);
+    }
+    if (conditions.length === 0) return { clause: "", params: [] };
+    return { clause: `AND (${conditions.join(" OR ")})`, params };
+  }
+  // ── Memory ──
+  async addMemory(memory) {
+    const tagsStr = memory.tags ? JSON.stringify(memory.tags) : null;
+    this.db.transaction(() => {
+      this.db.prepare(`
+        INSERT INTO memories (id, project_id, content, layer, type, priority, importance, tags, expires_at, last_accessed_at, created_at, updated_at, deleted_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        memory.id,
+        memory.projectId ?? null,
+        memory.content,
+        memory.layer,
+        memory.type,
+        memory.priority,
+        memory.importance,
+        tagsStr,
+        memory.expiresAt ?? null,
+        memory.lastAccessedAt,
+        memory.createdAt,
+        memory.updatedAt,
+        memory.deletedAt ?? null
+      );
+      if (memory.embedding) {
+        this.db.prepare(`
+          INSERT INTO vec_memories (memory_id, embedding) VALUES (?, ?)
+        `).run(memory.id, toVecBlob(memory.embedding));
+      }
+    })();
+  }
+  async getMemory(id) {
+    const row = this.db.prepare("SELECT * FROM memories WHERE id = ? AND deleted_at IS NULL").get(id);
+    return row ? this.rowToMemory(row) : null;
+  }
+  async updateMemory(id, input) {
+    const sets = ["updated_at = ?"];
+    const values = [(/* @__PURE__ */ new Date()).toISOString()];
+    if (input.content !== void 0) {
+      sets.push("content = ?");
+      values.push(input.content);
+    }
+    if (input.layer !== void 0) {
+      sets.push("layer = ?");
+      values.push(input.layer);
+    }
+    if (input.type !== void 0) {
+      sets.push("type = ?");
+      values.push(input.type);
+    }
+    if (input.importance !== void 0) {
+      sets.push("importance = ?");
+      values.push(input.importance);
+    }
+    if (input.tags !== void 0) {
+      sets.push("tags = ?");
+      values.push(JSON.stringify(input.tags));
+    }
+    if (input.expiresAt !== void 0) {
+      sets.push("expires_at = ?");
+      values.push(input.expiresAt);
+    }
+    values.push(id);
+    this.db.prepare(`UPDATE memories SET ${sets.join(", ")} WHERE id = ?`).run(...values);
+  }
+  async updateMemoryEmbedding(id, embedding) {
+    this.db.transaction(() => {
+      this.db.prepare("DELETE FROM vec_memories WHERE memory_id = ?").run(id);
+      this.db.prepare(
+        "INSERT INTO vec_memories (memory_id, embedding) VALUES (?, ?)"
+      ).run(id, toVecBlob(embedding));
+    })();
+  }
+  async deleteMemory(id) {
+    this.db.prepare("UPDATE memories SET deleted_at = ? WHERE id = ?").run((/* @__PURE__ */ new Date()).toISOString(), id);
+  }
+  async searchMemories(embedding, limit, projectIds) {
+    const { clause, params } = this.buildProjectFilter(projectIds, "m");
+    const rows = this.db.prepare(`
+      SELECT m.*, v.distance
+      FROM vec_memories v
+      INNER JOIN memories m ON m.id = v.memory_id
+      WHERE v.embedding MATCH ?
+        AND m.deleted_at IS NULL
+        AND k = ?
+        ${clause}
+    `).all(toVecBlob(embedding), limit, ...params);
+    return rows.map((row) => ({
+      memory: this.rowToMemory(row),
+      distance: row.distance
+    }));
+  }
+  async fullTextSearch(query, limit, projectIds) {
+    const { clause, params } = this.buildProjectFilter(projectIds, "m");
+    const rows = this.db.prepare(`
+      SELECT m.*, fts.rank
+      FROM memories_fts fts
+      INNER JOIN memories m ON m.rowid = fts.rowid
+      WHERE memories_fts MATCH ?
+        AND m.deleted_at IS NULL
+        ${clause}
+      ORDER BY fts.rank
+      LIMIT ?
+    `).all(query, ...params, limit);
+    return rows.map((row) => ({
+      memory: this.rowToMemory(row),
+      rank: row.rank
+    }));
+  }
+  async findSimilarMemories(embedding, threshold, limit, projectIds) {
+    const results = await this.searchMemories(embedding, limit * 3, projectIds);
+    return results.filter((r) => r.distance <= threshold).slice(0, limit);
+  }
+  async listMemories(limit, projectIds) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const { clause, params } = this.buildProjectFilter(projectIds, "memories");
+    const rows = this.db.prepare(`
+      SELECT * FROM memories
+      WHERE deleted_at IS NULL
+        AND (expires_at IS NULL OR expires_at > ?)
+        ${clause}
+      ORDER BY updated_at DESC
+      LIMIT ?
+    `).all(now, ...params, limit);
+    return rows.map((row) => this.rowToMemory(row));
+  }
+  async listNodes(limit, projectIds) {
+    const { clause, params } = this.buildProjectFilter(projectIds, "nodes");
+    const rows = this.db.prepare(`
+      SELECT * FROM nodes WHERE 1=1 ${clause} ORDER BY updated_at DESC LIMIT ?
+    `).all(...params, limit);
+    return rows.map((row) => this.rowToNode(row));
+  }
+  async listEdges(limit, includeExpired, projectIds) {
+    const expiredClause = includeExpired ? "" : "AND expired_at IS NULL";
+    const { clause, params } = this.buildProjectFilter(projectIds, "edges");
+    const rows = this.db.prepare(`
+      SELECT * FROM edges WHERE 1=1 ${expiredClause} ${clause} ORDER BY created_at DESC LIMIT ?
+    `).all(...params, limit);
+    return rows.map((row) => this.rowToEdge(row));
+  }
+  async listMemoriesByLayer(layer, limit, projectIds) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const { clause, params } = this.buildProjectFilter(projectIds, "memories");
+    const rows = this.db.prepare(`
+      SELECT * FROM memories
+      WHERE layer = ?
+        AND deleted_at IS NULL
+        AND (expires_at IS NULL OR expires_at > ?)
+        ${clause}
+      ORDER BY updated_at DESC
+      LIMIT ?
+    `).all(layer, now, ...params, limit);
+    return rows.map((row) => this.rowToMemory(row));
+  }
+  // ── Nodes ──
+  async upsertNode(node) {
+    this.db.transaction(() => {
+      this.db.prepare(`
+        INSERT INTO nodes (id, project_id, name, summary, entity_type, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(id) DO UPDATE SET
+          name = excluded.name,
+          summary = excluded.summary,
+          entity_type = excluded.entity_type,
+          updated_at = excluded.updated_at
+      `).run(node.id, node.projectId ?? null, node.name, node.summary ?? null, node.entityType ?? null, node.createdAt, node.updatedAt);
+      if (node.nameEmbedding) {
+        this.db.prepare(`
+          DELETE FROM vec_nodes WHERE node_id = ?
+        `).run(node.id);
+        this.db.prepare(`
+          INSERT INTO vec_nodes (node_id, embedding) VALUES (?, ?)
+        `).run(node.id, toVecBlob(node.nameEmbedding));
+      }
+    })();
+  }
+  async getNode(id) {
+    const row = this.db.prepare("SELECT * FROM nodes WHERE id = ?").get(id);
+    return row ? this.rowToNode(row) : null;
+  }
+  async searchNodes(embedding, limit, projectIds) {
+    const { clause, params } = this.buildProjectFilter(projectIds, "n");
+    const rows = this.db.prepare(`
+      SELECT n.*
+      FROM vec_nodes v
+      INNER JOIN nodes n ON n.id = v.node_id
+      WHERE v.embedding MATCH ?
+        AND k = ?
+        ${clause}
+    `).all(toVecBlob(embedding), limit, ...params);
+    return rows.map((row) => this.rowToNode(row));
+  }
+  // ── Edges ──
+  async upsertEdge(edge) {
+    this.db.transaction(() => {
+      this.db.prepare(`
+        INSERT INTO edges (id, project_id, source_id, target_id, relation, fact, created_at, expired_at, valid_at, invalid_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(id) DO UPDATE SET
+          relation = excluded.relation,
+          fact = excluded.fact,
+          expired_at = excluded.expired_at,
+          valid_at = excluded.valid_at,
+          invalid_at = excluded.invalid_at
+      `).run(
+        edge.id,
+        edge.projectId ?? null,
+        edge.sourceId,
+        edge.targetId,
+        edge.relation,
+        edge.fact ?? null,
+        edge.createdAt,
+        edge.expiredAt ?? null,
+        edge.validAt ?? null,
+        edge.invalidAt ?? null
+      );
+      if (edge.factEmbedding) {
+        this.db.prepare(`
+          DELETE FROM vec_edges WHERE edge_id = ?
+        `).run(edge.id);
+        this.db.prepare(`
+          INSERT INTO vec_edges (edge_id, embedding) VALUES (?, ?)
+        `).run(edge.id, toVecBlob(edge.factEmbedding));
+      }
+    })();
+  }
+  async getEdge(id) {
+    const row = this.db.prepare("SELECT * FROM edges WHERE id = ?").get(id);
+    return row ? this.rowToEdge(row) : null;
+  }
+  async invalidateEdge(id, expiredAt, invalidAt) {
+    this.db.prepare("UPDATE edges SET expired_at = ?, invalid_at = ? WHERE id = ?").run(expiredAt, invalidAt, id);
+  }
+  async searchEdges(embedding, filters, limit, projectIds) {
+    let whereClause = "1=1";
+    const params = [toVecBlob(embedding), limit];
+    if (filters.excludeExpired !== false) {
+      whereClause += " AND e.expired_at IS NULL";
+    }
+    if (filters.asOf) {
+      whereClause += " AND (e.valid_at IS NULL OR e.valid_at <= ?)";
+      params.push(filters.asOf);
+      whereClause += " AND (e.invalid_at IS NULL OR e.invalid_at > ?)";
+      params.push(filters.asOf);
+    }
+    const { clause: projectClause, params: projectParams } = this.buildProjectFilter(projectIds, "e");
+    whereClause += ` ${projectClause}`;
+    params.push(...projectParams);
+    const rows = this.db.prepare(`
+      SELECT e.*
+      FROM vec_edges v
+      INNER JOIN edges e ON e.id = v.edge_id
+      WHERE v.embedding MATCH ?
+        AND k = ?
+        AND ${whereClause}
+    `).all(...params);
+    return rows.map((row) => this.rowToEdge(row));
+  }
+  // ── Graph Traversal ──
+  async getEdgesForNode(nodeId) {
+    const rows = this.db.prepare(`
+      SELECT * FROM edges
+      WHERE (source_id = ? OR target_id = ?) AND expired_at IS NULL
+    `).all(nodeId, nodeId);
+    return rows.map((row) => this.rowToEdge(row));
+  }
+  async getNeighbors(nodeId, depth) {
+    if (depth < 1) return [];
+    const oneHop = this.db.prepare(`
+      SELECT DISTINCT n.* FROM nodes n
+      INNER JOIN edges e ON (e.source_id = ? AND e.target_id = n.id)
+                         OR (e.target_id = ? AND e.source_id = n.id)
+      WHERE e.expired_at IS NULL
+    `).all(nodeId, nodeId);
+    if (depth === 1) {
+      return oneHop.map((row) => this.rowToNode(row));
+    }
+    const visited = /* @__PURE__ */ new Set([nodeId]);
+    const results = [];
+    for (const row of oneHop) {
+      visited.add(row.id);
+      results.push(this.rowToNode(row));
+    }
+    for (const node of [...results]) {
+      const twoHop = this.db.prepare(`
+        SELECT DISTINCT n.* FROM nodes n
+        INNER JOIN edges e ON (e.source_id = ? AND e.target_id = n.id)
+                           OR (e.target_id = ? AND e.source_id = n.id)
+        WHERE e.expired_at IS NULL
+      `).all(node.id, node.id);
+      for (const row of twoHop) {
+        if (!visited.has(row.id)) {
+          visited.add(row.id);
+          results.push(this.rowToNode(row));
+        }
+      }
+    }
+    return results;
+  }
+  // ── Episodes ──
+  async addEpisode(episode) {
+    this.db.prepare(`
+      INSERT INTO episodes (id, project_id, content, content_type, source, created_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(episode.id, episode.projectId ?? null, episode.content, episode.contentType ?? null, episode.source ?? null, episode.createdAt);
+  }
+  async addEpisodeRef(ref) {
+    this.db.prepare(`
+      INSERT OR IGNORE INTO episode_refs (episode_id, ref_type, ref_id)
+      VALUES (?, ?, ?)
+    `).run(ref.episodeId, ref.refType, ref.refId);
+  }
+  async getEpisode(id) {
+    const row = this.db.prepare("SELECT * FROM episodes WHERE id = ?").get(id);
+    return row ? this.rowToEpisode(row) : null;
+  }
+  async listEpisodes(limit, projectIds) {
+    const { clause, params } = this.buildProjectFilter(projectIds, "episodes");
+    const rows = this.db.prepare(`SELECT * FROM episodes WHERE 1=1 ${clause} ORDER BY created_at DESC LIMIT ?`).all(...params, limit);
+    return rows.map((row) => this.rowToEpisode(row));
+  }
+  async getEpisodeRefs(episodeId) {
+    const rows = this.db.prepare("SELECT * FROM episode_refs WHERE episode_id = ?").all(episodeId);
+    return rows.map((row) => ({
+      episodeId: row.episode_id,
+      refType: row.ref_type,
+      refId: row.ref_id
+    }));
+  }
+  // ── Sessions ──
+  async addSession(session) {
+    this.db.prepare(`
+      INSERT INTO sessions (id, project_id, status, started_at, ended_at, checkpoint_count, working_memory_snapshot, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      session.id,
+      session.projectId ?? null,
+      session.status,
+      session.startedAt,
+      session.endedAt ?? null,
+      session.checkpointCount,
+      session.workingMemorySnapshot ?? null,
+      session.metadata ?? null
+    );
+  }
+  async updateSession(id, updates) {
+    const sets = [];
+    const values = [];
+    if (updates.status !== void 0) {
+      sets.push("status = ?");
+      values.push(updates.status);
+    }
+    if (updates.endedAt !== void 0) {
+      sets.push("ended_at = ?");
+      values.push(updates.endedAt);
+    }
+    if (updates.checkpointCount !== void 0) {
+      sets.push("checkpoint_count = ?");
+      values.push(updates.checkpointCount);
+    }
+    if (updates.workingMemorySnapshot !== void 0) {
+      sets.push("working_memory_snapshot = ?");
+      values.push(updates.workingMemorySnapshot);
+    }
+    if (updates.metadata !== void 0) {
+      sets.push("metadata = ?");
+      values.push(updates.metadata);
+    }
+    if (sets.length === 0) return;
+    values.push(id);
+    this.db.prepare(`UPDATE sessions SET ${sets.join(", ")} WHERE id = ?`).run(...values);
+  }
+  async getSession(id) {
+    const row = this.db.prepare("SELECT * FROM sessions WHERE id = ?").get(id);
+    return row ? this.rowToSession(row) : null;
+  }
+  async listSessions(limit, projectIds) {
+    const { clause, params } = this.buildProjectFilter(projectIds, "sessions");
+    const rows = this.db.prepare(`SELECT * FROM sessions WHERE 1=1 ${clause} ORDER BY started_at DESC LIMIT ?`).all(...params, limit);
+    return rows.map((row) => this.rowToSession(row));
+  }
+  // ── Config ──
+  async getConfig(key) {
+    const row = this.db.prepare("SELECT value FROM config WHERE key = ?").get(key);
+    return row?.value ?? null;
+  }
+  async setConfig(key, value) {
+    this.db.prepare("INSERT INTO config (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(key, value);
+  }
+  // ── Row Converters ──
+  rowToMemory(row) {
+    return {
+      id: row.id,
+      projectId: row.project_id ?? void 0,
+      content: row.content,
+      layer: row.layer,
+      type: row.type,
+      priority: row.priority,
+      importance: row.importance,
+      tags: row.tags ? JSON.parse(row.tags) : void 0,
+      expiresAt: row.expires_at ?? void 0,
+      lastAccessedAt: row.last_accessed_at,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      deletedAt: row.deleted_at ?? void 0
+    };
+  }
+  rowToNode(row) {
+    return {
+      id: row.id,
+      projectId: row.project_id ?? void 0,
+      name: row.name,
+      summary: row.summary ?? void 0,
+      entityType: row.entity_type ?? void 0,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  rowToEdge(row) {
+    return {
+      id: row.id,
+      projectId: row.project_id ?? void 0,
+      sourceId: row.source_id,
+      targetId: row.target_id,
+      relation: row.relation,
+      fact: row.fact ?? void 0,
+      createdAt: row.created_at,
+      expiredAt: row.expired_at ?? void 0,
+      validAt: row.valid_at ?? void 0,
+      invalidAt: row.invalid_at ?? void 0
+    };
+  }
+  rowToEpisode(row) {
+    return {
+      id: row.id,
+      projectId: row.project_id ?? void 0,
+      content: row.content,
+      contentType: row.content_type ?? void 0,
+      source: row.source ?? void 0,
+      createdAt: row.created_at
+    };
+  }
+  rowToSession(row) {
+    return {
+      id: row.id,
+      projectId: row.project_id ?? void 0,
+      status: row.status,
+      startedAt: row.started_at,
+      endedAt: row.ended_at ?? void 0,
+      checkpointCount: row.checkpoint_count,
+      workingMemorySnapshot: row.working_memory_snapshot ?? void 0,
+      metadata: row.metadata ?? void 0
+    };
+  }
+};
+
+// ../core/src/embedding/local-embedding.ts
+var LocalEmbedding = class {
+  constructor(cacheDir) {
+    this.cacheDir = cacheDir;
+  }
+  dimensions = 384;
+  pipe = null;
+  initPromise = null;
+  async getPipeline() {
+    if (this.pipe) return this.pipe;
+    if (!this.initPromise) {
+      this.initPromise = (async () => {
+        const { pipeline, env } = await import("@xenova/transformers");
+        if (this.cacheDir) {
+          env.cacheDir = this.cacheDir;
+        }
+        const pipe = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2");
+        return pipe;
+      })();
+    }
+    this.pipe = await this.initPromise;
+    return this.pipe;
+  }
+  async embed(text) {
+    const pipe = await this.getPipeline();
+    const result = await pipe(text, { pooling: "mean", normalize: true });
+    return Array.from(result.data).slice(0, this.dimensions);
+  }
+  async embedBatch(texts) {
+    return Promise.all(texts.map((t) => this.embed(t)));
+  }
+};
+
+// ../core/src/engine/memory-engine.ts
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+
+// ../../node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/index.js
+import { webcrypto as crypto } from "crypto";
+
+// ../../node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// ../../node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/index.js
+var POOL_SIZE_MULTIPLIER = 128;
+var pool;
+var poolOffset;
+function fillPool(bytes) {
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+    crypto.getRandomValues(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    crypto.getRandomValues(pool);
+    poolOffset = 0;
+  }
+  poolOffset += bytes;
+}
+function nanoid(size = 21) {
+  fillPool(size |= 0);
+  let id = "";
+  for (let i = poolOffset - size; i < poolOffset; i++) {
+    id += urlAlphabet[pool[i] & 63];
+  }
+  return id;
+}
+
+// ../core/src/utils/id.ts
+function generateId() {
+  return nanoid();
+}
+
+// ../core/src/engine/scoring.ts
+function decay(importance, lastAccessedAt, rate = 0.01) {
+  const ageHours = (Date.now() - new Date(lastAccessedAt).getTime()) / 36e5;
+  return importance * Math.exp(-rate * ageHours);
+}
+function recencyScore(timestamp, halfLifeHours = 24) {
+  const ageHours = (Date.now() - new Date(timestamp).getTime()) / 36e5;
+  return Math.exp(-Math.LN2 / halfLifeHours * ageHours);
+}
+function hybridScore(semantic, bm25, recency, salience, weights) {
+  return semantic * weights.semantic + bm25 * weights.bm25 + recency * weights.recency + salience * weights.salience;
+}
+function normalizeBm25(rank) {
+  return 1 / (1 + Math.abs(rank));
+}
+function distanceToSimilarity(distance) {
+  return 1 / (1 + distance);
+}
+
+// ../core/src/engine/context.ts
+async function getContext(storage, options = {}) {
+  const { maxMemories = 50, projectIds } = options;
+  const rules = await storage.listMemoriesByLayer("rule", maxMemories, projectIds);
+  const remaining1 = maxMemories - rules.length;
+  const working = remaining1 > 0 ? await storage.listMemoriesByLayer("working", Math.ceil(remaining1 * 0.6), projectIds) : [];
+  const remaining2 = maxMemories - rules.length - working.length;
+  const longTerm = remaining2 > 0 ? await storage.listMemoriesByLayer("long_term", remaining2, projectIds) : [];
+  const memories = [...rules, ...working, ...longTerm];
+  const totalCount = memories.length;
+  return {
+    memories,
+    totalCount,
+    truncated: totalCount >= maxMemories
+  };
+}
+
+// ../core/src/engine/memory-engine.ts
+var MemoryEngine = class {
+  storage;
+  embedding;
+  weights;
+  decayRate;
+  defaultProjectId;
+  constructor(config) {
+    mkdirSync(dirname(config.dbPath), { recursive: true });
+    this.storage = new SqliteDriver(config.dbPath);
+    this.embedding = new LocalEmbedding(config.embeddingCacheDir);
+    this.weights = { ...DEFAULT_WEIGHTS, ...config.weights };
+    this.decayRate = config.decayRate ?? DEFAULT_DECAY_RATE;
+    this.defaultProjectId = config.defaultProjectId;
+  }
+  async initialize() {
+    await this.storage.initialize();
+  }
+  close() {
+    this.storage.close();
+  }
+  // ── Scope Helpers ──
+  resolveProjectId(scope) {
+    if (scope === "global") return void 0;
+    return this.defaultProjectId;
+  }
+  resolveProjectFilter(scope) {
+    if (scope === "all") return void 0;
+    if (scope === "global") return [null];
+    if (this.defaultProjectId) return [this.defaultProjectId, null];
+    return void 0;
+  }
+  // ── Memory ──
+  async addMemory(input) {
+    const now = nowISO();
+    const layer = input.layer ?? "long_term";
+    const memory = {
+      id: generateId(),
+      projectId: this.resolveProjectId(input.scope),
+      content: input.content,
+      layer,
+      type: input.type ?? "note",
+      priority: MEMORY_LAYER_PRIORITY[layer] ?? 1,
+      importance: input.importance ?? 0.5,
+      tags: input.tags,
+      embedding: await this.embedding.embed(input.content),
+      expiresAt: input.expiresAt,
+      lastAccessedAt: now,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.storage.addMemory(memory);
+    return memory;
+  }
+  async searchMemories(query) {
+    const limit = query.limit ?? 10;
+    const weights = { ...this.weights, ...query.weights };
+    const projectIds = this.resolveProjectFilter(query.scope);
+    const queryEmbedding = query.embedding ?? await this.embedding.embed(query.text);
+    const semanticResults = await this.storage.searchMemories(queryEmbedding, limit * 2, projectIds);
+    let bm25Results = [];
+    try {
+      bm25Results = await this.storage.fullTextSearch(query.text, limit * 2, projectIds);
+    } catch {
+    }
+    const candidateMap = /* @__PURE__ */ new Map();
+    for (const { memory } of semanticResults) candidateMap.set(memory.id, memory);
+    for (const { memory } of bm25Results) candidateMap.set(memory.id, memory);
+    const semanticScoreMap = /* @__PURE__ */ new Map();
+    for (const { memory, distance } of semanticResults) {
+      semanticScoreMap.set(memory.id, distanceToSimilarity(distance));
+    }
+    const bm25ScoreMap = /* @__PURE__ */ new Map();
+    for (const { memory, rank } of bm25Results) {
+      bm25ScoreMap.set(memory.id, normalizeBm25(rank));
+    }
+    const layerFilter = query.layers ? new Set(query.layers) : null;
+    const results = [];
+    for (const [id, memory] of candidateMap) {
+      if (layerFilter && !layerFilter.has(memory.layer)) continue;
+      if (memory.expiresAt && new Date(memory.expiresAt) < /* @__PURE__ */ new Date()) continue;
+      const semantic = semanticScoreMap.get(id) ?? 0;
+      const bm25 = bm25ScoreMap.get(id) ?? 0;
+      const rec = recencyScore(memory.lastAccessedAt);
+      const sal = decay(memory.importance, memory.lastAccessedAt, this.decayRate);
+      const score = hybridScore(semantic, bm25, rec, sal, weights);
+      results.push({
+        id: memory.id,
+        type: "memory",
+        content: memory.content,
+        score,
+        scoreBreakdown: { semantic, bm25, recency: rec, salience: sal }
+      });
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, limit);
+  }
+  async updateMemory(id, input) {
+    await this.storage.updateMemory(id, input);
+    if (input.content !== void 0) {
+      const newEmbedding = await this.embedding.embed(input.content);
+      await this.storage.updateMemoryEmbedding(id, newEmbedding);
+    }
+  }
+  async deleteMemory(id) {
+    await this.storage.deleteMemory(id);
+  }
+  async getMemory(id) {
+    return this.storage.getMemory(id);
+  }
+  async listMemories(options) {
+    const limit = options?.limit ?? 100;
+    const projectIds = this.resolveProjectFilter(options?.scope);
+    if (options?.layer) {
+      return this.storage.listMemoriesByLayer(options.layer, limit, projectIds);
+    }
+    return this.storage.listMemories(limit, projectIds);
+  }
+  async listEntities(options) {
+    const limit = options?.limit ?? 100;
+    const projectIds = this.resolveProjectFilter(options?.scope);
+    return this.storage.listNodes(limit, projectIds);
+  }
+  async listEdges(options) {
+    const limit = options?.limit ?? 100;
+    const projectIds = this.resolveProjectFilter(options?.scope);
+    return this.storage.listEdges(limit, options?.includeExpired ?? false, projectIds);
+  }
+  // ── Deduplication & Consolidation ──
+  async findDuplicates(memoryId, threshold = 0.3) {
+    const target = await this.storage.getMemory(memoryId);
+    if (!target) throw new Error(`Memory not found: ${memoryId}`);
+    const embedding = target.embedding ?? await this.embedding.embed(target.content);
+    const projectIds = this.resolveProjectFilter("project");
+    const similar = await this.storage.findSimilarMemories(embedding, threshold, 20, projectIds);
+    return similar.filter((r) => r.memory.id !== memoryId);
+  }
+  async consolidateMemories(sourceIds, mergedContent, layer) {
+    const merged = await this.addMemory({
+      content: mergedContent,
+      layer: layer ?? "long_term",
+      type: "note"
+    });
+    for (const id of sourceIds) {
+      await this.storage.deleteMemory(id);
+    }
+    return merged;
+  }
+  // ── Graph ──
+  async addEntity(input) {
+    const now = nowISO();
+    const node = {
+      id: generateId(),
+      projectId: this.resolveProjectId(input.scope),
+      name: input.name,
+      nameEmbedding: await this.embedding.embed(input.name),
+      summary: input.summary,
+      entityType: input.entityType,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.storage.upsertNode(node);
+    return node;
+  }
+  async addEdge(input) {
+    const now = nowISO();
+    const edge = {
+      id: generateId(),
+      projectId: this.resolveProjectId(input.scope),
+      sourceId: input.sourceId,
+      targetId: input.targetId,
+      relation: input.relation,
+      fact: input.fact,
+      factEmbedding: input.fact ? await this.embedding.embed(input.fact) : void 0,
+      createdAt: now,
+      validAt: input.validAt
+    };
+    await this.storage.upsertEdge(edge);
+    return edge;
+  }
+  async getEdge(id) {
+    return this.storage.getEdge(id);
+  }
+  async invalidateEdge(edgeId) {
+    const now = nowISO();
+    await this.storage.invalidateEdge(edgeId, now, now);
+  }
+  async updateEdge(edgeId, input) {
+    const old = await this.storage.getEdge(edgeId);
+    if (!old) return null;
+    const now = nowISO();
+    await this.storage.invalidateEdge(edgeId, now, now);
+    return this.addEdge({
+      sourceId: old.sourceId,
+      targetId: old.targetId,
+      relation: input.relation ?? old.relation,
+      fact: input.fact ?? old.fact,
+      validAt: now
+    });
+  }
+  async searchGraph(query, limit = 10, options) {
+    const depth = options?.traverseDepth ?? 1;
+    const projectIds = this.resolveProjectFilter(options?.scope);
+    const queryEmbedding = await this.embedding.embed(query);
+    const nodes = await this.storage.searchNodes(queryEmbedding, Math.ceil(limit / 2), projectIds);
+    const edges = await this.storage.searchEdges(queryEmbedding, { excludeExpired: true }, Math.ceil(limit / 2), projectIds);
+    const results = [];
+    const seenNodeIds = /* @__PURE__ */ new Set();
+    for (const node of nodes) {
+      seenNodeIds.add(node.id);
+      results.push({
+        id: node.id,
+        type: "node",
+        content: `${node.name}${node.summary ? ": " + node.summary : ""}`,
+        score: 1
+      });
+    }
+    if (depth > 0) {
+      for (const node of nodes) {
+        const neighbors = await this.storage.getNeighbors(node.id, depth);
+        for (const neighbor of neighbors) {
+          if (!seenNodeIds.has(neighbor.id)) {
+            seenNodeIds.add(neighbor.id);
+            results.push({
+              id: neighbor.id,
+              type: "node",
+              content: `${neighbor.name}${neighbor.summary ? ": " + neighbor.summary : ""}`,
+              score: 0.5
+            });
+          }
+        }
+      }
+    }
+    for (const edge of edges) {
+      results.push({
+        id: edge.id,
+        type: "edge",
+        content: `${edge.relation}: ${edge.fact ?? ""}`,
+        score: 0.8
+      });
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, limit);
+  }
+  // ── Episodes ──
+  async addEpisode(input, refs) {
+    const episode = {
+      id: generateId(),
+      projectId: this.resolveProjectId(input.scope),
+      content: input.content,
+      contentType: input.contentType,
+      source: input.source,
+      createdAt: nowISO()
+    };
+    await this.storage.addEpisode(episode);
+    if (refs) {
+      for (const ref of refs) {
+        await this.storage.addEpisodeRef({ ...ref, episodeId: episode.id });
+      }
+    }
+    return episode;
+  }
+  async getEpisode(id) {
+    return this.storage.getEpisode(id);
+  }
+  async listEpisodes(limit = 20, scope) {
+    const projectIds = this.resolveProjectFilter(scope);
+    return this.storage.listEpisodes(limit, projectIds);
+  }
+  // ── Sessions ──
+  async sessionStart(metadata) {
+    const session = {
+      id: generateId(),
+      projectId: this.resolveProjectId("project"),
+      status: "active",
+      startedAt: nowISO(),
+      checkpointCount: 0,
+      metadata
+    };
+    await this.storage.addSession(session);
+    return session;
+  }
+  async sessionEnd(id) {
+    await this.storage.updateSession(id, {
+      status: "ended",
+      endedAt: nowISO()
+    });
+  }
+  async sessionCheckpoint(id) {
+    const session = await this.storage.getSession(id);
+    if (!session) throw new Error(`Session not found: ${id}`);
+    await this.storage.updateSession(id, {
+      checkpointCount: session.checkpointCount + 1
+    });
+  }
+  async sessionList(limit = 20, scope) {
+    const projectIds = this.resolveProjectFilter(scope);
+    return this.storage.listSessions(limit, projectIds);
+  }
+  // ── Context ──
+  async getContext(options) {
+    const projectIds = this.resolveProjectFilter(options?.scope);
+    return getContext(this.storage, { ...options, projectIds });
+  }
+};
+
+// src/shared/engine.ts
+var DEFAULT_DB_PATH2 = join(homedir(), ".config", "cohaku", "memory.db");
+function getDbPath() {
+  return process.env["COHAKU_DB_PATH"] ?? DEFAULT_DB_PATH2;
+}
+function detectProjectId() {
+  const envProjectId = process.env["COHAKU_PROJECT_ID"];
+  if (envProjectId) return envProjectId;
+  try {
+    const gitRoot = execSync("git rev-parse --show-toplevel", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return gitRoot || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function createEngine() {
+  const dbPath = getDbPath();
+  const projectId = detectProjectId();
+  const engine = new MemoryEngine({ dbPath, defaultProjectId: projectId });
+  await engine.initialize();
+  return { engine, dbPath, projectId };
+}
+
+export {
+  getDbPath,
+  detectProjectId,
+  createEngine
+};