claude-memory-layer 1.0.0

package/dist/hooks/user-prompt-submit.js

@@ -0,0 +1,2960 @@
+#!/usr/bin/env node
+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/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 { Database } from "duckdb";
+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/event-store.ts
+var EventStore = class {
+  constructor(dbPath) {
+    this.dbPath = dbPath;
+    this.db = new Database(dbPath);
+  }
+  db;
+  initialized = false;
+  /**
+   * Initialize database schema
+   */
+  async initialize() {
+    if (this.initialized)
+      return;
+    await this.db.run(`
+      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 this.db.run(`
+      CREATE TABLE IF NOT EXISTS event_dedup (
+        dedupe_key VARCHAR PRIMARY KEY,
+        event_id VARCHAR NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await this.db.run(`
+      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 this.db.run(`
+      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 this.db.run(`
+      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 this.db.run(`
+      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 this.db.run(`
+      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 this.db.run(`
+      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 this.db.run(`
+      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 this.db.run(`
+      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 this.db.run(`
+      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 this.db.run(`
+      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 this.db.run(`
+      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 this.db.run(`
+      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 this.db.run(`
+      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 this.db.run(`
+      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 this.db.run(`
+      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 this.db.run(`
+      CREATE TABLE IF NOT EXISTS endless_config (
+        key VARCHAR PRIMARY KEY,
+        value JSON,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await this.db.run(`CREATE INDEX IF NOT EXISTS idx_entries_type ON entries(entry_type)`);
+    await this.db.run(`CREATE INDEX IF NOT EXISTS idx_entries_stage ON entries(stage)`);
+    await this.db.run(`CREATE INDEX IF NOT EXISTS idx_entries_canonical ON entries(canonical_key)`);
+    await this.db.run(`CREATE INDEX IF NOT EXISTS idx_entities_type_key ON entities(entity_type, canonical_key)`);
+    await this.db.run(`CREATE INDEX IF NOT EXISTS idx_entities_status ON entities(status)`);
+    await this.db.run(`CREATE INDEX IF NOT EXISTS idx_edges_src ON edges(src_id, rel_type)`);
+    await this.db.run(`CREATE INDEX IF NOT EXISTS idx_edges_dst ON edges(dst_id, rel_type)`);
+    await this.db.run(`CREATE INDEX IF NOT EXISTS idx_edges_rel ON edges(rel_type)`);
+    await this.db.run(`CREATE INDEX IF NOT EXISTS idx_outbox_status ON vector_outbox(status)`);
+    await this.db.run(`CREATE INDEX IF NOT EXISTS idx_working_set_expires ON working_set(expires_at)`);
+    await this.db.run(`CREATE INDEX IF NOT EXISTS idx_working_set_relevance ON working_set(relevance_score DESC)`);
+    await this.db.run(`CREATE INDEX IF NOT EXISTS idx_consolidated_confidence ON consolidated_memories(confidence DESC)`);
+    await this.db.run(`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 this.db.all(
+      `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 this.db.run(
+        `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 this.db.run(
+        `INSERT INTO event_dedup (dedupe_key, event_id) VALUES (?, ?)`,
+        [dedupeKey, id]
+      );
+      await this.db.run(
+        `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 this.db.all(
+      `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 this.db.all(
+      `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 this.db.all(
+      `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 this.db.all(
+      `SELECT id FROM sessions WHERE id = ?`,
+      [session.id]
+    );
+    if (existing.length === 0) {
+      await this.db.run(
+        `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 this.db.run(
+          `UPDATE sessions SET ${updates.join(", ")} WHERE id = ?`,
+          values
+        );
+      }
+    }
+  }
+  /**
+   * Get session by ID
+   */
+  async getSession(id) {
+    await this.initialize();
+    const rows = await this.db.all(
+      `SELECT * FROM sessions WHERE id = ?`,
+      [id]
+    );
+    if (rows.length === 0)
+      return null;
+    const row = rows[0];
+    return {
+      id: row.id,
+      startedAt: new Date(row.started_at),
+      endedAt: row.ended_at ? new Date(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 this.db.run(
+      `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 rows = await this.db.all(
+      `UPDATE embedding_outbox
+       SET status = 'processing'
+       WHERE id IN (
+         SELECT id FROM embedding_outbox
+         WHERE status = 'pending'
+         ORDER BY created_at
+         LIMIT ?
+       )
+       RETURNING *`,
+      [limit]
+    );
+    return rows.map((row) => ({
+      id: row.id,
+      eventId: row.event_id,
+      content: row.content,
+      status: row.status,
+      retryCount: row.retry_count,
+      createdAt: new Date(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 this.db.run(
+      `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 this.db.run(
+      `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 this.db.run(
+      `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 this.db.all(
+      `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 this.db.all(
+      `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 this.db.run(
+      `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 this.db.all(
+      `SELECT * FROM sessions ORDER BY started_at DESC`
+    );
+    return rows.map((row) => ({
+      id: row.id,
+      startedAt: new Date(row.started_at),
+      endedAt: row.ended_at ? new Date(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 this.db.close();
+  }
+  /**
+   * Convert database row to MemoryEvent
+   */
+  rowToEvent(row) {
+    return {
+      id: row.id,
+      eventType: row.event_type,
+      sessionId: row.session_id,
+      timestamp: new Date(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).limit(limit * 2);
+    if (sessionId) {
+      query = query.where(`sessionId = '${sessionId}'`);
+    }
+    const results = await query.toArray();
+    return results.filter((r) => {
+      const score = 1 - (r._distance || 0);
+      return score >= minScore;
+    }).slice(0, limit).map((r) => ({
+      id: r.id,
+      eventId: r.eventId,
+      content: r.content,
+      score: 1 - (r._distance || 0),
+      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;
+  constructor(eventStore, vectorStore, embedder, matcher) {
+    this.eventStore = eventStore;
+    this.vectorStore = vectorStore;
+    this.embedder = embedder;
+    this.matcher = matcher;
+  }
+  /**
+   * 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 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/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 randomUUID2 } 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 this.db.run(
+      `INSERT OR REPLACE INTO working_set (id, event_id, added_at, relevance_score, topics, expires_at)
+       VALUES (?, ?, CURRENT_TIMESTAMP, ?, ?, ?)`,
+      [
+        randomUUID2(),
+        eventId,
+        relevanceScore,
+        JSON.stringify(topics || []),
+        expiresAt.toISOString()
+      ]
+    );
+    await this.enforceLimit();
+  }
+  /**
+   * Get the current working set
+   */
+  async get() {
+    await this.cleanup();
+    const rows = await this.db.all(
+      `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: new Date(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 this.db.all(
+      `SELECT * FROM working_set ORDER BY relevance_score DESC, added_at DESC`
+    );
+    return rows.map((row) => ({
+      id: row.id,
+      eventId: row.event_id,
+      addedAt: new Date(row.added_at),
+      relevanceScore: row.relevance_score,
+      topics: row.topics ? JSON.parse(row.topics) : void 0,
+      expiresAt: new Date(row.expires_at)
+    }));
+  }
+  /**
+   * Update relevance score for an event
+   */
+  async updateRelevance(eventId, score) {
+    await this.db.run(
+      `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 this.db.run(
+      `DELETE FROM working_set WHERE event_id IN (${placeholders})`,
+      eventIds
+    );
+  }
+  /**
+   * Get the count of items in working set
+   */
+  async count() {
+    const result = await this.db.all(
+      `SELECT COUNT(*) as count FROM working_set`
+    );
+    return result[0]?.count || 0;
+  }
+  /**
+   * Clear the entire working set
+   */
+  async clear() {
+    await this.db.run(`DELETE FROM working_set`);
+  }
+  /**
+   * Check if an event is in the working set
+   */
+  async contains(eventId) {
+    const result = await this.db.all(
+      `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 this.db.run(
+      `UPDATE working_set SET expires_at = ? WHERE event_id = ?`,
+      [newExpiresAt.toISOString(), eventId]
+    );
+  }
+  /**
+   * Clean up expired items
+   */
+  async cleanup() {
+    await this.db.run(
+      `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 this.db.all(
+      `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 this.db.run(
+      `DELETE FROM working_set WHERE id NOT IN (${placeholders})`,
+      keepIdList
+    );
+  }
+  /**
+   * Calculate continuity score based on recent context transitions
+   */
+  async calculateContinuityScore() {
+    const result = await this.db.all(
+      `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 this.db.all(
+      `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 randomUUID3 } 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 = randomUUID3();
+    await this.db.run(
+      `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 this.db.all(
+      `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 this.db.all(
+      `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 this.db.all(
+      `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 this.db.all(
+      `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 this.db.all(
+      `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 this.db.run(
+      `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 this.db.run(
+      `UPDATE consolidated_memories
+       SET confidence = ?
+       WHERE memory_id = ?`,
+      [confidence, memoryId]
+    );
+  }
+  /**
+   * Delete a consolidated memory
+   */
+  async delete(memoryId) {
+    await this.db.run(
+      `DELETE FROM consolidated_memories WHERE memory_id = ?`,
+      [memoryId]
+    );
+  }
+  /**
+   * Get count of consolidated memories
+   */
+  async count() {
+    const result = await this.db.all(
+      `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 this.db.all(
+      `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 this.db.all(
+      `SELECT AVG(confidence) as avg FROM consolidated_memories`
+    );
+    const averageConfidence = avgResult[0]?.avg || 0;
+    const recentResult = await this.db.all(
+      `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 this.db.all(
+        `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 this.db.all(
+      `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: new Date(row.created_at),
+      accessedAt: row.accessed_at ? new Date(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 randomUUID4 } 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 this.db.all(
+      `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: new Date(row.created_at)
+    }));
+  }
+  /**
+   * Get average continuity score over time period
+   */
+  async getAverageScore(hours = 1) {
+    const result = await this.db.all(
+      `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 this.db.all(
+      `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 this.db.all(
+      `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 this.db.run(
+      `INSERT INTO continuity_log
+        (log_id, from_context_id, to_context_id, continuity_score, transition_type, created_at)
+       VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)`,
+      [randomUUID4(), 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
+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";
+  constructor(config) {
+    const storagePath = this.expandPath(config.storagePath);
+    if (!fs.existsSync(storagePath)) {
+      fs.mkdirSync(storagePath, { recursive: 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();
+    }
+    this.initialized = true;
+  }
+  /**
+   * 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();
+    }
+    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;
+  }
+  // ============================================================
+  // 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();
+    }
+    await this.eventStore.close();
+  }
+  /**
+   * Expand ~ to home directory
+   */
+  expandPath(p) {
+    if (p.startsWith("~")) {
+      return path.join(os.homedir(), p.slice(1));
+    }
+    return p;
+  }
+};
+var defaultService = null;
+function getDefaultMemoryService() {
+  if (!defaultService) {
+    defaultService = new MemoryService({
+      storagePath: "~/.claude-code/memory"
+    });
+  }
+  return defaultService;
+}
+
+// src/hooks/user-prompt-submit.ts
+async function main() {
+  const inputData = await readStdin();
+  const input = JSON.parse(inputData);
+  const memoryService = getDefaultMemoryService();
+  try {
+    const retrievalResult = await memoryService.retrieveMemories(input.prompt, {
+      topK: 5,
+      minScore: 0.7
+    });
+    await memoryService.storeUserPrompt(
+      input.session_id,
+      input.prompt
+    );
+    const context = memoryService.formatAsContext(retrievalResult);
+    const output = { context };
+    console.log(JSON.stringify(output));
+  } catch (error) {
+    console.error("Memory hook error:", error);
+    console.log(JSON.stringify({ context: "" }));
+  }
+}
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => {
+      resolve(data);
+    });
+  });
+}
+main().catch(console.error);
+//# sourceMappingURL=user-prompt-submit.js.map