claude-memory-layer 1.0.5 → 1.0.7

package/dist/server/api/index.js

@@ -0,0 +1,4363 @@
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+const require = createRequire(import.meta.url);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// src/server/api/index.ts
+import { Hono as Hono6 } from "hono";
+
+// src/server/api/sessions.ts
+import { Hono } from "hono";
+
+// src/services/memory-service.ts
+import * as path from "path";
+import * as os from "os";
+import * as fs from "fs";
+import * as crypto2 from "crypto";
+
+// src/core/event-store.ts
+import { randomUUID } from "crypto";
+
+// src/core/canonical-key.ts
+import { createHash } from "crypto";
+var MAX_KEY_LENGTH = 200;
+function makeCanonicalKey(title, context) {
+  let normalized = title.normalize("NFKC");
+  normalized = normalized.toLowerCase();
+  normalized = normalized.replace(/[^\p{L}\p{N}\s]/gu, "");
+  normalized = normalized.replace(/\s+/g, " ").trim();
+  let key = normalized;
+  if (context?.project) {
+    key = `${context.project}::${key}`;
+  }
+  if (key.length > MAX_KEY_LENGTH) {
+    const hashSuffix = createHash("md5").update(key).digest("hex").slice(0, 8);
+    key = key.slice(0, MAX_KEY_LENGTH - 9) + "_" + hashSuffix;
+  }
+  return key;
+}
+function makeDedupeKey(content, sessionId) {
+  const contentHash = createHash("sha256").update(content).digest("hex");
+  return `${sessionId}:${contentHash}`;
+}
+
+// src/core/db-wrapper.ts
+import duckdb from "duckdb";
+function convertBigInts(obj) {
+  if (obj === null || obj === void 0)
+    return obj;
+  if (typeof obj === "bigint")
+    return Number(obj);
+  if (obj instanceof Date)
+    return obj;
+  if (Array.isArray(obj))
+    return obj.map(convertBigInts);
+  if (typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = convertBigInts(value);
+    }
+    return result;
+  }
+  return obj;
+}
+function toDate(value) {
+  if (value instanceof Date)
+    return value;
+  if (typeof value === "string")
+    return new Date(value);
+  if (typeof value === "number")
+    return new Date(value);
+  return new Date(String(value));
+}
+function createDatabase(path2) {
+  return new duckdb.Database(path2);
+}
+function dbRun(db, sql, params = []) {
+  return new Promise((resolve2, reject) => {
+    if (params.length === 0) {
+      db.run(sql, (err) => {
+        if (err)
+          reject(err);
+        else
+          resolve2();
+      });
+    } else {
+      db.run(sql, ...params, (err) => {
+        if (err)
+          reject(err);
+        else
+          resolve2();
+      });
+    }
+  });
+}
+function dbAll(db, sql, params = []) {
+  return new Promise((resolve2, reject) => {
+    if (params.length === 0) {
+      db.all(sql, (err, rows) => {
+        if (err)
+          reject(err);
+        else
+          resolve2(convertBigInts(rows || []));
+      });
+    } else {
+      db.all(sql, ...params, (err, rows) => {
+        if (err)
+          reject(err);
+        else
+          resolve2(convertBigInts(rows || []));
+      });
+    }
+  });
+}
+function dbClose(db) {
+  return new Promise((resolve2, reject) => {
+    db.close((err) => {
+      if (err)
+        reject(err);
+      else
+        resolve2();
+    });
+  });
+}
+
+// src/core/event-store.ts
+var EventStore = class {
+  constructor(dbPath) {
+    this.dbPath = dbPath;
+    this.db = createDatabase(dbPath);
+  }
+  db;
+  initialized = false;
+  /**
+   * Initialize database schema
+   */
+  async initialize() {
+    if (this.initialized)
+      return;
+    await dbRun(this.db, `
+      CREATE TABLE IF NOT EXISTS events (
+        id VARCHAR PRIMARY KEY,
+        event_type VARCHAR NOT NULL,
+        session_id VARCHAR NOT NULL,
+        timestamp TIMESTAMP NOT NULL,
+        content TEXT NOT NULL,
+        canonical_key VARCHAR NOT NULL,
+        dedupe_key VARCHAR UNIQUE,
+        metadata JSON
+      )
+    `);
+    await dbRun(this.db, `
+      CREATE TABLE IF NOT EXISTS event_dedup (
+        dedupe_key VARCHAR PRIMARY KEY,
+        event_id VARCHAR NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await dbRun(this.db, `
+      CREATE TABLE IF NOT EXISTS sessions (
+        id VARCHAR PRIMARY KEY,
+        started_at TIMESTAMP NOT NULL,
+        ended_at TIMESTAMP,
+        project_path VARCHAR,
+        summary TEXT,
+        tags JSON
+      )
+    `);
+    await dbRun(this.db, `
+      CREATE TABLE IF NOT EXISTS insights (
+        id VARCHAR PRIMARY KEY,
+        insight_type VARCHAR NOT NULL,
+        content TEXT NOT NULL,
+        canonical_key VARCHAR NOT NULL,
+        confidence FLOAT,
+        source_events JSON,
+        created_at TIMESTAMP,
+        last_updated TIMESTAMP
+      )
+    `);
+    await dbRun(this.db, `
+      CREATE TABLE IF NOT EXISTS embedding_outbox (
+        id VARCHAR PRIMARY KEY,
+        event_id VARCHAR NOT NULL,
+        content TEXT NOT NULL,
+        status VARCHAR DEFAULT 'pending',
+        retry_count INT DEFAULT 0,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        processed_at TIMESTAMP,
+        error_message TEXT
+      )
+    `);
+    await dbRun(this.db, `
+      CREATE TABLE IF NOT EXISTS projection_offsets (
+        projection_name VARCHAR PRIMARY KEY,
+        last_event_id VARCHAR,
+        last_timestamp TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await dbRun(this.db, `
+      CREATE TABLE IF NOT EXISTS memory_levels (
+        event_id VARCHAR PRIMARY KEY,
+        level VARCHAR NOT NULL DEFAULT 'L0',
+        promoted_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await dbRun(this.db, `
+      CREATE TABLE IF NOT EXISTS entries (
+        entry_id VARCHAR PRIMARY KEY,
+        created_ts TIMESTAMP NOT NULL,
+        entry_type VARCHAR NOT NULL,
+        title VARCHAR NOT NULL,
+        content_json JSON NOT NULL,
+        stage VARCHAR NOT NULL DEFAULT 'raw',
+        status VARCHAR DEFAULT 'active',
+        superseded_by VARCHAR,
+        build_id VARCHAR,
+        evidence_json JSON,
+        canonical_key VARCHAR,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await dbRun(this.db, `
+      CREATE TABLE IF NOT EXISTS entities (
+        entity_id VARCHAR PRIMARY KEY,
+        entity_type VARCHAR NOT NULL,
+        canonical_key VARCHAR NOT NULL,
+        title VARCHAR NOT NULL,
+        stage VARCHAR NOT NULL DEFAULT 'raw',
+        status VARCHAR NOT NULL DEFAULT 'active',
+        current_json JSON NOT NULL,
+        title_norm VARCHAR,
+        search_text VARCHAR,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await dbRun(this.db, `
+      CREATE TABLE IF NOT EXISTS entity_aliases (
+        entity_type VARCHAR NOT NULL,
+        canonical_key VARCHAR NOT NULL,
+        entity_id VARCHAR NOT NULL,
+        is_primary BOOLEAN DEFAULT FALSE,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY(entity_type, canonical_key)
+      )
+    `);
+    await dbRun(this.db, `
+      CREATE TABLE IF NOT EXISTS edges (
+        edge_id VARCHAR PRIMARY KEY,
+        src_type VARCHAR NOT NULL,
+        src_id VARCHAR NOT NULL,
+        rel_type VARCHAR NOT NULL,
+        dst_type VARCHAR NOT NULL,
+        dst_id VARCHAR NOT NULL,
+        meta_json JSON,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await dbRun(this.db, `
+      CREATE TABLE IF NOT EXISTS vector_outbox (
+        job_id VARCHAR PRIMARY KEY,
+        item_kind VARCHAR NOT NULL,
+        item_id VARCHAR NOT NULL,
+        embedding_version VARCHAR NOT NULL,
+        status VARCHAR NOT NULL DEFAULT 'pending',
+        retry_count INT DEFAULT 0,
+        error VARCHAR,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        UNIQUE(item_kind, item_id, embedding_version)
+      )
+    `);
+    await dbRun(this.db, `
+      CREATE TABLE IF NOT EXISTS build_runs (
+        build_id VARCHAR PRIMARY KEY,
+        started_at TIMESTAMP NOT NULL,
+        finished_at TIMESTAMP,
+        extractor_model VARCHAR NOT NULL,
+        extractor_prompt_hash VARCHAR NOT NULL,
+        embedder_model VARCHAR NOT NULL,
+        embedding_version VARCHAR NOT NULL,
+        idris_version VARCHAR NOT NULL,
+        schema_version VARCHAR NOT NULL,
+        status VARCHAR NOT NULL DEFAULT 'running',
+        error VARCHAR
+      )
+    `);
+    await dbRun(this.db, `
+      CREATE TABLE IF NOT EXISTS pipeline_metrics (
+        id VARCHAR PRIMARY KEY,
+        ts TIMESTAMP NOT NULL,
+        stage VARCHAR NOT NULL,
+        latency_ms DOUBLE NOT NULL,
+        success BOOLEAN NOT NULL,
+        error VARCHAR,
+        session_id VARCHAR
+      )
+    `);
+    await dbRun(this.db, `
+      CREATE TABLE IF NOT EXISTS working_set (
+        id VARCHAR PRIMARY KEY,
+        event_id VARCHAR NOT NULL,
+        added_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        relevance_score FLOAT DEFAULT 1.0,
+        topics JSON,
+        expires_at TIMESTAMP
+      )
+    `);
+    await dbRun(this.db, `
+      CREATE TABLE IF NOT EXISTS consolidated_memories (
+        memory_id VARCHAR PRIMARY KEY,
+        summary TEXT NOT NULL,
+        topics JSON,
+        source_events JSON,
+        confidence FLOAT DEFAULT 0.5,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        accessed_at TIMESTAMP,
+        access_count INTEGER DEFAULT 0
+      )
+    `);
+    await dbRun(this.db, `
+      CREATE TABLE IF NOT EXISTS continuity_log (
+        log_id VARCHAR PRIMARY KEY,
+        from_context_id VARCHAR,
+        to_context_id VARCHAR,
+        continuity_score FLOAT,
+        transition_type VARCHAR,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await dbRun(this.db, `
+      CREATE TABLE IF NOT EXISTS endless_config (
+        key VARCHAR PRIMARY KEY,
+        value JSON,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_entries_type ON entries(entry_type)`);
+    await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_entries_stage ON entries(stage)`);
+    await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_entries_canonical ON entries(canonical_key)`);
+    await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_entities_type_key ON entities(entity_type, canonical_key)`);
+    await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_entities_status ON entities(status)`);
+    await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_edges_src ON edges(src_id, rel_type)`);
+    await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_edges_dst ON edges(dst_id, rel_type)`);
+    await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_edges_rel ON edges(rel_type)`);
+    await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_outbox_status ON vector_outbox(status)`);
+    await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_working_set_expires ON working_set(expires_at)`);
+    await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_working_set_relevance ON working_set(relevance_score DESC)`);
+    await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_consolidated_confidence ON consolidated_memories(confidence DESC)`);
+    await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_continuity_created ON continuity_log(created_at)`);
+    this.initialized = true;
+  }
+  /**
+   * Append event to store (AXIOMMIND Principle 2: Append-only)
+   * Returns existing event ID if duplicate (Principle 3: Idempotency)
+   */
+  async append(input) {
+    await this.initialize();
+    const canonicalKey = makeCanonicalKey(input.content);
+    const dedupeKey = makeDedupeKey(input.content, input.sessionId);
+    const existing = await dbAll(
+      this.db,
+      `SELECT event_id FROM event_dedup WHERE dedupe_key = ?`,
+      [dedupeKey]
+    );
+    if (existing.length > 0) {
+      return {
+        success: true,
+        eventId: existing[0].event_id,
+        isDuplicate: true
+      };
+    }
+    const id = randomUUID();
+    const timestamp = input.timestamp.toISOString();
+    try {
+      await dbRun(
+        this.db,
+        `INSERT INTO events (id, event_type, session_id, timestamp, content, canonical_key, dedupe_key, metadata)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+        [
+          id,
+          input.eventType,
+          input.sessionId,
+          timestamp,
+          input.content,
+          canonicalKey,
+          dedupeKey,
+          JSON.stringify(input.metadata || {})
+        ]
+      );
+      await dbRun(
+        this.db,
+        `INSERT INTO event_dedup (dedupe_key, event_id) VALUES (?, ?)`,
+        [dedupeKey, id]
+      );
+      await dbRun(
+        this.db,
+        `INSERT INTO memory_levels (event_id, level) VALUES (?, 'L0')`,
+        [id]
+      );
+      return { success: true, eventId: id, isDuplicate: false };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Get events by session ID
+   */
+  async getSessionEvents(sessionId) {
+    await this.initialize();
+    const rows = await dbAll(
+      this.db,
+      `SELECT * FROM events WHERE session_id = ? ORDER BY timestamp ASC`,
+      [sessionId]
+    );
+    return rows.map(this.rowToEvent);
+  }
+  /**
+   * Get recent events
+   */
+  async getRecentEvents(limit = 100) {
+    await this.initialize();
+    const rows = await dbAll(
+      this.db,
+      `SELECT * FROM events ORDER BY timestamp DESC LIMIT ?`,
+      [limit]
+    );
+    return rows.map(this.rowToEvent);
+  }
+  /**
+   * Get event by ID
+   */
+  async getEvent(id) {
+    await this.initialize();
+    const rows = await dbAll(
+      this.db,
+      `SELECT * FROM events WHERE id = ?`,
+      [id]
+    );
+    if (rows.length === 0)
+      return null;
+    return this.rowToEvent(rows[0]);
+  }
+  /**
+   * Create or update session
+   */
+  async upsertSession(session) {
+    await this.initialize();
+    const existing = await dbAll(
+      this.db,
+      `SELECT id FROM sessions WHERE id = ?`,
+      [session.id]
+    );
+    if (existing.length === 0) {
+      await dbRun(
+        this.db,
+        `INSERT INTO sessions (id, started_at, project_path, tags)
+         VALUES (?, ?, ?, ?)`,
+        [
+          session.id,
+          (session.startedAt || /* @__PURE__ */ new Date()).toISOString(),
+          session.projectPath || null,
+          JSON.stringify(session.tags || [])
+        ]
+      );
+    } else {
+      const updates = [];
+      const values = [];
+      if (session.endedAt) {
+        updates.push("ended_at = ?");
+        values.push(session.endedAt.toISOString());
+      }
+      if (session.summary) {
+        updates.push("summary = ?");
+        values.push(session.summary);
+      }
+      if (session.tags) {
+        updates.push("tags = ?");
+        values.push(JSON.stringify(session.tags));
+      }
+      if (updates.length > 0) {
+        values.push(session.id);
+        await dbRun(
+          this.db,
+          `UPDATE sessions SET ${updates.join(", ")} WHERE id = ?`,
+          values
+        );
+      }
+    }
+  }
+  /**
+   * Get session by ID
+   */
+  async getSession(id) {
+    await this.initialize();
+    const rows = await dbAll(
+      this.db,
+      `SELECT * FROM sessions WHERE id = ?`,
+      [id]
+    );
+    if (rows.length === 0)
+      return null;
+    const row = rows[0];
+    return {
+      id: row.id,
+      startedAt: toDate(row.started_at),
+      endedAt: row.ended_at ? toDate(row.ended_at) : void 0,
+      projectPath: row.project_path,
+      summary: row.summary,
+      tags: row.tags ? JSON.parse(row.tags) : void 0
+    };
+  }
+  /**
+   * Add to embedding outbox (Single-Writer Pattern)
+   */
+  async enqueueForEmbedding(eventId, content) {
+    await this.initialize();
+    const id = randomUUID();
+    await dbRun(
+      this.db,
+      `INSERT INTO embedding_outbox (id, event_id, content, status, retry_count)
+       VALUES (?, ?, ?, 'pending', 0)`,
+      [id, eventId, content]
+    );
+    return id;
+  }
+  /**
+   * Get pending outbox items
+   */
+  async getPendingOutboxItems(limit = 32) {
+    await this.initialize();
+    const pending = await dbAll(
+      this.db,
+      `SELECT * FROM embedding_outbox
+       WHERE status = 'pending'
+       ORDER BY created_at
+       LIMIT ?`,
+      [limit]
+    );
+    if (pending.length === 0)
+      return [];
+    const ids = pending.map((r) => r.id);
+    const placeholders = ids.map(() => "?").join(",");
+    await dbRun(
+      this.db,
+      `UPDATE embedding_outbox SET status = 'processing' WHERE id IN (${placeholders})`,
+      ids
+    );
+    return pending.map((row) => ({
+      id: row.id,
+      eventId: row.event_id,
+      content: row.content,
+      status: "processing",
+      retryCount: row.retry_count,
+      createdAt: toDate(row.created_at),
+      errorMessage: row.error_message
+    }));
+  }
+  /**
+   * Mark outbox items as done
+   */
+  async completeOutboxItems(ids) {
+    if (ids.length === 0)
+      return;
+    const placeholders = ids.map(() => "?").join(",");
+    await dbRun(
+      this.db,
+      `DELETE FROM embedding_outbox WHERE id IN (${placeholders})`,
+      ids
+    );
+  }
+  /**
+   * Mark outbox items as failed
+   */
+  async failOutboxItems(ids, error) {
+    if (ids.length === 0)
+      return;
+    const placeholders = ids.map(() => "?").join(",");
+    await dbRun(
+      this.db,
+      `UPDATE embedding_outbox
+       SET status = CASE WHEN retry_count >= 3 THEN 'failed' ELSE 'pending' END,
+           retry_count = retry_count + 1,
+           error_message = ?
+       WHERE id IN (${placeholders})`,
+      [error, ...ids]
+    );
+  }
+  /**
+   * Update memory level
+   */
+  async updateMemoryLevel(eventId, level) {
+    await this.initialize();
+    await dbRun(
+      this.db,
+      `UPDATE memory_levels SET level = ?, promoted_at = CURRENT_TIMESTAMP WHERE event_id = ?`,
+      [level, eventId]
+    );
+  }
+  /**
+   * Get memory level statistics
+   */
+  async getLevelStats() {
+    await this.initialize();
+    const rows = await dbAll(
+      this.db,
+      `SELECT level, COUNT(*) as count FROM memory_levels GROUP BY level`
+    );
+    return rows;
+  }
+  // ============================================================
+  // Endless Mode Helper Methods
+  // ============================================================
+  /**
+   * Get database instance for Endless Mode stores
+   */
+  getDatabase() {
+    return this.db;
+  }
+  /**
+   * Get config value for endless mode
+   */
+  async getEndlessConfig(key) {
+    await this.initialize();
+    const rows = await dbAll(
+      this.db,
+      `SELECT value FROM endless_config WHERE key = ?`,
+      [key]
+    );
+    if (rows.length === 0)
+      return null;
+    return JSON.parse(rows[0].value);
+  }
+  /**
+   * Set config value for endless mode
+   */
+  async setEndlessConfig(key, value) {
+    await this.initialize();
+    await dbRun(
+      this.db,
+      `INSERT OR REPLACE INTO endless_config (key, value, updated_at)
+       VALUES (?, ?, CURRENT_TIMESTAMP)`,
+      [key, JSON.stringify(value)]
+    );
+  }
+  /**
+   * Get all sessions
+   */
+  async getAllSessions() {
+    await this.initialize();
+    const rows = await dbAll(
+      this.db,
+      `SELECT * FROM sessions ORDER BY started_at DESC`
+    );
+    return rows.map((row) => ({
+      id: row.id,
+      startedAt: toDate(row.started_at),
+      endedAt: row.ended_at ? toDate(row.ended_at) : void 0,
+      projectPath: row.project_path,
+      summary: row.summary,
+      tags: row.tags ? JSON.parse(row.tags) : void 0
+    }));
+  }
+  /**
+   * Close database connection
+   */
+  async close() {
+    await dbClose(this.db);
+  }
+  /**
+   * Convert database row to MemoryEvent
+   */
+  rowToEvent(row) {
+    return {
+      id: row.id,
+      eventType: row.event_type,
+      sessionId: row.session_id,
+      timestamp: toDate(row.timestamp),
+      content: row.content,
+      canonicalKey: row.canonical_key,
+      dedupeKey: row.dedupe_key,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0
+    };
+  }
+};
+
+// src/core/vector-store.ts
+import * as lancedb from "@lancedb/lancedb";
+var VectorStore = class {
+  constructor(dbPath) {
+    this.dbPath = dbPath;
+  }
+  db = null;
+  table = null;
+  tableName = "conversations";
+  /**
+   * Initialize LanceDB connection
+   */
+  async initialize() {
+    if (this.db)
+      return;
+    this.db = await lancedb.connect(this.dbPath);
+    try {
+      const tables = await this.db.tableNames();
+      if (tables.includes(this.tableName)) {
+        this.table = await this.db.openTable(this.tableName);
+      }
+    } catch {
+      this.table = null;
+    }
+  }
+  /**
+   * Add or update vector record
+   */
+  async upsert(record) {
+    await this.initialize();
+    if (!this.db) {
+      throw new Error("Database not initialized");
+    }
+    const data = {
+      id: record.id,
+      eventId: record.eventId,
+      sessionId: record.sessionId,
+      eventType: record.eventType,
+      content: record.content,
+      vector: record.vector,
+      timestamp: record.timestamp,
+      metadata: JSON.stringify(record.metadata || {})
+    };
+    if (!this.table) {
+      this.table = await this.db.createTable(this.tableName, [data]);
+    } else {
+      await this.table.add([data]);
+    }
+  }
+  /**
+   * Add multiple vector records in batch
+   */
+  async upsertBatch(records) {
+    if (records.length === 0)
+      return;
+    await this.initialize();
+    if (!this.db) {
+      throw new Error("Database not initialized");
+    }
+    const data = records.map((record) => ({
+      id: record.id,
+      eventId: record.eventId,
+      sessionId: record.sessionId,
+      eventType: record.eventType,
+      content: record.content,
+      vector: record.vector,
+      timestamp: record.timestamp,
+      metadata: JSON.stringify(record.metadata || {})
+    }));
+    if (!this.table) {
+      this.table = await this.db.createTable(this.tableName, data);
+    } else {
+      await this.table.add(data);
+    }
+  }
+  /**
+   * Search for similar vectors
+   */
+  async search(queryVector, options = {}) {
+    await this.initialize();
+    if (!this.table) {
+      return [];
+    }
+    const { limit = 5, minScore = 0.7, sessionId } = options;
+    let query = this.table.search(queryVector).distanceType("cosine").limit(limit * 2);
+    if (sessionId) {
+      query = query.where(`sessionId = '${sessionId}'`);
+    }
+    const results = await query.toArray();
+    return results.filter((r) => {
+      const distance = r._distance || 0;
+      const score = 1 - distance / 2;
+      return score >= minScore;
+    }).slice(0, limit).map((r) => {
+      const distance = r._distance || 0;
+      const score = 1 - distance / 2;
+      return {
+        id: r.id,
+        eventId: r.eventId,
+        content: r.content,
+        score,
+        sessionId: r.sessionId,
+        eventType: r.eventType,
+        timestamp: r.timestamp
+      };
+    });
+  }
+  /**
+   * Delete vector by event ID
+   */
+  async delete(eventId) {
+    if (!this.table)
+      return;
+    await this.table.delete(`eventId = '${eventId}'`);
+  }
+  /**
+   * Get total count of vectors
+   */
+  async count() {
+    if (!this.table)
+      return 0;
+    const result = await this.table.countRows();
+    return result;
+  }
+  /**
+   * Check if vector exists for event
+   */
+  async exists(eventId) {
+    if (!this.table)
+      return false;
+    const results = await this.table.search([]).where(`eventId = '${eventId}'`).limit(1).toArray();
+    return results.length > 0;
+  }
+};
+
+// src/core/embedder.ts
+import { pipeline } from "@xenova/transformers";
+var Embedder = class {
+  pipeline = null;
+  modelName;
+  initialized = false;
+  constructor(modelName = "Xenova/all-MiniLM-L6-v2") {
+    this.modelName = modelName;
+  }
+  /**
+   * Initialize the embedding pipeline
+   */
+  async initialize() {
+    if (this.initialized)
+      return;
+    this.pipeline = await pipeline("feature-extraction", this.modelName);
+    this.initialized = true;
+  }
+  /**
+   * Generate embedding for a single text
+   */
+  async embed(text) {
+    await this.initialize();
+    if (!this.pipeline) {
+      throw new Error("Embedding pipeline not initialized");
+    }
+    const output = await this.pipeline(text, {
+      pooling: "mean",
+      normalize: true
+    });
+    const vector = Array.from(output.data);
+    return {
+      vector,
+      model: this.modelName,
+      dimensions: vector.length
+    };
+  }
+  /**
+   * Generate embeddings for multiple texts in batch
+   */
+  async embedBatch(texts) {
+    await this.initialize();
+    if (!this.pipeline) {
+      throw new Error("Embedding pipeline not initialized");
+    }
+    const results = [];
+    const batchSize = 32;
+    for (let i = 0; i < texts.length; i += batchSize) {
+      const batch = texts.slice(i, i + batchSize);
+      for (const text of batch) {
+        const output = await this.pipeline(text, {
+          pooling: "mean",
+          normalize: true
+        });
+        const vector = Array.from(output.data);
+        results.push({
+          vector,
+          model: this.modelName,
+          dimensions: vector.length
+        });
+      }
+    }
+    return results;
+  }
+  /**
+   * Get embedding dimensions for the current model
+   */
+  async getDimensions() {
+    const result = await this.embed("test");
+    return result.dimensions;
+  }
+  /**
+   * Check if embedder is ready
+   */
+  isReady() {
+    return this.initialized && this.pipeline !== null;
+  }
+  /**
+   * Get model name
+   */
+  getModelName() {
+    return this.modelName;
+  }
+};
+var defaultEmbedder = null;
+function getDefaultEmbedder() {
+  if (!defaultEmbedder) {
+    defaultEmbedder = new Embedder();
+  }
+  return defaultEmbedder;
+}
+
+// src/core/vector-outbox.ts
+var DEFAULT_CONFIG = {
+  embeddingVersion: "v1",
+  maxRetries: 3,
+  stuckThresholdMs: 5 * 60 * 1e3,
+  // 5 minutes
+  cleanupDays: 7
+};
+
+// src/core/vector-worker.ts
+var DEFAULT_CONFIG2 = {
+  batchSize: 32,
+  pollIntervalMs: 1e3,
+  maxRetries: 3
+};
+var VectorWorker = class {
+  eventStore;
+  vectorStore;
+  embedder;
+  config;
+  running = false;
+  pollTimeout = null;
+  constructor(eventStore, vectorStore, embedder, config = {}) {
+    this.eventStore = eventStore;
+    this.vectorStore = vectorStore;
+    this.embedder = embedder;
+    this.config = { ...DEFAULT_CONFIG2, ...config };
+  }
+  /**
+   * Start the worker polling loop
+   */
+  start() {
+    if (this.running)
+      return;
+    this.running = true;
+    this.poll();
+  }
+  /**
+   * Stop the worker
+   */
+  stop() {
+    this.running = false;
+    if (this.pollTimeout) {
+      clearTimeout(this.pollTimeout);
+      this.pollTimeout = null;
+    }
+  }
+  /**
+   * Process a single batch of outbox items
+   */
+  async processBatch() {
+    const items = await this.eventStore.getPendingOutboxItems(this.config.batchSize);
+    if (items.length === 0) {
+      return 0;
+    }
+    const successful = [];
+    const failed = [];
+    try {
+      const embeddings = await this.embedder.embedBatch(items.map((i) => i.content));
+      const records = [];
+      for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        const embedding = embeddings[i];
+        const event = await this.eventStore.getEvent(item.eventId);
+        if (!event) {
+          failed.push(item.id);
+          continue;
+        }
+        records.push({
+          id: `vec_${item.id}`,
+          eventId: item.eventId,
+          sessionId: event.sessionId,
+          eventType: event.eventType,
+          content: item.content,
+          vector: embedding.vector,
+          timestamp: event.timestamp.toISOString(),
+          metadata: event.metadata
+        });
+        successful.push(item.id);
+      }
+      if (records.length > 0) {
+        await this.vectorStore.upsertBatch(records);
+      }
+      if (successful.length > 0) {
+        await this.eventStore.completeOutboxItems(successful);
+      }
+      if (failed.length > 0) {
+        await this.eventStore.failOutboxItems(failed, "Event not found");
+      }
+      return successful.length;
+    } catch (error) {
+      const allIds = items.map((i) => i.id);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      await this.eventStore.failOutboxItems(allIds, errorMessage);
+      throw error;
+    }
+  }
+  /**
+   * Poll for new items
+   */
+  async poll() {
+    if (!this.running)
+      return;
+    try {
+      await this.processBatch();
+    } catch (error) {
+      console.error("Vector worker error:", error);
+    }
+    this.pollTimeout = setTimeout(() => this.poll(), this.config.pollIntervalMs);
+  }
+  /**
+   * Process all pending items (blocking)
+   */
+  async processAll() {
+    let totalProcessed = 0;
+    let processed;
+    do {
+      processed = await this.processBatch();
+      totalProcessed += processed;
+    } while (processed > 0);
+    return totalProcessed;
+  }
+  /**
+   * Check if worker is running
+   */
+  isRunning() {
+    return this.running;
+  }
+};
+function createVectorWorker(eventStore, vectorStore, embedder, config) {
+  const worker = new VectorWorker(eventStore, vectorStore, embedder, config);
+  return worker;
+}
+
+// src/core/matcher.ts
+var DEFAULT_CONFIG3 = {
+  weights: {
+    semanticSimilarity: 0.4,
+    ftsScore: 0.25,
+    recencyBonus: 0.2,
+    statusWeight: 0.15
+  },
+  minCombinedScore: 0.92,
+  minGap: 0.03,
+  suggestionThreshold: 0.75
+};
+var Matcher = class {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      ...DEFAULT_CONFIG3,
+      ...config,
+      weights: { ...DEFAULT_CONFIG3.weights, ...config.weights }
+    };
+  }
+  /**
+   * Calculate combined score using AXIOMMIND weighted formula
+   */
+  calculateCombinedScore(semanticScore, ftsScore = 0, recencyDays = 0, isActive = true) {
+    const { weights } = this.config;
+    const recencyBonus = Math.max(0, 1 - recencyDays / 30);
+    const statusMultiplier = isActive ? 1 : 0.7;
+    const combinedScore = weights.semanticSimilarity * semanticScore + weights.ftsScore * ftsScore + weights.recencyBonus * recencyBonus + weights.statusWeight * statusMultiplier;
+    return Math.min(1, combinedScore);
+  }
+  /**
+   * Classify match confidence based on AXIOMMIND thresholds
+   */
+  classifyConfidence(topScore, secondScore) {
+    const { minCombinedScore, minGap, suggestionThreshold } = this.config;
+    const gap = secondScore !== null ? topScore - secondScore : Infinity;
+    if (topScore >= minCombinedScore && gap >= minGap) {
+      return "high";
+    }
+    if (topScore >= suggestionThreshold) {
+      return "suggested";
+    }
+    return "none";
+  }
+  /**
+   * Match search results to find best memory
+   */
+  matchSearchResults(results, getEventAge) {
+    if (results.length === 0) {
+      return {
+        match: null,
+        confidence: "none"
+      };
+    }
+    const scoredResults = results.map((result) => {
+      const ageDays = getEventAge(result.eventId);
+      const combinedScore = this.calculateCombinedScore(
+        result.score,
+        0,
+        // FTS score - would need to be passed in
+        ageDays,
+        true
+        // Assume active
+      );
+      return {
+        result,
+        combinedScore
+      };
+    });
+    scoredResults.sort((a, b) => b.combinedScore - a.combinedScore);
+    const topResult = scoredResults[0];
+    const secondScore = scoredResults.length > 1 ? scoredResults[1].combinedScore : null;
+    const confidence = this.classifyConfidence(topResult.combinedScore, secondScore);
+    const match = {
+      event: {
+        id: topResult.result.eventId,
+        eventType: topResult.result.eventType,
+        sessionId: topResult.result.sessionId,
+        timestamp: new Date(topResult.result.timestamp),
+        content: topResult.result.content,
+        canonicalKey: "",
+        // Would need to be fetched
+        dedupeKey: ""
+        // Would need to be fetched
+      },
+      score: topResult.combinedScore
+    };
+    const gap = secondScore !== null ? topResult.combinedScore - secondScore : void 0;
+    const alternatives = confidence === "suggested" ? scoredResults.slice(1, 4).map((sr) => ({
+      event: {
+        id: sr.result.eventId,
+        eventType: sr.result.eventType,
+        sessionId: sr.result.sessionId,
+        timestamp: new Date(sr.result.timestamp),
+        content: sr.result.content,
+        canonicalKey: "",
+        dedupeKey: ""
+      },
+      score: sr.combinedScore
+    })) : void 0;
+    return {
+      match: confidence !== "none" ? match : null,
+      confidence,
+      gap,
+      alternatives
+    };
+  }
+  /**
+   * Calculate days between two dates
+   */
+  static calculateAgeDays(timestamp) {
+    const now = /* @__PURE__ */ new Date();
+    const diffMs = now.getTime() - timestamp.getTime();
+    return diffMs / (1e3 * 60 * 60 * 24);
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+};
+var defaultMatcher = null;
+function getDefaultMatcher() {
+  if (!defaultMatcher) {
+    defaultMatcher = new Matcher();
+  }
+  return defaultMatcher;
+}
+
+// src/core/retriever.ts
+var DEFAULT_OPTIONS = {
+  topK: 5,
+  minScore: 0.7,
+  maxTokens: 2e3,
+  includeSessionContext: true
+};
+var Retriever = class {
+  eventStore;
+  vectorStore;
+  embedder;
+  matcher;
+  sharedStore;
+  sharedVectorStore;
+  constructor(eventStore, vectorStore, embedder, matcher, sharedOptions) {
+    this.eventStore = eventStore;
+    this.vectorStore = vectorStore;
+    this.embedder = embedder;
+    this.matcher = matcher;
+    this.sharedStore = sharedOptions?.sharedStore;
+    this.sharedVectorStore = sharedOptions?.sharedVectorStore;
+  }
+  /**
+   * Set shared stores after construction
+   */
+  setSharedStores(sharedStore, sharedVectorStore) {
+    this.sharedStore = sharedStore;
+    this.sharedVectorStore = sharedVectorStore;
+  }
+  /**
+   * Retrieve relevant memories for a query
+   */
+  async retrieve(query, options = {}) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const queryEmbedding = await this.embedder.embed(query);
+    const searchResults = await this.vectorStore.search(queryEmbedding.vector, {
+      limit: opts.topK * 2,
+      // Get extra for filtering
+      minScore: opts.minScore,
+      sessionId: opts.sessionId
+    });
+    const matchResult = this.matcher.matchSearchResults(
+      searchResults,
+      (eventId) => this.getEventAgeDays(eventId)
+    );
+    const memories = await this.enrichResults(searchResults.slice(0, opts.topK), opts);
+    const context = this.buildContext(memories, opts.maxTokens);
+    return {
+      memories,
+      matchResult,
+      totalTokens: this.estimateTokens(context),
+      context
+    };
+  }
+  /**
+   * Retrieve with unified search (project + shared)
+   */
+  async retrieveUnified(query, options = {}) {
+    const projectResult = await this.retrieve(query, options);
+    if (!options.includeShared || !this.sharedStore || !this.sharedVectorStore) {
+      return projectResult;
+    }
+    try {
+      const queryEmbedding = await this.embedder.embed(query);
+      const sharedVectorResults = await this.sharedVectorStore.search(
+        queryEmbedding.vector,
+        {
+          limit: options.topK || 5,
+          minScore: options.minScore || 0.7,
+          excludeProjectHash: options.projectHash
+        }
+      );
+      const sharedMemories = [];
+      for (const result of sharedVectorResults) {
+        const entry = await this.sharedStore.get(result.entryId);
+        if (entry) {
+          if (!options.projectHash || entry.sourceProjectHash !== options.projectHash) {
+            sharedMemories.push(entry);
+            await this.sharedStore.recordUsage(entry.entryId);
+          }
+        }
+      }
+      const unifiedContext = this.buildUnifiedContext(projectResult, sharedMemories);
+      return {
+        ...projectResult,
+        context: unifiedContext,
+        totalTokens: this.estimateTokens(unifiedContext),
+        sharedMemories
+      };
+    } catch (error) {
+      console.error("Shared search failed:", error);
+      return projectResult;
+    }
+  }
+  /**
+   * Build unified context combining project and shared memories
+   */
+  buildUnifiedContext(projectResult, sharedMemories) {
+    let context = projectResult.context;
+    if (sharedMemories.length > 0) {
+      context += "\n\n## Cross-Project Knowledge\n\n";
+      for (const memory of sharedMemories.slice(0, 3)) {
+        context += `### ${memory.title}
+`;
+        if (memory.symptoms.length > 0) {
+          context += `**Symptoms:** ${memory.symptoms.join(", ")}
+`;
+        }
+        context += `**Root Cause:** ${memory.rootCause}
+`;
+        context += `**Solution:** ${memory.solution}
+`;
+        if (memory.technologies && memory.technologies.length > 0) {
+          context += `**Technologies:** ${memory.technologies.join(", ")}
+`;
+        }
+        context += `_Confidence: ${(memory.confidence * 100).toFixed(0)}%_
+
+`;
+      }
+    }
+    return context;
+  }
+  /**
+   * Retrieve memories from a specific session
+   */
+  async retrieveFromSession(sessionId) {
+    return this.eventStore.getSessionEvents(sessionId);
+  }
+  /**
+   * Get recent memories across all sessions
+   */
+  async retrieveRecent(limit = 100) {
+    return this.eventStore.getRecentEvents(limit);
+  }
+  /**
+   * Enrich search results with full event data
+   */
+  async enrichResults(results, options) {
+    const memories = [];
+    for (const result of results) {
+      const event = await this.eventStore.getEvent(result.eventId);
+      if (!event)
+        continue;
+      let sessionContext;
+      if (options.includeSessionContext) {
+        sessionContext = await this.getSessionContext(event.sessionId, event.id);
+      }
+      memories.push({
+        event,
+        score: result.score,
+        sessionContext
+      });
+    }
+    return memories;
+  }
+  /**
+   * Get surrounding context from the same session
+   */
+  async getSessionContext(sessionId, eventId) {
+    const sessionEvents = await this.eventStore.getSessionEvents(sessionId);
+    const eventIndex = sessionEvents.findIndex((e) => e.id === eventId);
+    if (eventIndex === -1)
+      return void 0;
+    const start = Math.max(0, eventIndex - 1);
+    const end = Math.min(sessionEvents.length, eventIndex + 2);
+    const contextEvents = sessionEvents.slice(start, end);
+    if (contextEvents.length <= 1)
+      return void 0;
+    return contextEvents.filter((e) => e.id !== eventId).map((e) => `[${e.eventType}]: ${e.content.slice(0, 200)}...`).join("\n");
+  }
+  /**
+   * Build context string from memories (respecting token limit)
+   */
+  buildContext(memories, maxTokens) {
+    const parts = [];
+    let currentTokens = 0;
+    for (const memory of memories) {
+      const memoryText = this.formatMemory(memory);
+      const memoryTokens = this.estimateTokens(memoryText);
+      if (currentTokens + memoryTokens > maxTokens) {
+        break;
+      }
+      parts.push(memoryText);
+      currentTokens += memoryTokens;
+    }
+    if (parts.length === 0) {
+      return "";
+    }
+    return `## Relevant Memories
+
+${parts.join("\n\n---\n\n")}`;
+  }
+  /**
+   * Format a single memory for context
+   */
+  formatMemory(memory) {
+    const { event, score, sessionContext } = memory;
+    const date = event.timestamp.toISOString().split("T")[0];
+    let text = `**${event.eventType}** (${date}, score: ${score.toFixed(2)})
+${event.content}`;
+    if (sessionContext) {
+      text += `
+
+_Context:_ ${sessionContext}`;
+    }
+    return text;
+  }
+  /**
+   * Estimate token count (rough approximation)
+   */
+  estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+  }
+  /**
+   * Get event age in days (for recency scoring)
+   */
+  getEventAgeDays(eventId) {
+    return 0;
+  }
+};
+function createRetriever(eventStore, vectorStore, embedder, matcher) {
+  return new Retriever(eventStore, vectorStore, embedder, matcher);
+}
+
+// src/core/graduation.ts
+var DEFAULT_CRITERIA = {
+  L0toL1: {
+    minAccessCount: 1,
+    minConfidence: 0.5,
+    minCrossSessionRefs: 0,
+    maxAgeDays: 30
+  },
+  L1toL2: {
+    minAccessCount: 3,
+    minConfidence: 0.7,
+    minCrossSessionRefs: 1,
+    maxAgeDays: 60
+  },
+  L2toL3: {
+    minAccessCount: 5,
+    minConfidence: 0.85,
+    minCrossSessionRefs: 2,
+    maxAgeDays: 90
+  },
+  L3toL4: {
+    minAccessCount: 10,
+    minConfidence: 0.92,
+    minCrossSessionRefs: 3,
+    maxAgeDays: 180
+  }
+};
+var GraduationPipeline = class {
+  eventStore;
+  criteria;
+  metrics = /* @__PURE__ */ new Map();
+  constructor(eventStore, criteria = {}) {
+    this.eventStore = eventStore;
+    this.criteria = {
+      L0toL1: { ...DEFAULT_CRITERIA.L0toL1, ...criteria.L0toL1 },
+      L1toL2: { ...DEFAULT_CRITERIA.L1toL2, ...criteria.L1toL2 },
+      L2toL3: { ...DEFAULT_CRITERIA.L2toL3, ...criteria.L2toL3 },
+      L3toL4: { ...DEFAULT_CRITERIA.L3toL4, ...criteria.L3toL4 }
+    };
+  }
+  /**
+   * Record an access to an event (used for graduation scoring)
+   */
+  recordAccess(eventId, fromSessionId, confidence = 1) {
+    const existing = this.metrics.get(eventId);
+    if (existing) {
+      existing.accessCount++;
+      existing.lastAccessed = /* @__PURE__ */ new Date();
+      existing.confidence = Math.max(existing.confidence, confidence);
+    } else {
+      this.metrics.set(eventId, {
+        eventId,
+        accessCount: 1,
+        lastAccessed: /* @__PURE__ */ new Date(),
+        crossSessionRefs: 0,
+        confidence
+      });
+    }
+  }
+  /**
+   * Evaluate if an event should graduate to the next level
+   */
+  async evaluateGraduation(eventId, currentLevel) {
+    const metrics = this.metrics.get(eventId);
+    if (!metrics) {
+      return {
+        eventId,
+        fromLevel: currentLevel,
+        toLevel: currentLevel,
+        success: false,
+        reason: "No metrics available for event"
+      };
+    }
+    const nextLevel = this.getNextLevel(currentLevel);
+    if (!nextLevel) {
+      return {
+        eventId,
+        fromLevel: currentLevel,
+        toLevel: currentLevel,
+        success: false,
+        reason: "Already at maximum level"
+      };
+    }
+    const criteria = this.getCriteria(currentLevel, nextLevel);
+    const evaluation = this.checkCriteria(metrics, criteria);
+    if (evaluation.passed) {
+      await this.eventStore.updateMemoryLevel(eventId, nextLevel);
+      return {
+        eventId,
+        fromLevel: currentLevel,
+        toLevel: nextLevel,
+        success: true
+      };
+    }
+    return {
+      eventId,
+      fromLevel: currentLevel,
+      toLevel: currentLevel,
+      success: false,
+      reason: evaluation.reason
+    };
+  }
+  /**
+   * Run graduation evaluation for all events at a given level
+   */
+  async graduateBatch(level) {
+    const results = [];
+    for (const [eventId, metrics] of this.metrics) {
+      const result = await this.evaluateGraduation(eventId, level);
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * Extract insights from graduated events (L1+)
+   */
+  extractInsights(events) {
+    const insights = [];
+    const patterns = this.detectPatterns(events);
+    for (const pattern of patterns) {
+      insights.push({
+        id: crypto.randomUUID(),
+        insightType: "pattern",
+        content: pattern.description,
+        canonicalKey: pattern.key,
+        confidence: pattern.confidence,
+        sourceEvents: pattern.eventIds,
+        createdAt: /* @__PURE__ */ new Date(),
+        lastUpdated: /* @__PURE__ */ new Date()
+      });
+    }
+    const preferences = this.detectPreferences(events);
+    for (const pref of preferences) {
+      insights.push({
+        id: crypto.randomUUID(),
+        insightType: "preference",
+        content: pref.description,
+        canonicalKey: pref.key,
+        confidence: pref.confidence,
+        sourceEvents: pref.eventIds,
+        createdAt: /* @__PURE__ */ new Date(),
+        lastUpdated: /* @__PURE__ */ new Date()
+      });
+    }
+    return insights;
+  }
+  /**
+   * Get the next level in the graduation pipeline
+   */
+  getNextLevel(current) {
+    const levels = ["L0", "L1", "L2", "L3", "L4"];
+    const currentIndex = levels.indexOf(current);
+    if (currentIndex === -1 || currentIndex >= levels.length - 1) {
+      return null;
+    }
+    return levels[currentIndex + 1];
+  }
+  /**
+   * Get criteria for level transition
+   */
+  getCriteria(from, to) {
+    const key = `${from}to${to}`;
+    return this.criteria[key] || DEFAULT_CRITERIA.L0toL1;
+  }
+  /**
+   * Check if metrics meet criteria
+   */
+  checkCriteria(metrics, criteria) {
+    if (metrics.accessCount < criteria.minAccessCount) {
+      return {
+        passed: false,
+        reason: `Access count ${metrics.accessCount} < ${criteria.minAccessCount}`
+      };
+    }
+    if (metrics.confidence < criteria.minConfidence) {
+      return {
+        passed: false,
+        reason: `Confidence ${metrics.confidence} < ${criteria.minConfidence}`
+      };
+    }
+    if (metrics.crossSessionRefs < criteria.minCrossSessionRefs) {
+      return {
+        passed: false,
+        reason: `Cross-session refs ${metrics.crossSessionRefs} < ${criteria.minCrossSessionRefs}`
+      };
+    }
+    const ageDays = (Date.now() - metrics.lastAccessed.getTime()) / (1e3 * 60 * 60 * 24);
+    if (ageDays > criteria.maxAgeDays) {
+      return {
+        passed: false,
+        reason: `Event too old: ${ageDays.toFixed(1)} days > ${criteria.maxAgeDays}`
+      };
+    }
+    return { passed: true };
+  }
+  /**
+   * Detect patterns in events
+   */
+  detectPatterns(events) {
+    const keyGroups = /* @__PURE__ */ new Map();
+    for (const event of events) {
+      const existing = keyGroups.get(event.canonicalKey) || [];
+      existing.push(event);
+      keyGroups.set(event.canonicalKey, existing);
+    }
+    const patterns = [];
+    for (const [key, groupEvents] of keyGroups) {
+      if (groupEvents.length >= 2) {
+        patterns.push({
+          key,
+          description: `Repeated topic: ${key.slice(0, 50)}`,
+          confidence: Math.min(1, groupEvents.length / 5),
+          eventIds: groupEvents.map((e) => e.id)
+        });
+      }
+    }
+    return patterns;
+  }
+  /**
+   * Detect user preferences from events
+   */
+  detectPreferences(events) {
+    const preferenceKeywords = ["prefer", "like", "want", "always", "never", "favorite"];
+    const preferences = [];
+    for (const event of events) {
+      if (event.eventType !== "user_prompt")
+        continue;
+      const lowerContent = event.content.toLowerCase();
+      for (const keyword of preferenceKeywords) {
+        if (lowerContent.includes(keyword)) {
+          preferences.push({
+            key: `preference_${keyword}_${event.id.slice(0, 8)}`,
+            description: `User preference: ${event.content.slice(0, 100)}`,
+            confidence: 0.7,
+            eventIds: [event.id]
+          });
+          break;
+        }
+      }
+    }
+    return preferences;
+  }
+  /**
+   * Get graduation statistics
+   */
+  async getStats() {
+    return this.eventStore.getLevelStats();
+  }
+};
+function createGraduationPipeline(eventStore) {
+  return new GraduationPipeline(eventStore);
+}
+
+// src/core/shared-event-store.ts
+var SharedEventStore = class {
+  constructor(dbPath) {
+    this.dbPath = dbPath;
+    this.db = createDatabase(dbPath);
+  }
+  db;
+  initialized = false;
+  async initialize() {
+    if (this.initialized)
+      return;
+    await dbRun(this.db, `
+      CREATE TABLE IF NOT EXISTS shared_troubleshooting (
+        entry_id VARCHAR PRIMARY KEY,
+        source_project_hash VARCHAR NOT NULL,
+        source_entry_id VARCHAR NOT NULL,
+        title VARCHAR NOT NULL,
+        symptoms JSON NOT NULL,
+        root_cause TEXT NOT NULL,
+        solution TEXT NOT NULL,
+        topics JSON NOT NULL,
+        technologies JSON,
+        confidence REAL NOT NULL DEFAULT 0.8,
+        usage_count INTEGER DEFAULT 0,
+        last_used_at TIMESTAMP,
+        promoted_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        UNIQUE(source_project_hash, source_entry_id)
+      )
+    `);
+    await dbRun(this.db, `
+      CREATE TABLE IF NOT EXISTS shared_best_practices (
+        entry_id VARCHAR PRIMARY KEY,
+        source_project_hash VARCHAR NOT NULL,
+        source_entry_id VARCHAR NOT NULL,
+        title VARCHAR NOT NULL,
+        content_json JSON NOT NULL,
+        topics JSON NOT NULL,
+        confidence REAL NOT NULL DEFAULT 0.8,
+        usage_count INTEGER DEFAULT 0,
+        promoted_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        UNIQUE(source_project_hash, source_entry_id)
+      )
+    `);
+    await dbRun(this.db, `
+      CREATE TABLE IF NOT EXISTS shared_common_errors (
+        entry_id VARCHAR PRIMARY KEY,
+        source_project_hash VARCHAR NOT NULL,
+        source_entry_id VARCHAR NOT NULL,
+        title VARCHAR NOT NULL,
+        error_pattern TEXT NOT NULL,
+        solution TEXT NOT NULL,
+        topics JSON NOT NULL,
+        technologies JSON,
+        confidence REAL NOT NULL DEFAULT 0.8,
+        usage_count INTEGER DEFAULT 0,
+        promoted_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        UNIQUE(source_project_hash, source_entry_id)
+      )
+    `);
+    await dbRun(this.db, `
+      CREATE INDEX IF NOT EXISTS idx_shared_ts_confidence
+      ON shared_troubleshooting(confidence DESC)
+    `);
+    await dbRun(this.db, `
+      CREATE INDEX IF NOT EXISTS idx_shared_ts_usage
+      ON shared_troubleshooting(usage_count DESC)
+    `);
+    await dbRun(this.db, `
+      CREATE INDEX IF NOT EXISTS idx_shared_ts_source
+      ON shared_troubleshooting(source_project_hash)
+    `);
+    this.initialized = true;
+  }
+  getDatabase() {
+    return this.db;
+  }
+  isInitialized() {
+    return this.initialized;
+  }
+  async close() {
+    await dbClose(this.db);
+    this.initialized = false;
+  }
+};
+function createSharedEventStore(dbPath) {
+  return new SharedEventStore(dbPath);
+}
+
+// src/core/shared-store.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var SharedStore = class {
+  constructor(sharedEventStore) {
+    this.sharedEventStore = sharedEventStore;
+  }
+  get db() {
+    return this.sharedEventStore.getDatabase();
+  }
+  /**
+   * Promote a verified troubleshooting entry to shared storage
+   */
+  async promoteEntry(input) {
+    const entryId = randomUUID2();
+    await dbRun(
+      this.db,
+      `INSERT INTO shared_troubleshooting (
+        entry_id, source_project_hash, source_entry_id,
+        title, symptoms, root_cause, solution, topics,
+        technologies, confidence, promoted_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+      ON CONFLICT (source_project_hash, source_entry_id)
+      DO UPDATE SET
+        title = excluded.title,
+        symptoms = excluded.symptoms,
+        root_cause = excluded.root_cause,
+        solution = excluded.solution,
+        topics = excluded.topics,
+        technologies = excluded.technologies,
+        confidence = CASE
+          WHEN excluded.confidence > shared_troubleshooting.confidence
+          THEN excluded.confidence
+          ELSE shared_troubleshooting.confidence
+        END`,
+      [
+        entryId,
+        input.sourceProjectHash,
+        input.sourceEntryId,
+        input.title,
+        JSON.stringify(input.symptoms),
+        input.rootCause,
+        input.solution,
+        JSON.stringify(input.topics),
+        JSON.stringify(input.technologies || []),
+        input.confidence
+      ]
+    );
+    return entryId;
+  }
+  /**
+   * Search troubleshooting entries by text query
+   */
+  async search(query, options) {
+    const topK = options?.topK || 5;
+    const minConfidence = options?.minConfidence || 0.5;
+    const searchPattern = `%${query}%`;
+    const rows = await dbAll(
+      this.db,
+      `SELECT * FROM shared_troubleshooting
+       WHERE (title LIKE ? OR root_cause LIKE ? OR solution LIKE ?)
+       AND confidence >= ?
+       ORDER BY confidence DESC, usage_count DESC
+       LIMIT ?`,
+      [searchPattern, searchPattern, searchPattern, minConfidence, topK]
+    );
+    return rows.map(this.rowToEntry);
+  }
+  /**
+   * Search by topics
+   */
+  async searchByTopics(topics, options) {
+    const topK = options?.topK || 5;
+    if (topics.length === 0) {
+      return [];
+    }
+    const topicConditions = topics.map(() => `topics LIKE ?`).join(" OR ");
+    const topicParams = topics.map((t) => `%"${t}"%`);
+    let query = `SELECT * FROM shared_troubleshooting WHERE (${topicConditions})`;
+    const params = [...topicParams];
+    if (options?.excludeProjectHash) {
+      query += ` AND source_project_hash != ?`;
+      params.push(options.excludeProjectHash);
+    }
+    query += ` ORDER BY confidence DESC, usage_count DESC LIMIT ?`;
+    params.push(topK);
+    const rows = await dbAll(this.db, query, params);
+    return rows.map(this.rowToEntry);
+  }
+  /**
+   * Record usage of a shared entry (for ranking)
+   */
+  async recordUsage(entryId) {
+    await dbRun(
+      this.db,
+      `UPDATE shared_troubleshooting
+       SET usage_count = usage_count + 1,
+           last_used_at = CURRENT_TIMESTAMP
+       WHERE entry_id = ?`,
+      [entryId]
+    );
+  }
+  /**
+   * Get entry by ID
+   */
+  async get(entryId) {
+    const rows = await dbAll(
+      this.db,
+      `SELECT * FROM shared_troubleshooting WHERE entry_id = ?`,
+      [entryId]
+    );
+    if (rows.length === 0)
+      return null;
+    return this.rowToEntry(rows[0]);
+  }
+  /**
+   * Get entry by source (project hash + entry ID)
+   */
+  async getBySource(projectHash, sourceEntryId) {
+    const rows = await dbAll(
+      this.db,
+      `SELECT * FROM shared_troubleshooting
+       WHERE source_project_hash = ? AND source_entry_id = ?`,
+      [projectHash, sourceEntryId]
+    );
+    if (rows.length === 0)
+      return null;
+    return this.rowToEntry(rows[0]);
+  }
+  /**
+   * Check if an entry already exists in shared store
+   */
+  async exists(projectHash, sourceEntryId) {
+    const result = await dbAll(
+      this.db,
+      `SELECT COUNT(*) as count FROM shared_troubleshooting
+       WHERE source_project_hash = ? AND source_entry_id = ?`,
+      [projectHash, sourceEntryId]
+    );
+    return (result[0]?.count || 0) > 0;
+  }
+  /**
+   * Get all entries (with limit for safety)
+   */
+  async getAll(options) {
+    const limit = options?.limit || 100;
+    const rows = await dbAll(
+      this.db,
+      `SELECT * FROM shared_troubleshooting
+       ORDER BY confidence DESC, usage_count DESC
+       LIMIT ?`,
+      [limit]
+    );
+    return rows.map(this.rowToEntry);
+  }
+  /**
+   * Get total count
+   */
+  async count() {
+    const result = await dbAll(
+      this.db,
+      `SELECT COUNT(*) as count FROM shared_troubleshooting`
+    );
+    return result[0]?.count || 0;
+  }
+  /**
+   * Get statistics
+   */
+  async getStats() {
+    const countResult = await dbAll(
+      this.db,
+      `SELECT COUNT(*) as count FROM shared_troubleshooting`
+    );
+    const total = countResult[0]?.count || 0;
+    const avgResult = await dbAll(
+      this.db,
+      `SELECT AVG(confidence) as avg FROM shared_troubleshooting`
+    );
+    const averageConfidence = avgResult[0]?.avg || 0;
+    const usageResult = await dbAll(
+      this.db,
+      `SELECT SUM(usage_count) as total FROM shared_troubleshooting`
+    );
+    const totalUsageCount = usageResult[0]?.total || 0;
+    const entries = await this.getAll({ limit: 1e3 });
+    const topicCounts = {};
+    for (const entry of entries) {
+      for (const topic of entry.topics) {
+        topicCounts[topic] = (topicCounts[topic] || 0) + 1;
+      }
+    }
+    const topTopics = Object.entries(topicCounts).map(([topic, count]) => ({ topic, count })).sort((a, b) => b.count - a.count).slice(0, 10);
+    return { total, averageConfidence, topTopics, totalUsageCount };
+  }
+  /**
+   * Delete an entry
+   */
+  async delete(entryId) {
+    const before = await this.count();
+    await dbRun(
+      this.db,
+      `DELETE FROM shared_troubleshooting WHERE entry_id = ?`,
+      [entryId]
+    );
+    const after = await this.count();
+    return before > after;
+  }
+  rowToEntry(row) {
+    return {
+      entryId: row.entry_id,
+      sourceProjectHash: row.source_project_hash,
+      sourceEntryId: row.source_entry_id,
+      title: row.title,
+      symptoms: JSON.parse(row.symptoms || "[]"),
+      rootCause: row.root_cause,
+      solution: row.solution,
+      topics: JSON.parse(row.topics || "[]"),
+      technologies: JSON.parse(row.technologies || "[]"),
+      confidence: row.confidence,
+      usageCount: row.usage_count || 0,
+      lastUsedAt: row.last_used_at ? toDate(row.last_used_at) : void 0,
+      promotedAt: toDate(row.promoted_at),
+      createdAt: toDate(row.created_at)
+    };
+  }
+};
+function createSharedStore(sharedEventStore) {
+  return new SharedStore(sharedEventStore);
+}
+
+// src/core/shared-vector-store.ts
+import * as lancedb2 from "@lancedb/lancedb";
+var SharedVectorStore = class {
+  constructor(dbPath) {
+    this.dbPath = dbPath;
+  }
+  db = null;
+  table = null;
+  tableName = "shared_knowledge";
+  /**
+   * Initialize LanceDB connection
+   */
+  async initialize() {
+    if (this.db)
+      return;
+    this.db = await lancedb2.connect(this.dbPath);
+    try {
+      const tables = await this.db.tableNames();
+      if (tables.includes(this.tableName)) {
+        this.table = await this.db.openTable(this.tableName);
+      }
+    } catch {
+      this.table = null;
+    }
+  }
+  /**
+   * Add or update a shared vector record
+   */
+  async upsert(record) {
+    await this.initialize();
+    if (!this.db) {
+      throw new Error("Database not initialized");
+    }
+    const data = {
+      id: record.id,
+      entryId: record.entryId,
+      entryType: record.entryType,
+      content: record.content,
+      vector: record.vector,
+      topics: JSON.stringify(record.topics),
+      sourceProjectHash: record.sourceProjectHash || ""
+    };
+    if (!this.table) {
+      this.table = await this.db.createTable(this.tableName, [data]);
+    } else {
+      try {
+        await this.table.delete(`entryId = '${record.entryId}'`);
+      } catch {
+      }
+      await this.table.add([data]);
+    }
+  }
+  /**
+   * Add multiple records in batch
+   */
+  async upsertBatch(records) {
+    if (records.length === 0)
+      return;
+    await this.initialize();
+    if (!this.db) {
+      throw new Error("Database not initialized");
+    }
+    const data = records.map((record) => ({
+      id: record.id,
+      entryId: record.entryId,
+      entryType: record.entryType,
+      content: record.content,
+      vector: record.vector,
+      topics: JSON.stringify(record.topics),
+      sourceProjectHash: record.sourceProjectHash || ""
+    }));
+    if (!this.table) {
+      this.table = await this.db.createTable(this.tableName, data);
+    } else {
+      await this.table.add(data);
+    }
+  }
+  /**
+   * Search for similar vectors
+   */
+  async search(queryVector, options = {}) {
+    await this.initialize();
+    if (!this.table) {
+      return [];
+    }
+    const { limit = 5, minScore = 0.7, excludeProjectHash, entryType } = options;
+    let query = this.table.search(queryVector).distanceType("cosine").limit(limit * 2);
+    const filters = [];
+    if (excludeProjectHash) {
+      filters.push(`sourceProjectHash != '${excludeProjectHash}'`);
+    }
+    if (entryType) {
+      filters.push(`entryType = '${entryType}'`);
+    }
+    if (filters.length > 0) {
+      query = query.where(filters.join(" AND "));
+    }
+    const results = await query.toArray();
+    return results.filter((r) => {
+      const distance = r._distance || 0;
+      const score = 1 - distance / 2;
+      return score >= minScore;
+    }).slice(0, limit).map((r) => {
+      const distance = r._distance || 0;
+      const score = 1 - distance / 2;
+      return {
+        id: r.id,
+        entryId: r.entryId,
+        content: r.content,
+        score,
+        entryType: r.entryType
+      };
+    });
+  }
+  /**
+   * Delete vector by entry ID
+   */
+  async delete(entryId) {
+    if (!this.table)
+      return;
+    await this.table.delete(`entryId = '${entryId}'`);
+  }
+  /**
+   * Get total count
+   */
+  async count() {
+    if (!this.table)
+      return 0;
+    return this.table.countRows();
+  }
+  /**
+   * Check if vector exists for entry
+   */
+  async exists(entryId) {
+    if (!this.table)
+      return false;
+    try {
+      const results = await this.table.search([]).where(`entryId = '${entryId}'`).limit(1).toArray();
+      return results.length > 0;
+    } catch {
+      return false;
+    }
+  }
+};
+function createSharedVectorStore(dbPath) {
+  return new SharedVectorStore(dbPath);
+}
+
+// src/core/shared-promoter.ts
+import { randomUUID as randomUUID3 } from "crypto";
+var SharedPromoter = class {
+  constructor(sharedStore, sharedVectorStore, embedder, config) {
+    this.sharedStore = sharedStore;
+    this.sharedVectorStore = sharedVectorStore;
+    this.embedder = embedder;
+    this.config = config;
+  }
+  /**
+   * Check if an entry is eligible for promotion
+   */
+  isEligibleForPromotion(entry) {
+    if (entry.entryType !== "troubleshooting") {
+      return false;
+    }
+    if (entry.stage !== "verified" && entry.stage !== "certified") {
+      return false;
+    }
+    if (entry.status !== "active") {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Promote a verified troubleshooting entry to shared storage
+   */
+  async promoteEntry(entry, projectHash) {
+    if (!this.isEligibleForPromotion(entry)) {
+      return {
+        success: false,
+        skipped: true,
+        skipReason: `Entry not eligible: type=${entry.entryType}, stage=${entry.stage}, status=${entry.status}`
+      };
+    }
+    const exists = await this.sharedStore.exists(projectHash, entry.entryId);
+    if (exists) {
+      return {
+        success: true,
+        skipped: true,
+        skipReason: "Entry already exists in shared store"
+      };
+    }
+    try {
+      const content = entry.contentJson;
+      const confidence = this.calculateConfidence(entry);
+      const minConfidence = this.config?.minConfidenceForPromotion ?? 0.8;
+      if (confidence < minConfidence) {
+        return {
+          success: false,
+          skipped: true,
+          skipReason: `Confidence ${confidence} below threshold ${minConfidence}`
+        };
+      }
+      const input = {
+        sourceProjectHash: projectHash,
+        sourceEntryId: entry.entryId,
+        title: entry.title,
+        symptoms: content.symptoms || [],
+        rootCause: content.rootCause || "",
+        solution: content.solution || "",
+        topics: this.extractTopics(entry),
+        technologies: content.technologies || [],
+        confidence
+      };
+      const entryId = await this.sharedStore.promoteEntry(input);
+      const embeddingContent = this.createEmbeddingContent(input);
+      const embedding = await this.embedder.embed(embeddingContent);
+      await this.sharedVectorStore.upsert({
+        id: randomUUID3(),
+        entryId,
+        entryType: "troubleshooting",
+        content: embeddingContent,
+        vector: embedding.vector,
+        topics: input.topics,
+        sourceProjectHash: projectHash
+      });
+      return {
+        success: true,
+        entryId
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Batch promote multiple entries
+   */
+  async promoteEntries(entries, projectHash) {
+    const results = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const result = await this.promoteEntry(entry, projectHash);
+      results.set(entry.entryId, result);
+    }
+    return results;
+  }
+  /**
+   * Extract topics from entry
+   */
+  extractTopics(entry) {
+    const topics = [];
+    const titleWords = entry.title.toLowerCase().split(/[\s\-_]+/).filter((w) => w.length > 3 && !this.isStopWord(w));
+    topics.push(...titleWords);
+    const content = entry.contentJson;
+    if (content.topics && Array.isArray(content.topics)) {
+      topics.push(...content.topics.map((t) => String(t).toLowerCase()));
+    }
+    if (content.technologies && Array.isArray(content.technologies)) {
+      topics.push(...content.technologies.map((t) => String(t).toLowerCase()));
+    }
+    return [...new Set(topics)];
+  }
+  /**
+   * Check if word is a stop word
+   */
+  isStopWord(word) {
+    const stopWords = /* @__PURE__ */ new Set([
+      "the",
+      "and",
+      "for",
+      "with",
+      "this",
+      "that",
+      "from",
+      "have",
+      "been",
+      "were",
+      "are",
+      "was",
+      "had",
+      "has",
+      "will",
+      "would",
+      "could",
+      "should",
+      "when",
+      "where",
+      "what",
+      "which",
+      "while",
+      "error",
+      "problem",
+      "issue"
+    ]);
+    return stopWords.has(word);
+  }
+  /**
+   * Calculate confidence score for entry
+   */
+  calculateConfidence(entry) {
+    let confidence = 0.8;
+    if (entry.stage === "certified") {
+      confidence = 0.95;
+    }
+    return Math.min(confidence, 1);
+  }
+  /**
+   * Create embedding content from input
+   */
+  createEmbeddingContent(input) {
+    const parts = [];
+    parts.push(`Problem: ${input.title}`);
+    if (input.symptoms.length > 0) {
+      parts.push(`Symptoms: ${input.symptoms.join(", ")}`);
+    }
+    if (input.rootCause) {
+      parts.push(`Root Cause: ${input.rootCause}`);
+    }
+    if (input.solution) {
+      parts.push(`Solution: ${input.solution}`);
+    }
+    if (input.technologies && input.technologies.length > 0) {
+      parts.push(`Technologies: ${input.technologies.join(", ")}`);
+    }
+    return parts.join("\n");
+  }
+};
+function createSharedPromoter(sharedStore, sharedVectorStore, embedder, config) {
+  return new SharedPromoter(sharedStore, sharedVectorStore, embedder, config);
+}
+
+// src/core/metadata-extractor.ts
+function createToolObservationEmbedding(toolName, metadata, success) {
+  const parts = [];
+  parts.push(`Tool: ${toolName}`);
+  if (metadata.filePath) {
+    parts.push(`File: ${metadata.filePath}`);
+  }
+  if (metadata.command) {
+    parts.push(`Command: ${metadata.command}`);
+  }
+  if (metadata.pattern) {
+    parts.push(`Pattern: ${metadata.pattern}`);
+  }
+  if (metadata.url) {
+    try {
+      const url = new URL(metadata.url);
+      parts.push(`URL: ${url.hostname}`);
+    } catch {
+    }
+  }
+  parts.push(`Result: ${success ? "Success" : "Failed"}`);
+  return parts.join("\n");
+}
+
+// src/core/working-set-store.ts
+import { randomUUID as randomUUID4 } from "crypto";
+var WorkingSetStore = class {
+  constructor(eventStore, config) {
+    this.eventStore = eventStore;
+    this.config = config;
+  }
+  get db() {
+    return this.eventStore.getDatabase();
+  }
+  /**
+   * Add an event to the working set
+   */
+  async add(eventId, relevanceScore = 1, topics) {
+    const expiresAt = new Date(
+      Date.now() + this.config.workingSet.timeWindowHours * 60 * 60 * 1e3
+    );
+    await dbRun(
+      this.db,
+      `INSERT OR REPLACE INTO working_set (id, event_id, added_at, relevance_score, topics, expires_at)
+       VALUES (?, ?, CURRENT_TIMESTAMP, ?, ?, ?)`,
+      [
+        randomUUID4(),
+        eventId,
+        relevanceScore,
+        JSON.stringify(topics || []),
+        expiresAt.toISOString()
+      ]
+    );
+    await this.enforceLimit();
+  }
+  /**
+   * Get the current working set
+   */
+  async get() {
+    await this.cleanup();
+    const rows = await dbAll(
+      this.db,
+      `SELECT ws.*, e.*
+       FROM working_set ws
+       JOIN events e ON ws.event_id = e.id
+       ORDER BY ws.relevance_score DESC, ws.added_at DESC
+       LIMIT ?`,
+      [this.config.workingSet.maxEvents]
+    );
+    const events = rows.map((row) => ({
+      id: row.id,
+      eventType: row.event_type,
+      sessionId: row.session_id,
+      timestamp: toDate(row.timestamp),
+      content: row.content,
+      canonicalKey: row.canonical_key,
+      dedupeKey: row.dedupe_key,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0
+    }));
+    return {
+      recentEvents: events,
+      lastActivity: events.length > 0 ? events[0].timestamp : /* @__PURE__ */ new Date(),
+      continuityScore: await this.calculateContinuityScore()
+    };
+  }
+  /**
+   * Get working set items (metadata only)
+   */
+  async getItems() {
+    const rows = await dbAll(
+      this.db,
+      `SELECT * FROM working_set ORDER BY relevance_score DESC, added_at DESC`
+    );
+    return rows.map((row) => ({
+      id: row.id,
+      eventId: row.event_id,
+      addedAt: toDate(row.added_at),
+      relevanceScore: row.relevance_score,
+      topics: row.topics ? JSON.parse(row.topics) : void 0,
+      expiresAt: toDate(row.expires_at)
+    }));
+  }
+  /**
+   * Update relevance score for an event
+   */
+  async updateRelevance(eventId, score) {
+    await dbRun(
+      this.db,
+      `UPDATE working_set SET relevance_score = ? WHERE event_id = ?`,
+      [score, eventId]
+    );
+  }
+  /**
+   * Prune specific events from working set (after consolidation)
+   */
+  async prune(eventIds) {
+    if (eventIds.length === 0)
+      return;
+    const placeholders = eventIds.map(() => "?").join(",");
+    await dbRun(
+      this.db,
+      `DELETE FROM working_set WHERE event_id IN (${placeholders})`,
+      eventIds
+    );
+  }
+  /**
+   * Get the count of items in working set
+   */
+  async count() {
+    const result = await dbAll(
+      this.db,
+      `SELECT COUNT(*) as count FROM working_set`
+    );
+    return result[0]?.count || 0;
+  }
+  /**
+   * Clear the entire working set
+   */
+  async clear() {
+    await dbRun(this.db, `DELETE FROM working_set`);
+  }
+  /**
+   * Check if an event is in the working set
+   */
+  async contains(eventId) {
+    const result = await dbAll(
+      this.db,
+      `SELECT COUNT(*) as count FROM working_set WHERE event_id = ?`,
+      [eventId]
+    );
+    return (result[0]?.count || 0) > 0;
+  }
+  /**
+   * Refresh expiration for an event (rehears al - keep relevant items longer)
+   */
+  async refresh(eventId) {
+    const newExpiresAt = new Date(
+      Date.now() + this.config.workingSet.timeWindowHours * 60 * 60 * 1e3
+    );
+    await dbRun(
+      this.db,
+      `UPDATE working_set SET expires_at = ? WHERE event_id = ?`,
+      [newExpiresAt.toISOString(), eventId]
+    );
+  }
+  /**
+   * Clean up expired items
+   */
+  async cleanup() {
+    await dbRun(
+      this.db,
+      `DELETE FROM working_set WHERE expires_at < datetime('now')`
+    );
+  }
+  /**
+   * Enforce the maximum size limit
+   * Removes lowest relevance items when over limit
+   */
+  async enforceLimit() {
+    const maxEvents = this.config.workingSet.maxEvents;
+    const keepIds = await dbAll(
+      this.db,
+      `SELECT id FROM working_set
+       ORDER BY relevance_score DESC, added_at DESC
+       LIMIT ?`,
+      [maxEvents]
+    );
+    if (keepIds.length === 0)
+      return;
+    const keepIdList = keepIds.map((r) => r.id);
+    const placeholders = keepIdList.map(() => "?").join(",");
+    await dbRun(
+      this.db,
+      `DELETE FROM working_set WHERE id NOT IN (${placeholders})`,
+      keepIdList
+    );
+  }
+  /**
+   * Calculate continuity score based on recent context transitions
+   */
+  async calculateContinuityScore() {
+    const result = await dbAll(
+      this.db,
+      `SELECT AVG(continuity_score) as avg_score
+       FROM continuity_log
+       WHERE created_at > datetime('now', '-1 hour')`
+    );
+    return result[0]?.avg_score ?? 0.5;
+  }
+  /**
+   * Get topics from current working set for context matching
+   */
+  async getActiveTopics() {
+    const rows = await dbAll(
+      this.db,
+      `SELECT topics FROM working_set WHERE topics IS NOT NULL`
+    );
+    const allTopics = /* @__PURE__ */ new Set();
+    for (const row of rows) {
+      const topics = JSON.parse(row.topics);
+      topics.forEach((t) => allTopics.add(t));
+    }
+    return Array.from(allTopics);
+  }
+};
+function createWorkingSetStore(eventStore, config) {
+  return new WorkingSetStore(eventStore, config);
+}
+
+// src/core/consolidated-store.ts
+import { randomUUID as randomUUID5 } from "crypto";
+var ConsolidatedStore = class {
+  constructor(eventStore) {
+    this.eventStore = eventStore;
+  }
+  get db() {
+    return this.eventStore.getDatabase();
+  }
+  /**
+   * Create a new consolidated memory
+   */
+  async create(input) {
+    const memoryId = randomUUID5();
+    await dbRun(
+      this.db,
+      `INSERT INTO consolidated_memories
+        (memory_id, summary, topics, source_events, confidence, created_at)
+       VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)`,
+      [
+        memoryId,
+        input.summary,
+        JSON.stringify(input.topics),
+        JSON.stringify(input.sourceEvents),
+        input.confidence
+      ]
+    );
+    return memoryId;
+  }
+  /**
+   * Get a consolidated memory by ID
+   */
+  async get(memoryId) {
+    const rows = await dbAll(
+      this.db,
+      `SELECT * FROM consolidated_memories WHERE memory_id = ?`,
+      [memoryId]
+    );
+    if (rows.length === 0)
+      return null;
+    return this.rowToMemory(rows[0]);
+  }
+  /**
+   * Search consolidated memories by query (simple text search)
+   */
+  async search(query, options) {
+    const topK = options?.topK || 5;
+    const rows = await dbAll(
+      this.db,
+      `SELECT * FROM consolidated_memories
+       WHERE summary LIKE ?
+       ORDER BY confidence DESC
+       LIMIT ?`,
+      [`%${query}%`, topK]
+    );
+    return rows.map(this.rowToMemory);
+  }
+  /**
+   * Search by topics
+   */
+  async searchByTopics(topics, options) {
+    const topK = options?.topK || 5;
+    const topicConditions = topics.map(() => `topics LIKE ?`).join(" OR ");
+    const topicParams = topics.map((t) => `%"${t}"%`);
+    const rows = await dbAll(
+      this.db,
+      `SELECT * FROM consolidated_memories
+       WHERE ${topicConditions}
+       ORDER BY confidence DESC
+       LIMIT ?`,
+      [...topicParams, topK]
+    );
+    return rows.map(this.rowToMemory);
+  }
+  /**
+   * Get all consolidated memories ordered by confidence
+   */
+  async getAll(options) {
+    const limit = options?.limit || 100;
+    const rows = await dbAll(
+      this.db,
+      `SELECT * FROM consolidated_memories
+       ORDER BY confidence DESC, created_at DESC
+       LIMIT ?`,
+      [limit]
+    );
+    return rows.map(this.rowToMemory);
+  }
+  /**
+   * Get recently created memories
+   */
+  async getRecent(options) {
+    const limit = options?.limit || 10;
+    const hours = options?.hours || 24;
+    const rows = await dbAll(
+      this.db,
+      `SELECT * FROM consolidated_memories
+       WHERE created_at > datetime('now', '-${hours} hours')
+       ORDER BY created_at DESC
+       LIMIT ?`,
+      [limit]
+    );
+    return rows.map(this.rowToMemory);
+  }
+  /**
+   * Mark a memory as accessed (tracks usage for importance scoring)
+   */
+  async markAccessed(memoryId) {
+    await dbRun(
+      this.db,
+      `UPDATE consolidated_memories
+       SET accessed_at = CURRENT_TIMESTAMP,
+           access_count = access_count + 1
+       WHERE memory_id = ?`,
+      [memoryId]
+    );
+  }
+  /**
+   * Update confidence score for a memory
+   */
+  async updateConfidence(memoryId, confidence) {
+    await dbRun(
+      this.db,
+      `UPDATE consolidated_memories
+       SET confidence = ?
+       WHERE memory_id = ?`,
+      [confidence, memoryId]
+    );
+  }
+  /**
+   * Delete a consolidated memory
+   */
+  async delete(memoryId) {
+    await dbRun(
+      this.db,
+      `DELETE FROM consolidated_memories WHERE memory_id = ?`,
+      [memoryId]
+    );
+  }
+  /**
+   * Get count of consolidated memories
+   */
+  async count() {
+    const result = await dbAll(
+      this.db,
+      `SELECT COUNT(*) as count FROM consolidated_memories`
+    );
+    return result[0]?.count || 0;
+  }
+  /**
+   * Get most accessed memories (for importance scoring)
+   */
+  async getMostAccessed(limit = 10) {
+    const rows = await dbAll(
+      this.db,
+      `SELECT * FROM consolidated_memories
+       WHERE access_count > 0
+       ORDER BY access_count DESC
+       LIMIT ?`,
+      [limit]
+    );
+    return rows.map(this.rowToMemory);
+  }
+  /**
+   * Get statistics about consolidated memories
+   */
+  async getStats() {
+    const total = await this.count();
+    const avgResult = await dbAll(
+      this.db,
+      `SELECT AVG(confidence) as avg FROM consolidated_memories`
+    );
+    const averageConfidence = avgResult[0]?.avg || 0;
+    const recentResult = await dbAll(
+      this.db,
+      `SELECT COUNT(*) as count FROM consolidated_memories
+       WHERE created_at > datetime('now', '-24 hours')`
+    );
+    const recentCount = recentResult[0]?.count || 0;
+    const allMemories = await this.getAll({ limit: 1e3 });
+    const topicCounts = {};
+    for (const memory of allMemories) {
+      for (const topic of memory.topics) {
+        topicCounts[topic] = (topicCounts[topic] || 0) + 1;
+      }
+    }
+    return {
+      total,
+      averageConfidence,
+      topicCounts,
+      recentCount
+    };
+  }
+  /**
+   * Check if source events are already consolidated
+   */
+  async isAlreadyConsolidated(eventIds) {
+    for (const eventId of eventIds) {
+      const result = await dbAll(
+        this.db,
+        `SELECT COUNT(*) as count FROM consolidated_memories
+         WHERE source_events LIKE ?`,
+        [`%"${eventId}"%`]
+      );
+      if ((result[0]?.count || 0) > 0)
+        return true;
+    }
+    return false;
+  }
+  /**
+   * Get the last consolidation time
+   */
+  async getLastConsolidationTime() {
+    const result = await dbAll(
+      this.db,
+      `SELECT created_at FROM consolidated_memories
+       ORDER BY created_at DESC
+       LIMIT 1`
+    );
+    if (result.length === 0)
+      return null;
+    return new Date(result[0].created_at);
+  }
+  /**
+   * Convert database row to ConsolidatedMemory
+   */
+  rowToMemory(row) {
+    return {
+      memoryId: row.memory_id,
+      summary: row.summary,
+      topics: JSON.parse(row.topics || "[]"),
+      sourceEvents: JSON.parse(row.source_events || "[]"),
+      confidence: row.confidence,
+      createdAt: toDate(row.created_at),
+      accessedAt: row.accessed_at ? toDate(row.accessed_at) : void 0,
+      accessCount: row.access_count || 0
+    };
+  }
+};
+function createConsolidatedStore(eventStore) {
+  return new ConsolidatedStore(eventStore);
+}
+
+// src/core/consolidation-worker.ts
+var ConsolidationWorker = class {
+  constructor(workingSetStore, consolidatedStore, config) {
+    this.workingSetStore = workingSetStore;
+    this.consolidatedStore = consolidatedStore;
+    this.config = config;
+  }
+  running = false;
+  timeout = null;
+  lastActivity = /* @__PURE__ */ new Date();
+  /**
+   * Start the consolidation worker
+   */
+  start() {
+    if (this.running)
+      return;
+    this.running = true;
+    this.scheduleNext();
+  }
+  /**
+   * Stop the consolidation worker
+   */
+  stop() {
+    this.running = false;
+    if (this.timeout) {
+      clearTimeout(this.timeout);
+      this.timeout = null;
+    }
+  }
+  /**
+   * Record activity (resets idle timer)
+   */
+  recordActivity() {
+    this.lastActivity = /* @__PURE__ */ new Date();
+  }
+  /**
+   * Check if currently running
+   */
+  isRunning() {
+    return this.running;
+  }
+  /**
+   * Force a consolidation run (manual trigger)
+   */
+  async forceRun() {
+    return await this.consolidate();
+  }
+  /**
+   * Schedule the next consolidation check
+   */
+  scheduleNext() {
+    if (!this.running)
+      return;
+    this.timeout = setTimeout(
+      () => this.run(),
+      this.config.consolidation.triggerIntervalMs
+    );
+  }
+  /**
+   * Run consolidation check
+   */
+  async run() {
+    if (!this.running)
+      return;
+    try {
+      await this.checkAndConsolidate();
+    } catch (error) {
+      console.error("Consolidation error:", error);
+    }
+    this.scheduleNext();
+  }
+  /**
+   * Check conditions and consolidate if needed
+   */
+  async checkAndConsolidate() {
+    const workingSet = await this.workingSetStore.get();
+    if (!this.shouldConsolidate(workingSet)) {
+      return;
+    }
+    await this.consolidate();
+  }
+  /**
+   * Perform consolidation
+   */
+  async consolidate() {
+    const workingSet = await this.workingSetStore.get();
+    if (workingSet.recentEvents.length < 3) {
+      return 0;
+    }
+    const groups = this.groupByTopic(workingSet.recentEvents);
+    let consolidatedCount = 0;
+    for (const group of groups) {
+      if (group.events.length < 3)
+        continue;
+      const eventIds = group.events.map((e) => e.id);
+      const alreadyConsolidated = await this.consolidatedStore.isAlreadyConsolidated(eventIds);
+      if (alreadyConsolidated)
+        continue;
+      const summary = await this.summarize(group);
+      await this.consolidatedStore.create({
+        summary,
+        topics: group.topics,
+        sourceEvents: eventIds,
+        confidence: this.calculateConfidence(group)
+      });
+      consolidatedCount++;
+    }
+    if (consolidatedCount > 0) {
+      const consolidatedEventIds = groups.filter((g) => g.events.length >= 3).flatMap((g) => g.events.map((e) => e.id));
+      const oldEventIds = consolidatedEventIds.filter((id) => {
+        const event = workingSet.recentEvents.find((e) => e.id === id);
+        if (!event)
+          return false;
+        const ageHours = (Date.now() - event.timestamp.getTime()) / (1e3 * 60 * 60);
+        return ageHours > this.config.workingSet.timeWindowHours / 2;
+      });
+      if (oldEventIds.length > 0) {
+        await this.workingSetStore.prune(oldEventIds);
+      }
+    }
+    return consolidatedCount;
+  }
+  /**
+   * Check if consolidation should run
+   */
+  shouldConsolidate(workingSet) {
+    if (workingSet.recentEvents.length >= this.config.consolidation.triggerEventCount) {
+      return true;
+    }
+    const idleTime = Date.now() - this.lastActivity.getTime();
+    if (idleTime >= this.config.consolidation.triggerIdleMs) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Group events by topic using simple keyword extraction
+   */
+  groupByTopic(events) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const event of events) {
+      const topics = this.extractTopics(event.content);
+      for (const topic of topics) {
+        if (!groups.has(topic)) {
+          groups.set(topic, { topics: [topic], events: [] });
+        }
+        const group = groups.get(topic);
+        if (!group.events.find((e) => e.id === event.id)) {
+          group.events.push(event);
+        }
+      }
+    }
+    const mergedGroups = this.mergeOverlappingGroups(Array.from(groups.values()));
+    return mergedGroups;
+  }
+  /**
+   * Extract topics from content using simple keyword extraction
+   */
+  extractTopics(content) {
+    const topics = [];
+    const codePatterns = [
+      /\b(function|class|interface|type|const|let|var)\s+(\w+)/gi,
+      /\b(import|export)\s+.*?from\s+['"]([^'"]+)['"]/gi,
+      /\bfile[:\s]+([^\s,]+)/gi
+    ];
+    for (const pattern of codePatterns) {
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        const keyword = match[2] || match[1];
+        if (keyword && keyword.length > 2) {
+          topics.push(keyword.toLowerCase());
+        }
+      }
+    }
+    const commonTerms = [
+      "bug",
+      "fix",
+      "error",
+      "issue",
+      "feature",
+      "test",
+      "refactor",
+      "implement",
+      "add",
+      "remove",
+      "update",
+      "change",
+      "modify",
+      "create",
+      "delete"
+    ];
+    const contentLower = content.toLowerCase();
+    for (const term of commonTerms) {
+      if (contentLower.includes(term)) {
+        topics.push(term);
+      }
+    }
+    return [...new Set(topics)].slice(0, 5);
+  }
+  /**
+   * Merge groups that have significant event overlap
+   */
+  mergeOverlappingGroups(groups) {
+    const merged = [];
+    for (const group of groups) {
+      let foundMerge = false;
+      for (const existing of merged) {
+        const overlap = group.events.filter(
+          (e) => existing.events.some((ex) => ex.id === e.id)
+        );
+        if (overlap.length > group.events.length / 2) {
+          existing.topics = [.../* @__PURE__ */ new Set([...existing.topics, ...group.topics])];
+          for (const event of group.events) {
+            if (!existing.events.find((e) => e.id === event.id)) {
+              existing.events.push(event);
+            }
+          }
+          foundMerge = true;
+          break;
+        }
+      }
+      if (!foundMerge) {
+        merged.push(group);
+      }
+    }
+    return merged;
+  }
+  /**
+   * Generate summary for a group of events
+   * Rule-based extraction (no LLM by default)
+   */
+  async summarize(group) {
+    if (this.config.consolidation.useLLMSummarization) {
+      return this.ruleBasedSummary(group);
+    }
+    return this.ruleBasedSummary(group);
+  }
+  /**
+   * Rule-based summary generation
+   */
+  ruleBasedSummary(group) {
+    const keyPoints = [];
+    for (const event of group.events.slice(0, 10)) {
+      const keyPoint = this.extractKeyPoint(event.content);
+      if (keyPoint) {
+        keyPoints.push(keyPoint);
+      }
+    }
+    const topicsStr = group.topics.slice(0, 3).join(", ");
+    const summary = [
+      `Topics: ${topicsStr}`,
+      "",
+      "Key points:",
+      ...keyPoints.map((kp) => `- ${kp}`)
+    ].join("\n");
+    return summary;
+  }
+  /**
+   * Extract key point from content
+   */
+  extractKeyPoint(content) {
+    const sentences = content.split(/[.!?\n]+/).filter((s) => s.trim().length > 10);
+    if (sentences.length === 0)
+      return null;
+    const firstSentence = sentences[0].trim();
+    if (firstSentence.length > 100) {
+      return firstSentence.slice(0, 100) + "...";
+    }
+    return firstSentence;
+  }
+  /**
+   * Calculate confidence score for a group
+   */
+  calculateConfidence(group) {
+    const eventScore = Math.min(group.events.length / 10, 1);
+    const timeScore = this.calculateTimeProximity(group.events);
+    const topicScore = Math.min(3 / group.topics.length, 1);
+    return eventScore * 0.4 + timeScore * 0.4 + topicScore * 0.2;
+  }
+  /**
+   * Calculate time proximity score
+   */
+  calculateTimeProximity(events) {
+    if (events.length < 2)
+      return 1;
+    const timestamps = events.map((e) => e.timestamp.getTime()).sort((a, b) => a - b);
+    const timeSpan = timestamps[timestamps.length - 1] - timestamps[0];
+    const avgGap = timeSpan / (events.length - 1);
+    const hourInMs = 60 * 60 * 1e3;
+    return Math.max(0, 1 - avgGap / (24 * hourInMs));
+  }
+};
+function createConsolidationWorker(workingSetStore, consolidatedStore, config) {
+  return new ConsolidationWorker(workingSetStore, consolidatedStore, config);
+}
+
+// src/core/continuity-manager.ts
+import { randomUUID as randomUUID6 } from "crypto";
+var ContinuityManager = class {
+  constructor(eventStore, config) {
+    this.eventStore = eventStore;
+    this.config = config;
+  }
+  lastContext = null;
+  get db() {
+    return this.eventStore.getDatabase();
+  }
+  /**
+   * Calculate continuity score between current and previous context
+   */
+  async calculateScore(currentContext, previousContext) {
+    const prev = previousContext || this.lastContext;
+    if (!prev) {
+      this.lastContext = currentContext;
+      return { score: 0.5, transitionType: "break" };
+    }
+    let score = 0;
+    const topicOverlap = this.calculateOverlap(
+      currentContext.topics,
+      prev.topics
+    );
+    score += topicOverlap * 0.3;
+    const fileOverlap = this.calculateOverlap(
+      currentContext.files,
+      prev.files
+    );
+    score += fileOverlap * 0.2;
+    const timeDiff = currentContext.timestamp - prev.timestamp;
+    const decayHours = this.config.continuity.topicDecayHours;
+    const timeScore = Math.exp(-timeDiff / (decayHours * 36e5));
+    score += timeScore * 0.3;
+    const entityOverlap = this.calculateOverlap(
+      currentContext.entities,
+      prev.entities
+    );
+    score += entityOverlap * 0.2;
+    const transitionType = this.determineTransitionType(score);
+    await this.logTransition(currentContext, prev, score, transitionType);
+    this.lastContext = currentContext;
+    return { score, transitionType };
+  }
+  /**
+   * Create a context snapshot from current state
+   */
+  createSnapshot(id, content, metadata) {
+    return {
+      id,
+      timestamp: Date.now(),
+      topics: this.extractTopics(content),
+      files: metadata?.files || this.extractFiles(content),
+      entities: metadata?.entities || this.extractEntities(content)
+    };
+  }
+  /**
+   * Get recent continuity logs
+   */
+  async getRecentLogs(limit = 10) {
+    const rows = await dbAll(
+      this.db,
+      `SELECT * FROM continuity_log
+       ORDER BY created_at DESC
+       LIMIT ?`,
+      [limit]
+    );
+    return rows.map((row) => ({
+      logId: row.log_id,
+      fromContextId: row.from_context_id,
+      toContextId: row.to_context_id,
+      continuityScore: row.continuity_score,
+      transitionType: row.transition_type,
+      createdAt: toDate(row.created_at)
+    }));
+  }
+  /**
+   * Get average continuity score over time period
+   */
+  async getAverageScore(hours = 1) {
+    const result = await dbAll(
+      this.db,
+      `SELECT AVG(continuity_score) as avg_score
+       FROM continuity_log
+       WHERE created_at > datetime('now', '-${hours} hours')`
+    );
+    return result[0]?.avg_score ?? 0.5;
+  }
+  /**
+   * Get transition type distribution
+   */
+  async getTransitionStats(hours = 24) {
+    const rows = await dbAll(
+      this.db,
+      `SELECT transition_type, COUNT(*) as count
+       FROM continuity_log
+       WHERE created_at > datetime('now', '-${hours} hours')
+       GROUP BY transition_type`
+    );
+    const stats = {
+      seamless: 0,
+      topic_shift: 0,
+      break: 0
+    };
+    for (const row of rows) {
+      stats[row.transition_type] = row.count;
+    }
+    return stats;
+  }
+  /**
+   * Clear old continuity logs
+   */
+  async cleanup(olderThanDays = 7) {
+    const result = await dbAll(
+      this.db,
+      `DELETE FROM continuity_log
+       WHERE created_at < datetime('now', '-${olderThanDays} days')
+       RETURNING COUNT(*) as changes`
+    );
+    return result[0]?.changes || 0;
+  }
+  /**
+   * Calculate overlap between two arrays
+   */
+  calculateOverlap(a, b) {
+    if (a.length === 0 || b.length === 0)
+      return 0;
+    const setA = new Set(a.map((s) => s.toLowerCase()));
+    const setB = new Set(b.map((s) => s.toLowerCase()));
+    const intersection = [...setA].filter((x) => setB.has(x));
+    const union = /* @__PURE__ */ new Set([...setA, ...setB]);
+    return intersection.length / union.size;
+  }
+  /**
+   * Determine transition type based on score
+   */
+  determineTransitionType(score) {
+    if (score >= this.config.continuity.minScoreForSeamless) {
+      return "seamless";
+    } else if (score >= 0.4) {
+      return "topic_shift";
+    } else {
+      return "break";
+    }
+  }
+  /**
+   * Log a context transition
+   */
+  async logTransition(current, previous, score, type) {
+    await dbRun(
+      this.db,
+      `INSERT INTO continuity_log
+        (log_id, from_context_id, to_context_id, continuity_score, transition_type, created_at)
+       VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)`,
+      [randomUUID6(), previous.id, current.id, score, type]
+    );
+  }
+  /**
+   * Extract topics from content
+   */
+  extractTopics(content) {
+    const topics = [];
+    const contentLower = content.toLowerCase();
+    const langPatterns = [
+      { pattern: /typescript|\.ts\b/i, topic: "typescript" },
+      { pattern: /javascript|\.js\b/i, topic: "javascript" },
+      { pattern: /python|\.py\b/i, topic: "python" },
+      { pattern: /rust|\.rs\b/i, topic: "rust" },
+      { pattern: /go\b|golang/i, topic: "go" }
+    ];
+    for (const { pattern, topic } of langPatterns) {
+      if (pattern.test(content)) {
+        topics.push(topic);
+      }
+    }
+    const devTopics = [
+      "api",
+      "database",
+      "test",
+      "bug",
+      "feature",
+      "refactor",
+      "component",
+      "function",
+      "class",
+      "module",
+      "hook",
+      "deploy",
+      "build",
+      "config",
+      "docker",
+      "git"
+    ];
+    for (const topic of devTopics) {
+      if (contentLower.includes(topic)) {
+        topics.push(topic);
+      }
+    }
+    return [...new Set(topics)].slice(0, 10);
+  }
+  /**
+   * Extract file paths from content
+   */
+  extractFiles(content) {
+    const filePatterns = [
+      /(?:^|\s)([a-zA-Z0-9_\-./]+\.[a-zA-Z0-9]+)(?:\s|$|:)/gm,
+      /['"](\.?\/[^'"]+\.[a-zA-Z0-9]+)['"]/g,
+      /file[:\s]+([^\s,]+)/gi
+    ];
+    const files = /* @__PURE__ */ new Set();
+    for (const pattern of filePatterns) {
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        const file = match[1];
+        if (file && file.length > 3 && file.length < 100) {
+          if (!file.match(/^(https?:|mailto:|ftp:)/i)) {
+            files.add(file);
+          }
+        }
+      }
+    }
+    return Array.from(files).slice(0, 10);
+  }
+  /**
+   * Extract entity names from content (functions, classes, variables)
+   */
+  extractEntities(content) {
+    const entities = /* @__PURE__ */ new Set();
+    const entityPatterns = [
+      /\b(function|const|let|var|class|interface|type)\s+([a-zA-Z_][a-zA-Z0-9_]*)/g,
+      /\b([A-Z][a-zA-Z0-9_]*(?:Component|Service|Store|Manager|Handler|Factory|Provider))\b/g,
+      /\b(use[A-Z][a-zA-Z0-9_]*)\b/g
+      // React hooks
+    ];
+    for (const pattern of entityPatterns) {
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        const entity = match[2] || match[1];
+        if (entity && entity.length > 2) {
+          entities.add(entity);
+        }
+      }
+    }
+    return Array.from(entities).slice(0, 20);
+  }
+  /**
+   * Reset the last context (for testing or manual reset)
+   */
+  resetLastContext() {
+    this.lastContext = null;
+  }
+  /**
+   * Get the last context snapshot
+   */
+  getLastContext() {
+    return this.lastContext;
+  }
+};
+function createContinuityManager(eventStore, config) {
+  return new ContinuityManager(eventStore, config);
+}
+
+// src/services/memory-service.ts
+function normalizePath(projectPath) {
+  const expanded = projectPath.startsWith("~") ? path.join(os.homedir(), projectPath.slice(1)) : projectPath;
+  try {
+    return fs.realpathSync(expanded);
+  } catch {
+    return path.resolve(expanded);
+  }
+}
+function hashProjectPath(projectPath) {
+  const normalizedPath = normalizePath(projectPath);
+  return crypto2.createHash("sha256").update(normalizedPath).digest("hex").slice(0, 8);
+}
+function getProjectStoragePath(projectPath) {
+  const hash = hashProjectPath(projectPath);
+  return path.join(os.homedir(), ".claude-code", "memory", "projects", hash);
+}
+var REGISTRY_PATH = path.join(os.homedir(), ".claude-code", "memory", "session-registry.json");
+var SHARED_STORAGE_PATH = path.join(os.homedir(), ".claude-code", "memory", "shared");
+var MemoryService = class {
+  eventStore;
+  vectorStore;
+  embedder;
+  matcher;
+  retriever;
+  graduation;
+  vectorWorker = null;
+  initialized = false;
+  // Endless Mode components
+  workingSetStore = null;
+  consolidatedStore = null;
+  consolidationWorker = null;
+  continuityManager = null;
+  endlessMode = "session";
+  // Shared Store components (cross-project knowledge)
+  sharedEventStore = null;
+  sharedStore = null;
+  sharedVectorStore = null;
+  sharedPromoter = null;
+  sharedStoreConfig = null;
+  projectHash = null;
+  constructor(config) {
+    const storagePath = this.expandPath(config.storagePath);
+    if (!fs.existsSync(storagePath)) {
+      fs.mkdirSync(storagePath, { recursive: true });
+    }
+    this.projectHash = config.projectHash || null;
+    this.sharedStoreConfig = config.sharedStoreConfig ?? { enabled: true };
+    this.eventStore = new EventStore(path.join(storagePath, "events.duckdb"));
+    this.vectorStore = new VectorStore(path.join(storagePath, "vectors"));
+    this.embedder = config.embeddingModel ? new Embedder(config.embeddingModel) : getDefaultEmbedder();
+    this.matcher = getDefaultMatcher();
+    this.retriever = createRetriever(
+      this.eventStore,
+      this.vectorStore,
+      this.embedder,
+      this.matcher
+    );
+    this.graduation = createGraduationPipeline(this.eventStore);
+  }
+  /**
+   * Initialize all components
+   */
+  async initialize() {
+    if (this.initialized)
+      return;
+    await this.eventStore.initialize();
+    await this.vectorStore.initialize();
+    await this.embedder.initialize();
+    this.vectorWorker = createVectorWorker(
+      this.eventStore,
+      this.vectorStore,
+      this.embedder
+    );
+    this.vectorWorker.start();
+    const savedMode = await this.eventStore.getEndlessConfig("mode");
+    if (savedMode === "endless") {
+      this.endlessMode = "endless";
+      await this.initializeEndlessMode();
+    }
+    if (this.sharedStoreConfig?.enabled !== false) {
+      await this.initializeSharedStore();
+    }
+    this.initialized = true;
+  }
+  /**
+   * Initialize Shared Store components
+   */
+  async initializeSharedStore() {
+    const sharedPath = this.sharedStoreConfig?.sharedStoragePath ? this.expandPath(this.sharedStoreConfig.sharedStoragePath) : SHARED_STORAGE_PATH;
+    if (!fs.existsSync(sharedPath)) {
+      fs.mkdirSync(sharedPath, { recursive: true });
+    }
+    this.sharedEventStore = createSharedEventStore(
+      path.join(sharedPath, "shared.duckdb")
+    );
+    await this.sharedEventStore.initialize();
+    this.sharedStore = createSharedStore(this.sharedEventStore);
+    this.sharedVectorStore = createSharedVectorStore(
+      path.join(sharedPath, "vectors")
+    );
+    await this.sharedVectorStore.initialize();
+    this.sharedPromoter = createSharedPromoter(
+      this.sharedStore,
+      this.sharedVectorStore,
+      this.embedder,
+      this.sharedStoreConfig || void 0
+    );
+    this.retriever.setSharedStores(this.sharedStore, this.sharedVectorStore);
+  }
+  /**
+   * Start a new session
+   */
+  async startSession(sessionId, projectPath) {
+    await this.initialize();
+    await this.eventStore.upsertSession({
+      id: sessionId,
+      startedAt: /* @__PURE__ */ new Date(),
+      projectPath
+    });
+  }
+  /**
+   * End a session
+   */
+  async endSession(sessionId, summary) {
+    await this.initialize();
+    await this.eventStore.upsertSession({
+      id: sessionId,
+      endedAt: /* @__PURE__ */ new Date(),
+      summary
+    });
+  }
+  /**
+   * Store a user prompt
+   */
+  async storeUserPrompt(sessionId, content, metadata) {
+    await this.initialize();
+    const result = await this.eventStore.append({
+      eventType: "user_prompt",
+      sessionId,
+      timestamp: /* @__PURE__ */ new Date(),
+      content,
+      metadata
+    });
+    if (result.success && !result.isDuplicate) {
+      await this.eventStore.enqueueForEmbedding(result.eventId, content);
+    }
+    return result;
+  }
+  /**
+   * Store an agent response
+   */
+  async storeAgentResponse(sessionId, content, metadata) {
+    await this.initialize();
+    const result = await this.eventStore.append({
+      eventType: "agent_response",
+      sessionId,
+      timestamp: /* @__PURE__ */ new Date(),
+      content,
+      metadata
+    });
+    if (result.success && !result.isDuplicate) {
+      await this.eventStore.enqueueForEmbedding(result.eventId, content);
+    }
+    return result;
+  }
+  /**
+   * Store a session summary
+   */
+  async storeSessionSummary(sessionId, summary) {
+    await this.initialize();
+    const result = await this.eventStore.append({
+      eventType: "session_summary",
+      sessionId,
+      timestamp: /* @__PURE__ */ new Date(),
+      content: summary
+    });
+    if (result.success && !result.isDuplicate) {
+      await this.eventStore.enqueueForEmbedding(result.eventId, summary);
+    }
+    return result;
+  }
+  /**
+   * Store a tool observation
+   */
+  async storeToolObservation(sessionId, payload) {
+    await this.initialize();
+    const content = JSON.stringify(payload);
+    const result = await this.eventStore.append({
+      eventType: "tool_observation",
+      sessionId,
+      timestamp: /* @__PURE__ */ new Date(),
+      content,
+      metadata: {
+        toolName: payload.toolName,
+        success: payload.success
+      }
+    });
+    if (result.success && !result.isDuplicate) {
+      const embeddingContent = createToolObservationEmbedding(
+        payload.toolName,
+        payload.metadata || {},
+        payload.success
+      );
+      await this.eventStore.enqueueForEmbedding(result.eventId, embeddingContent);
+    }
+    return result;
+  }
+  /**
+   * Retrieve relevant memories for a query
+   */
+  async retrieveMemories(query, options) {
+    await this.initialize();
+    if (this.vectorWorker) {
+      await this.vectorWorker.processAll();
+    }
+    if (options?.includeShared && this.sharedStore) {
+      return this.retriever.retrieveUnified(query, {
+        ...options,
+        includeShared: true,
+        projectHash: this.projectHash || void 0
+      });
+    }
+    return this.retriever.retrieve(query, options);
+  }
+  /**
+   * Get session history
+   */
+  async getSessionHistory(sessionId) {
+    await this.initialize();
+    return this.eventStore.getSessionEvents(sessionId);
+  }
+  /**
+   * Get recent events
+   */
+  async getRecentEvents(limit = 100) {
+    await this.initialize();
+    return this.eventStore.getRecentEvents(limit);
+  }
+  /**
+   * Get memory statistics
+   */
+  async getStats() {
+    await this.initialize();
+    const recentEvents = await this.eventStore.getRecentEvents(1e4);
+    const vectorCount = await this.vectorStore.count();
+    const levelStats = await this.graduation.getStats();
+    return {
+      totalEvents: recentEvents.length,
+      vectorCount,
+      levelStats
+    };
+  }
+  /**
+   * Process pending embeddings
+   */
+  async processPendingEmbeddings() {
+    if (this.vectorWorker) {
+      return this.vectorWorker.processAll();
+    }
+    return 0;
+  }
+  /**
+   * Format retrieval results as context for Claude
+   */
+  formatAsContext(result) {
+    if (!result.context) {
+      return "";
+    }
+    const confidence = result.matchResult.confidence;
+    let header = "";
+    if (confidence === "high") {
+      header = "\u{1F3AF} **High-confidence memory match found:**\n\n";
+    } else if (confidence === "suggested") {
+      header = "\u{1F4A1} **Suggested memories (may be relevant):**\n\n";
+    }
+    return header + result.context;
+  }
+  // ============================================================
+  // Shared Store Methods (Cross-Project Knowledge)
+  // ============================================================
+  /**
+   * Check if shared store is enabled and initialized
+   */
+  isSharedStoreEnabled() {
+    return this.sharedStore !== null;
+  }
+  /**
+   * Promote an entry to shared storage
+   */
+  async promoteToShared(entry) {
+    if (!this.sharedPromoter || !this.projectHash) {
+      return {
+        success: false,
+        error: "Shared store not initialized or project hash not set"
+      };
+    }
+    return this.sharedPromoter.promoteEntry(entry, this.projectHash);
+  }
+  /**
+   * Get shared store statistics
+   */
+  async getSharedStoreStats() {
+    if (!this.sharedStore)
+      return null;
+    return this.sharedStore.getStats();
+  }
+  /**
+   * Search shared troubleshooting entries
+   */
+  async searchShared(query, options) {
+    if (!this.sharedStore)
+      return [];
+    return this.sharedStore.search(query, options);
+  }
+  /**
+   * Get project hash for this service
+   */
+  getProjectHash() {
+    return this.projectHash;
+  }
+  // ============================================================
+  // Endless Mode Methods
+  // ============================================================
+  /**
+   * Get the default endless mode config
+   */
+  getDefaultEndlessConfig() {
+    return {
+      enabled: true,
+      workingSet: {
+        maxEvents: 100,
+        timeWindowHours: 24,
+        minRelevanceScore: 0.5
+      },
+      consolidation: {
+        triggerIntervalMs: 36e5,
+        // 1 hour
+        triggerEventCount: 100,
+        triggerIdleMs: 18e5,
+        // 30 minutes
+        useLLMSummarization: false
+      },
+      continuity: {
+        minScoreForSeamless: 0.7,
+        topicDecayHours: 48
+      }
+    };
+  }
+  /**
+   * Initialize Endless Mode components
+   */
+  async initializeEndlessMode() {
+    const config = await this.getEndlessConfig();
+    this.workingSetStore = createWorkingSetStore(this.eventStore, config);
+    this.consolidatedStore = createConsolidatedStore(this.eventStore);
+    this.consolidationWorker = createConsolidationWorker(
+      this.workingSetStore,
+      this.consolidatedStore,
+      config
+    );
+    this.continuityManager = createContinuityManager(this.eventStore, config);
+    this.consolidationWorker.start();
+  }
+  /**
+   * Get Endless Mode configuration
+   */
+  async getEndlessConfig() {
+    const savedConfig = await this.eventStore.getEndlessConfig("config");
+    return savedConfig || this.getDefaultEndlessConfig();
+  }
+  /**
+   * Set Endless Mode configuration
+   */
+  async setEndlessConfig(config) {
+    const current = await this.getEndlessConfig();
+    const merged = { ...current, ...config };
+    await this.eventStore.setEndlessConfig("config", merged);
+  }
+  /**
+   * Set memory mode (session or endless)
+   */
+  async setMode(mode) {
+    await this.initialize();
+    if (mode === this.endlessMode)
+      return;
+    this.endlessMode = mode;
+    await this.eventStore.setEndlessConfig("mode", mode);
+    if (mode === "endless") {
+      await this.initializeEndlessMode();
+    } else {
+      if (this.consolidationWorker) {
+        this.consolidationWorker.stop();
+        this.consolidationWorker = null;
+      }
+      this.workingSetStore = null;
+      this.consolidatedStore = null;
+      this.continuityManager = null;
+    }
+  }
+  /**
+   * Get current memory mode
+   */
+  getMode() {
+    return this.endlessMode;
+  }
+  /**
+   * Check if endless mode is active
+   */
+  isEndlessModeActive() {
+    return this.endlessMode === "endless";
+  }
+  /**
+   * Add event to Working Set (Endless Mode)
+   */
+  async addToWorkingSet(eventId, relevanceScore) {
+    if (!this.workingSetStore)
+      return;
+    await this.workingSetStore.add(eventId, relevanceScore);
+  }
+  /**
+   * Get the current Working Set
+   */
+  async getWorkingSet() {
+    if (!this.workingSetStore)
+      return null;
+    return this.workingSetStore.get();
+  }
+  /**
+   * Search consolidated memories
+   */
+  async searchConsolidated(query, options) {
+    if (!this.consolidatedStore)
+      return [];
+    return this.consolidatedStore.search(query, options);
+  }
+  /**
+   * Get all consolidated memories
+   */
+  async getConsolidatedMemories(limit) {
+    if (!this.consolidatedStore)
+      return [];
+    return this.consolidatedStore.getAll({ limit });
+  }
+  /**
+   * Calculate continuity score for current context
+   */
+  async calculateContinuity(content, metadata) {
+    if (!this.continuityManager)
+      return null;
+    const snapshot = this.continuityManager.createSnapshot(
+      crypto2.randomUUID(),
+      content,
+      metadata
+    );
+    return this.continuityManager.calculateScore(snapshot);
+  }
+  /**
+   * Record activity (for consolidation idle trigger)
+   */
+  recordActivity() {
+    if (this.consolidationWorker) {
+      this.consolidationWorker.recordActivity();
+    }
+  }
+  /**
+   * Force a consolidation run
+   */
+  async forceConsolidation() {
+    if (!this.consolidationWorker)
+      return 0;
+    return this.consolidationWorker.forceRun();
+  }
+  /**
+   * Get Endless Mode status
+   */
+  async getEndlessModeStatus() {
+    await this.initialize();
+    let workingSetSize = 0;
+    let continuityScore = 0.5;
+    let consolidatedCount = 0;
+    let lastConsolidation = null;
+    if (this.workingSetStore) {
+      workingSetSize = await this.workingSetStore.count();
+      const workingSet = await this.workingSetStore.get();
+      continuityScore = workingSet.continuityScore;
+    }
+    if (this.consolidatedStore) {
+      consolidatedCount = await this.consolidatedStore.count();
+      lastConsolidation = await this.consolidatedStore.getLastConsolidationTime();
+    }
+    return {
+      mode: this.endlessMode,
+      workingSetSize,
+      continuityScore,
+      consolidatedCount,
+      lastConsolidation
+    };
+  }
+  /**
+   * Format Endless Mode context for Claude
+   */
+  async formatEndlessContext(query) {
+    if (!this.isEndlessModeActive()) {
+      return "";
+    }
+    const workingSet = await this.getWorkingSet();
+    const consolidated = await this.searchConsolidated(query, { topK: 3 });
+    const continuity = await this.calculateContinuity(query);
+    const parts = [];
+    if (continuity) {
+      const statusEmoji = continuity.transitionType === "seamless" ? "\u{1F517}" : continuity.transitionType === "topic_shift" ? "\u21AA\uFE0F" : "\u{1F195}";
+      parts.push(`${statusEmoji} Context: ${continuity.transitionType} (score: ${continuity.score.toFixed(2)})`);
+    }
+    if (workingSet && workingSet.recentEvents.length > 0) {
+      parts.push("\n## Recent Context (Working Set)");
+      const recent = workingSet.recentEvents.slice(0, 5);
+      for (const event of recent) {
+        const preview = event.content.slice(0, 80) + (event.content.length > 80 ? "..." : "");
+        const time = event.timestamp.toLocaleTimeString();
+        parts.push(`- ${time} [${event.eventType}] ${preview}`);
+      }
+    }
+    if (consolidated.length > 0) {
+      parts.push("\n## Related Knowledge (Consolidated)");
+      for (const memory of consolidated) {
+        parts.push(`- ${memory.topics.slice(0, 3).join(", ")}: ${memory.summary.slice(0, 100)}...`);
+      }
+    }
+    return parts.join("\n");
+  }
+  /**
+   * Shutdown service
+   */
+  async shutdown() {
+    if (this.consolidationWorker) {
+      this.consolidationWorker.stop();
+    }
+    if (this.vectorWorker) {
+      this.vectorWorker.stop();
+    }
+    if (this.sharedEventStore) {
+      await this.sharedEventStore.close();
+    }
+    await this.eventStore.close();
+  }
+  /**
+   * Expand ~ to home directory
+   */
+  expandPath(p) {
+    if (p.startsWith("~")) {
+      return path.join(os.homedir(), p.slice(1));
+    }
+    return p;
+  }
+};
+var serviceCache = /* @__PURE__ */ new Map();
+var GLOBAL_KEY = "__global__";
+function getDefaultMemoryService() {
+  if (!serviceCache.has(GLOBAL_KEY)) {
+    serviceCache.set(GLOBAL_KEY, new MemoryService({
+      storagePath: "~/.claude-code/memory"
+    }));
+  }
+  return serviceCache.get(GLOBAL_KEY);
+}
+function getMemoryServiceForProject(projectPath, sharedStoreConfig) {
+  const hash = hashProjectPath(projectPath);
+  if (!serviceCache.has(hash)) {
+    const storagePath = getProjectStoragePath(projectPath);
+    serviceCache.set(hash, new MemoryService({
+      storagePath,
+      projectHash: hash,
+      sharedStoreConfig
+    }));
+  }
+  return serviceCache.get(hash);
+}
+
+// src/server/api/sessions.ts
+var sessionsRouter = new Hono();
+sessionsRouter.get("/", async (c) => {
+  const page = parseInt(c.req.query("page") || "1", 10);
+  const pageSize = parseInt(c.req.query("pageSize") || "20", 10);
+  try {
+    const memoryService = getDefaultMemoryService();
+    await memoryService.initialize();
+    const recentEvents = await memoryService.getRecentEvents(1e3);
+    const sessionMap = /* @__PURE__ */ new Map();
+    for (const event of recentEvents) {
+      const existing = sessionMap.get(event.sessionId);
+      if (!existing) {
+        sessionMap.set(event.sessionId, {
+          id: event.sessionId,
+          startedAt: event.timestamp,
+          eventCount: 1,
+          lastEventAt: event.timestamp
+        });
+      } else {
+        existing.eventCount++;
+        if (event.timestamp < existing.startedAt) {
+          existing.startedAt = event.timestamp;
+        }
+        if (event.timestamp > existing.lastEventAt) {
+          existing.lastEventAt = event.timestamp;
+        }
+      }
+    }
+    const sessions = Array.from(sessionMap.values()).sort((a, b) => b.lastEventAt.getTime() - a.lastEventAt.getTime());
+    const total = sessions.length;
+    const start = (page - 1) * pageSize;
+    const end = start + pageSize;
+    const paginatedSessions = sessions.slice(start, end);
+    return c.json({
+      sessions: paginatedSessions,
+      total,
+      page,
+      pageSize,
+      hasMore: end < total
+    });
+  } catch (error) {
+    return c.json({ error: error.message }, 500);
+  }
+});
+sessionsRouter.get("/:id", async (c) => {
+  const { id } = c.req.param();
+  try {
+    const memoryService = getDefaultMemoryService();
+    await memoryService.initialize();
+    const events = await memoryService.getSessionHistory(id);
+    if (events.length === 0) {
+      return c.json({ error: "Session not found" }, 404);
+    }
+    const session = {
+      id,
+      startedAt: events[0].timestamp,
+      endedAt: events[events.length - 1].timestamp,
+      eventCount: events.length
+    };
+    const eventsByType = {
+      user_prompt: events.filter((e) => e.eventType === "user_prompt").length,
+      agent_response: events.filter((e) => e.eventType === "agent_response").length,
+      tool_observation: events.filter((e) => e.eventType === "tool_observation").length
+    };
+    return c.json({
+      session,
+      events: events.slice(0, 100).map((e) => ({
+        id: e.id,
+        eventType: e.eventType,
+        timestamp: e.timestamp,
+        preview: e.content.slice(0, 200) + (e.content.length > 200 ? "..." : "")
+      })),
+      stats: eventsByType
+    });
+  } catch (error) {
+    return c.json({ error: error.message }, 500);
+  }
+});
+
+// src/server/api/events.ts
+import { Hono as Hono2 } from "hono";
+var eventsRouter = new Hono2();
+eventsRouter.get("/", async (c) => {
+  const sessionId = c.req.query("sessionId");
+  const eventType = c.req.query("type");
+  const limit = parseInt(c.req.query("limit") || "100", 10);
+  const offset = parseInt(c.req.query("offset") || "0", 10);
+  try {
+    const memoryService = getDefaultMemoryService();
+    await memoryService.initialize();
+    let events = await memoryService.getRecentEvents(limit + offset + 1e3);
+    if (sessionId) {
+      events = events.filter((e) => e.sessionId === sessionId);
+    }
+    if (eventType) {
+      events = events.filter((e) => e.eventType === eventType);
+    }
+    const total = events.length;
+    events = events.slice(offset, offset + limit);
+    return c.json({
+      events: events.map((e) => ({
+        id: e.id,
+        eventType: e.eventType,
+        timestamp: e.timestamp,
+        sessionId: e.sessionId,
+        preview: e.content.slice(0, 200) + (e.content.length > 200 ? "..." : ""),
+        contentLength: e.content.length
+      })),
+      total,
+      limit,
+      offset,
+      hasMore: offset + limit < total
+    });
+  } catch (error) {
+    return c.json({ error: error.message }, 500);
+  }
+});
+eventsRouter.get("/:id", async (c) => {
+  const { id } = c.req.param();
+  try {
+    const memoryService = getDefaultMemoryService();
+    await memoryService.initialize();
+    const recentEvents = await memoryService.getRecentEvents(1e4);
+    const event = recentEvents.find((e) => e.id === id);
+    if (!event) {
+      return c.json({ error: "Event not found" }, 404);
+    }
+    const sessionEvents = recentEvents.filter((e) => e.sessionId === event.sessionId).sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    const eventIndex = sessionEvents.findIndex((e) => e.id === id);
+    const start = Math.max(0, eventIndex - 2);
+    const end = Math.min(sessionEvents.length, eventIndex + 3);
+    const context = sessionEvents.slice(start, end).filter((e) => e.id !== id);
+    return c.json({
+      event: {
+        id: event.id,
+        eventType: event.eventType,
+        timestamp: event.timestamp,
+        sessionId: event.sessionId,
+        content: event.content,
+        metadata: event.metadata
+      },
+      context: context.map((e) => ({
+        id: e.id,
+        eventType: e.eventType,
+        timestamp: e.timestamp,
+        preview: e.content.slice(0, 100) + (e.content.length > 100 ? "..." : "")
+      }))
+    });
+  } catch (error) {
+    return c.json({ error: error.message }, 500);
+  }
+});
+
+// src/server/api/search.ts
+import { Hono as Hono3 } from "hono";
+var searchRouter = new Hono3();
+searchRouter.post("/", async (c) => {
+  try {
+    const body = await c.req.json();
+    if (!body.query) {
+      return c.json({ error: "Query is required" }, 400);
+    }
+    const memoryService = getDefaultMemoryService();
+    await memoryService.initialize();
+    const startTime = Date.now();
+    const result = await memoryService.retrieveMemories(body.query, {
+      topK: body.options?.topK ?? 10,
+      minScore: body.options?.minScore ?? 0.7,
+      sessionId: body.options?.sessionId
+    });
+    const searchTime = Date.now() - startTime;
+    return c.json({
+      results: result.memories.map((m) => ({
+        id: m.event.id,
+        eventType: m.event.eventType,
+        timestamp: m.event.timestamp,
+        sessionId: m.event.sessionId,
+        score: m.score,
+        content: m.event.content,
+        preview: m.event.content.slice(0, 200) + (m.event.content.length > 200 ? "..." : ""),
+        context: m.sessionContext
+      })),
+      meta: {
+        totalMatches: result.memories.length,
+        searchTime,
+        confidence: result.matchResult.confidence,
+        totalTokens: result.totalTokens
+      }
+    });
+  } catch (error) {
+    return c.json({ error: error.message }, 500);
+  }
+});
+searchRouter.get("/", async (c) => {
+  const query = c.req.query("q");
+  if (!query) {
+    return c.json({ error: 'Query parameter "q" is required' }, 400);
+  }
+  const topK = parseInt(c.req.query("topK") || "5", 10);
+  try {
+    const memoryService = getDefaultMemoryService();
+    await memoryService.initialize();
+    const result = await memoryService.retrieveMemories(query, { topK });
+    return c.json({
+      results: result.memories.map((m) => ({
+        id: m.event.id,
+        eventType: m.event.eventType,
+        timestamp: m.event.timestamp,
+        score: m.score,
+        preview: m.event.content.slice(0, 200) + (m.event.content.length > 200 ? "..." : "")
+      })),
+      meta: {
+        totalMatches: result.memories.length,
+        confidence: result.matchResult.confidence
+      }
+    });
+  } catch (error) {
+    return c.json({ error: error.message }, 500);
+  }
+});
+
+// src/server/api/stats.ts
+import { Hono as Hono4 } from "hono";
+var statsRouter = new Hono4();
+statsRouter.get("/shared", async (c) => {
+  try {
+    const memoryService = getDefaultMemoryService();
+    await memoryService.initialize();
+    const sharedStats = await memoryService.getSharedStoreStats();
+    return c.json({
+      troubleshooting: sharedStats?.troubleshooting || 0,
+      bestPractices: sharedStats?.bestPractices || 0,
+      commonErrors: sharedStats?.commonErrors || 0,
+      totalUsageCount: sharedStats?.totalUsageCount || 0,
+      lastUpdated: sharedStats?.lastUpdated || null
+    });
+  } catch (error) {
+    return c.json({
+      troubleshooting: 0,
+      bestPractices: 0,
+      commonErrors: 0,
+      totalUsageCount: 0,
+      lastUpdated: null
+    });
+  }
+});
+statsRouter.get("/endless", async (c) => {
+  try {
+    const projectPath = c.req.query("project") || process.cwd();
+    const memoryService = getMemoryServiceForProject(projectPath);
+    await memoryService.initialize();
+    const status = await memoryService.getEndlessModeStatus();
+    return c.json({
+      mode: status.mode,
+      continuityScore: status.continuityScore,
+      workingSetSize: status.workingSetSize,
+      consolidatedCount: status.consolidatedCount,
+      lastConsolidation: status.lastConsolidation?.toISOString() || null
+    });
+  } catch (error) {
+    return c.json({
+      mode: "session",
+      continuityScore: 0,
+      workingSetSize: 0,
+      consolidatedCount: 0,
+      lastConsolidation: null
+    });
+  }
+});
+statsRouter.get("/", async (c) => {
+  try {
+    const memoryService = getDefaultMemoryService();
+    await memoryService.initialize();
+    const stats = await memoryService.getStats();
+    const recentEvents = await memoryService.getRecentEvents(1e4);
+    const eventsByType = recentEvents.reduce((acc, e) => {
+      acc[e.eventType] = (acc[e.eventType] || 0) + 1;
+      return acc;
+    }, {});
+    const uniqueSessions = new Set(recentEvents.map((e) => e.sessionId));
+    const now = /* @__PURE__ */ new Date();
+    const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1e3);
+    const eventsByDay = recentEvents.filter((e) => e.timestamp >= sevenDaysAgo).reduce((acc, e) => {
+      const day = e.timestamp.toISOString().split("T")[0];
+      acc[day] = (acc[day] || 0) + 1;
+      return acc;
+    }, {});
+    return c.json({
+      storage: {
+        eventCount: stats.totalEvents,
+        vectorCount: stats.vectorCount
+      },
+      sessions: {
+        total: uniqueSessions.size
+      },
+      eventsByType,
+      activity: {
+        daily: eventsByDay,
+        total7Days: recentEvents.filter((e) => e.timestamp >= sevenDaysAgo).length
+      },
+      memory: {
+        heapUsed: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),
+        heapTotal: Math.round(process.memoryUsage().heapTotal / 1024 / 1024)
+      },
+      levelStats: stats.levelStats
+    });
+  } catch (error) {
+    return c.json({ error: error.message }, 500);
+  }
+});
+statsRouter.get("/timeline", async (c) => {
+  const days = parseInt(c.req.query("days") || "7", 10);
+  try {
+    const memoryService = getDefaultMemoryService();
+    await memoryService.initialize();
+    const recentEvents = await memoryService.getRecentEvents(1e4);
+    const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1e3);
+    const filteredEvents = recentEvents.filter((e) => e.timestamp >= cutoff);
+    const daily = filteredEvents.reduce((acc, e) => {
+      const day = e.timestamp.toISOString().split("T")[0];
+      if (!acc[day]) {
+        acc[day] = { date: day, total: 0, prompts: 0, responses: 0, tools: 0 };
+      }
+      acc[day].total++;
+      if (e.eventType === "user_prompt")
+        acc[day].prompts++;
+      if (e.eventType === "agent_response")
+        acc[day].responses++;
+      if (e.eventType === "tool_observation")
+        acc[day].tools++;
+      return acc;
+    }, {});
+    return c.json({
+      days,
+      daily: Object.values(daily).sort((a, b) => a.date.localeCompare(b.date))
+    });
+  } catch (error) {
+    return c.json({ error: error.message }, 500);
+  }
+});
+
+// src/server/api/citations.ts
+import { Hono as Hono5 } from "hono";
+
+// src/core/citation-generator.ts
+import { createHash as createHash3 } from "crypto";
+var ID_LENGTH = 6;
+var CHARSET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+function generateCitationId(eventId) {
+  const hash = createHash3("sha256").update(eventId).digest();
+  let id = "";
+  for (let i = 0; i < ID_LENGTH; i++) {
+    id += CHARSET[hash[i] % CHARSET.length];
+  }
+  return id;
+}
+function parseCitationId(formatted) {
+  const match = formatted.match(/\[?mem:([A-Za-z0-9]{6})\]?/);
+  return match ? match[1] : null;
+}
+
+// src/server/api/citations.ts
+var citationsRouter = new Hono5();
+citationsRouter.get("/:id", async (c) => {
+  const { id } = c.req.param();
+  const citationId = parseCitationId(id) || id;
+  try {
+    const memoryService = getDefaultMemoryService();
+    await memoryService.initialize();
+    const recentEvents = await memoryService.getRecentEvents(1e4);
+    const event = recentEvents.find((e) => {
+      const eventCitationId = generateCitationId(e.id);
+      return eventCitationId === citationId;
+    });
+    if (!event) {
+      return c.json({ error: "Citation not found" }, 404);
+    }
+    return c.json({
+      citation: {
+        id: citationId,
+        eventId: event.id
+      },
+      event: {
+        id: event.id,
+        eventType: event.eventType,
+        timestamp: event.timestamp,
+        sessionId: event.sessionId,
+        content: event.content,
+        metadata: event.metadata
+      }
+    });
+  } catch (error) {
+    return c.json({ error: error.message }, 500);
+  }
+});
+citationsRouter.get("/:id/related", async (c) => {
+  const { id } = c.req.param();
+  const citationId = parseCitationId(id) || id;
+  try {
+    const memoryService = getDefaultMemoryService();
+    await memoryService.initialize();
+    const recentEvents = await memoryService.getRecentEvents(1e4);
+    const event = recentEvents.find((e) => {
+      const eventCitationId = generateCitationId(e.id);
+      return eventCitationId === citationId;
+    });
+    if (!event) {
+      return c.json({ error: "Citation not found" }, 404);
+    }
+    const sessionEvents = recentEvents.filter((e) => e.sessionId === event.sessionId).sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    const eventIndex = sessionEvents.findIndex((e) => e.id === event.id);
+    const prev = eventIndex > 0 ? sessionEvents[eventIndex - 1] : null;
+    const next = eventIndex < sessionEvents.length - 1 ? sessionEvents[eventIndex + 1] : null;
+    return c.json({
+      previous: prev ? {
+        citationId: generateCitationId(prev.id),
+        eventType: prev.eventType,
+        timestamp: prev.timestamp,
+        preview: prev.content.slice(0, 100) + (prev.content.length > 100 ? "..." : "")
+      } : null,
+      next: next ? {
+        citationId: generateCitationId(next.id),
+        eventType: next.eventType,
+        timestamp: next.timestamp,
+        preview: next.content.slice(0, 100) + (next.content.length > 100 ? "..." : "")
+      } : null
+    });
+  } catch (error) {
+    return c.json({ error: error.message }, 500);
+  }
+});
+
+// src/server/api/index.ts
+var apiRouter = new Hono6().route("/sessions", sessionsRouter).route("/events", eventsRouter).route("/search", searchRouter).route("/stats", statsRouter).route("/citations", citationsRouter);
+export {
+  apiRouter
+};
+//# sourceMappingURL=index.js.map