kiro-memory 1.9.0 → 3.0.0

package/plugin/dist/services/sqlite/index.js

@@ -4,14 +4,15 @@ import { createRequire } from 'module';const require = createRequire(import.meta
 import BetterSqlite3 from "better-sqlite3";
 var Database = class {
   _db;
+  _stmtCache = /* @__PURE__ */ new Map();
   constructor(path, options) {
     this._db = new BetterSqlite3(path, {
-      // better-sqlite3 crea il file di default (non serve 'create')
+      // better-sqlite3 creates the file by default ('create' not needed)
       readonly: options?.readwrite === false ? true : false
     });
   }
   /**
-   * Esegui una query SQL senza risultati
+   * Execute a SQL query without results
    */
   run(sql, params) {
     const stmt = this._db.prepare(sql);
@@ -19,51 +20,53 @@ var Database = class {
     return result;
   }
   /**
-   * Prepara una query con interfaccia compatibile bun:sqlite
+   * Prepare a query with bun:sqlite-compatible interface.
+   * Returns a cached prepared statement for repeated queries.
    */
   query(sql) {
-    return new BunQueryCompat(this._db, sql);
+    let cached = this._stmtCache.get(sql);
+    if (!cached) {
+      cached = new BunQueryCompat(this._db, sql);
+      this._stmtCache.set(sql, cached);
+    }
+    return cached;
   }
   /**
-   * Crea una transazione
+   * Create a transaction
    */
   transaction(fn) {
     return this._db.transaction(fn);
   }
   /**
-   * Chiudi la connessione
+   * Close the connection
    */
   close() {
+    this._stmtCache.clear();
     this._db.close();
   }
 };
 var BunQueryCompat = class {
-  _db;
-  _sql;
+  _stmt;
   constructor(db, sql) {
-    this._db = db;
-    this._sql = sql;
+    this._stmt = db.prepare(sql);
   }
   /**
-   * Restituisce tutte le righe
+   * Returns all rows
    */
   all(...params) {
-    const stmt = this._db.prepare(this._sql);
-    return params.length > 0 ? stmt.all(...params) : stmt.all();
+    return params.length > 0 ? this._stmt.all(...params) : this._stmt.all();
   }
   /**
-   * Restituisce la prima riga o null
+   * Returns the first row or null
    */
   get(...params) {
-    const stmt = this._db.prepare(this._sql);
-    return params.length > 0 ? stmt.get(...params) : stmt.get();
+    return params.length > 0 ? this._stmt.get(...params) : this._stmt.get();
   }
   /**
-   * Esegui senza risultati
+   * Execute without results
    */
   run(...params) {
-    const stmt = this._db.prepare(this._sql);
-    return params.length > 0 ? stmt.run(...params) : stmt.run();
+    return params.length > 0 ? this._stmt.run(...params) : this._stmt.run();
   }
 };
 
@@ -324,150 +327,63 @@ function ensureDir(dirPath) {
 // src/services/sqlite/Database.ts
 var SQLITE_MMAP_SIZE_BYTES = 256 * 1024 * 1024;
 var SQLITE_CACHE_SIZE_PAGES = 1e4;
-var dbInstance = null;
 var KiroMemoryDatabase = class {
-  db;
+  _db;
   /**
-   * @param dbPath - Percorso al file SQLite (default: DB_PATH)
-   * @param skipMigrations - Se true, salta il migration runner (per hook ad alta frequenza)
+   * Readonly accessor for the underlying Database instance.
+   * Prefer using query() and run() proxy methods directly.
+   */
+  get db() {
+    return this._db;
+  }
+  /**
+   * @param dbPath - Path to the SQLite file (default: DB_PATH)
+   * @param skipMigrations - If true, skip the migration runner (for high-frequency hooks)
    */
   constructor(dbPath = DB_PATH, skipMigrations = false) {
     if (dbPath !== ":memory:") {
       ensureDir(DATA_DIR);
     }
-    this.db = new Database(dbPath, { create: true, readwrite: true });
-    this.db.run("PRAGMA journal_mode = WAL");
-    this.db.run("PRAGMA synchronous = NORMAL");
-    this.db.run("PRAGMA foreign_keys = ON");
-    this.db.run("PRAGMA temp_store = memory");
-    this.db.run(`PRAGMA mmap_size = ${SQLITE_MMAP_SIZE_BYTES}`);
-    this.db.run(`PRAGMA cache_size = ${SQLITE_CACHE_SIZE_PAGES}`);
+    this._db = new Database(dbPath, { create: true, readwrite: true });
+    this._db.run("PRAGMA journal_mode = WAL");
+    this._db.run("PRAGMA busy_timeout = 5000");
+    this._db.run("PRAGMA synchronous = NORMAL");
+    this._db.run("PRAGMA foreign_keys = ON");
+    this._db.run("PRAGMA temp_store = memory");
+    this._db.run(`PRAGMA mmap_size = ${SQLITE_MMAP_SIZE_BYTES}`);
+    this._db.run(`PRAGMA cache_size = ${SQLITE_CACHE_SIZE_PAGES}`);
     if (!skipMigrations) {
-      const migrationRunner = new MigrationRunner(this.db);
+      const migrationRunner = new MigrationRunner(this._db);
       migrationRunner.runAllMigrations();
     }
   }
   /**
-   * Esegue una funzione all'interno di una transazione atomica.
-   * Se fn() lancia un errore, la transazione viene annullata automaticamente.
-   */
-  withTransaction(fn) {
-    const transaction = this.db.transaction(fn);
-    return transaction(this.db);
-  }
-  /**
-   * Close the database connection
+   * Prepare a query (delegates to underlying Database).
+   * Proxy method to avoid ctx.db.db.query() double access.
    */
-  close() {
-    this.db.close();
-  }
-};
-var DatabaseManager = class _DatabaseManager {
-  static instance;
-  db = null;
-  migrations = [];
-  static getInstance() {
-    if (!_DatabaseManager.instance) {
-      _DatabaseManager.instance = new _DatabaseManager();
-    }
-    return _DatabaseManager.instance;
-  }
-  /**
-   * Register a migration to be run during initialization
-   */
-  registerMigration(migration) {
-    this.migrations.push(migration);
-    this.migrations.sort((a, b) => a.version - b.version);
-  }
-  /**
-   * Initialize database connection with optimized settings
-   */
-  async initialize() {
-    if (this.db) {
-      return this.db;
-    }
-    ensureDir(DATA_DIR);
-    this.db = new Database(DB_PATH, { create: true, readwrite: true });
-    this.db.run("PRAGMA journal_mode = WAL");
-    this.db.run("PRAGMA synchronous = NORMAL");
-    this.db.run("PRAGMA foreign_keys = ON");
-    this.db.run("PRAGMA temp_store = memory");
-    this.db.run(`PRAGMA mmap_size = ${SQLITE_MMAP_SIZE_BYTES}`);
-    this.db.run(`PRAGMA cache_size = ${SQLITE_CACHE_SIZE_PAGES}`);
-    this.initializeSchemaVersions();
-    await this.runMigrations();
-    dbInstance = this.db;
-    return this.db;
+  query(sql) {
+    return this._db.query(sql);
   }
   /**
-   * Get the current database connection
+   * Execute a SQL statement without results (delegates to underlying Database).
+   * Proxy method to avoid ctx.db.db.run() double access.
    */
-  getConnection() {
-    if (!this.db) {
-      throw new Error("Database not initialized. Call initialize() first.");
-    }
-    return this.db;
+  run(sql, params) {
+    return this._db.run(sql, params);
   }
   /**
-   * Execute a function within a transaction
+   * Executes a function within an atomic transaction.
+   * If fn() throws an error, the transaction is automatically rolled back.
    */
   withTransaction(fn) {
-    const db = this.getConnection();
-    const transaction = db.transaction(fn);
-    return transaction(db);
+    const transaction = this._db.transaction(fn);
+    return transaction(this._db);
   }
   /**
    * Close the database connection
    */
   close() {
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-      dbInstance = null;
-    }
-  }
-  /**
-   * Initialize the schema_versions table
-   */
-  initializeSchemaVersions() {
-    if (!this.db) return;
-    this.db.run(`
-      CREATE TABLE IF NOT EXISTS schema_versions (
-        id INTEGER PRIMARY KEY,
-        version INTEGER UNIQUE NOT NULL,
-        applied_at TEXT NOT NULL
-      )
-    `);
-  }
-  /**
-   * Run all pending migrations
-   */
-  async runMigrations() {
-    if (!this.db) return;
-    const query = this.db.query("SELECT version FROM schema_versions ORDER BY version");
-    const appliedVersions = query.all().map((row) => row.version);
-    const maxApplied = appliedVersions.length > 0 ? Math.max(...appliedVersions) : 0;
-    for (const migration of this.migrations) {
-      if (migration.version > maxApplied) {
-        logger.info("DB", `Applying migration ${migration.version}`);
-        const transaction = this.db.transaction(() => {
-          migration.up(this.db);
-          const insertQuery = this.db.query("INSERT INTO schema_versions (version, applied_at) VALUES (?, ?)");
-          insertQuery.run(migration.version, (/* @__PURE__ */ new Date()).toISOString());
-        });
-        transaction();
-        logger.info("DB", `Migration ${migration.version} applied successfully`);
-      }
-    }
-  }
-  /**
-   * Get current schema version
-   */
-  getCurrentVersion() {
-    if (!this.db) return 0;
-    const query = this.db.query("SELECT MAX(version) as version FROM schema_versions");
-    const result = query.get();
-    return result?.version || 0;
+    this._db.close();
   }
 };
 var MigrationRunner = class {
@@ -708,19 +624,108 @@ var MigrationRunner = class {
           db.run("CREATE INDEX IF NOT EXISTS idx_summaries_project_epoch ON summaries(project, created_at_epoch DESC)");
           db.run("CREATE INDEX IF NOT EXISTS idx_prompts_project_epoch ON prompts(project, created_at_epoch DESC)");
         }
+      },
+      {
+        version: 10,
+        up: (db) => {
+          db.run(`
+            CREATE TABLE IF NOT EXISTS job_queue (
+              id INTEGER PRIMARY KEY AUTOINCREMENT,
+              type TEXT NOT NULL,
+              status TEXT NOT NULL DEFAULT 'pending',
+              payload TEXT,
+              result TEXT,
+              error TEXT,
+              retry_count INTEGER DEFAULT 0,
+              max_retries INTEGER DEFAULT 3,
+              priority INTEGER DEFAULT 0,
+              created_at TEXT NOT NULL,
+              created_at_epoch INTEGER NOT NULL,
+              started_at_epoch INTEGER,
+              completed_at_epoch INTEGER
+            )
+          `);
+          db.run("CREATE INDEX IF NOT EXISTS idx_jobs_status ON job_queue(status)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_jobs_type ON job_queue(type)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_jobs_priority ON job_queue(status, priority DESC, created_at_epoch ASC)");
+        }
+      },
+      {
+        version: 11,
+        up: (db) => {
+          db.run("ALTER TABLE observations ADD COLUMN auto_category TEXT");
+          db.run("CREATE INDEX IF NOT EXISTS idx_observations_category ON observations(auto_category)");
+        }
+      },
+      {
+        version: 12,
+        up: (db) => {
+          db.run(`
+            CREATE TABLE IF NOT EXISTS github_links (
+              id INTEGER PRIMARY KEY AUTOINCREMENT,
+              observation_id INTEGER,
+              session_id TEXT,
+              repo TEXT NOT NULL,
+              issue_number INTEGER,
+              pr_number INTEGER,
+              event_type TEXT NOT NULL,
+              action TEXT,
+              title TEXT,
+              url TEXT,
+              author TEXT,
+              created_at TEXT NOT NULL,
+              created_at_epoch INTEGER NOT NULL,
+              FOREIGN KEY (observation_id) REFERENCES observations(id)
+            )
+          `);
+          db.run("CREATE INDEX IF NOT EXISTS idx_github_links_repo ON github_links(repo)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_github_links_obs ON github_links(observation_id)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_github_links_event ON github_links(event_type)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_github_links_repo_issue ON github_links(repo, issue_number)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_github_links_repo_pr ON github_links(repo, pr_number)");
+        }
+      },
+      {
+        version: 13,
+        up: (db) => {
+          db.run("CREATE INDEX IF NOT EXISTS idx_observations_keyset ON observations(created_at_epoch DESC, id DESC)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_observations_project_keyset ON observations(project, created_at_epoch DESC, id DESC)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_summaries_keyset ON summaries(created_at_epoch DESC, id DESC)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_summaries_project_keyset ON summaries(project, created_at_epoch DESC, id DESC)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_prompts_keyset ON prompts(created_at_epoch DESC, id DESC)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_prompts_project_keyset ON prompts(project, created_at_epoch DESC, id DESC)");
+        }
       }
     ];
   }
 };
-function getDatabase() {
-  if (!dbInstance) {
-    throw new Error("Database not initialized. Call DatabaseManager.getInstance().initialize() first.");
+
+// src/services/sqlite/cursor.ts
+function encodeCursor(id, epoch) {
+  const raw = `${epoch}:${id}`;
+  return Buffer.from(raw, "utf8").toString("base64url");
+}
+function decodeCursor(cursor) {
+  try {
+    const raw = Buffer.from(cursor, "base64url").toString("utf8");
+    const colonIdx = raw.indexOf(":");
+    if (colonIdx === -1) return null;
+    const epochStr = raw.substring(0, colonIdx);
+    const idStr = raw.substring(colonIdx + 1);
+    const epoch = parseInt(epochStr, 10);
+    const id = parseInt(idStr, 10);
+    if (!Number.isInteger(epoch) || epoch <= 0) return null;
+    if (!Number.isInteger(id) || id <= 0) return null;
+    return { epoch, id };
+  } catch {
+    return null;
   }
-  return dbInstance;
 }
-async function initializeDatabase() {
-  const manager = DatabaseManager.getInstance();
-  return await manager.initialize();
+function buildNextCursor(rows, limit) {
+  if (rows.length < limit) return null;
+  const last = rows[rows.length - 1];
+  if (!last) return null;
+  return encodeCursor(last.id, last.created_at_epoch);
 }
 
 // src/services/sqlite/Sessions.ts
@@ -778,6 +783,278 @@ function getSessionsByProject(db, project, limit = 100) {
   return query.all(project, limit);
 }
 
+// src/utils/secrets.ts
+var SECRET_PATTERNS = [
+  // AWS Access Keys (AKIA, ABIA, ACCA, ASIA prefixes + 16 alphanumeric chars)
+  { name: "aws-key", pattern: /(?:AKIA|ABIA|ACCA|ASIA)[A-Z0-9]{16}/g },
+  // JWT tokens (three base64url segments separated by dots)
+  { name: "jwt", pattern: /eyJ[a-zA-Z0-9_-]{10,}\.eyJ[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}/g },
+  // Generic API keys in key=value or key: value assignments
+  { name: "api-key", pattern: /(?:api[_-]?key|apikey|api[_-]?secret)\s*[:=]\s*['"]?([a-zA-Z0-9_\-]{20,})['"]?/gi },
+  // Password/secret/token in variable assignments
+  { name: "credential", pattern: /(?:password|passwd|pwd|secret|token|auth[_-]?token|access[_-]?token|bearer)\s*[:=]\s*['"]?([^\s'"]{8,})['"]?/gi },
+  // Credentials embedded in URLs (user:pass@host)
+  { name: "url-credential", pattern: /(?:https?:\/\/)([^:]+):([^@]+)@/g },
+  // PEM-encoded private keys (RSA, EC, DSA, OpenSSH)
+  { name: "private-key", pattern: /-----BEGIN (?:RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----/g },
+  // GitHub personal access tokens (ghp_, gho_, ghu_, ghs_, ghr_ prefixes)
+  { name: "github-token", pattern: /gh[pousr]_[a-zA-Z0-9]{36,}/g },
+  // Slack bot/user/app tokens
+  { name: "slack-token", pattern: /xox[bpoas]-[a-zA-Z0-9-]{10,}/g },
+  // HTTP Authorization Bearer header values
+  { name: "bearer-header", pattern: /\bBearer\s+([a-zA-Z0-9_\-\.]{20,})/g },
+  // Generic hex secrets (32+ hex chars after a key/secret/token/password label)
+  { name: "hex-secret", pattern: /(?:key|secret|token|password)\s*[:=]\s*['"]?([0-9a-f]{32,})['"]?/gi }
+];
+function redactSecrets(text) {
+  if (!text) return text;
+  let redacted = text;
+  for (const { pattern } of SECRET_PATTERNS) {
+    pattern.lastIndex = 0;
+    redacted = redacted.replace(pattern, (match) => {
+      const prefix = match.substring(0, Math.min(4, match.length));
+      return `${prefix}***REDACTED***`;
+    });
+  }
+  return redacted;
+}
+
+// src/utils/categorizer.ts
+var CATEGORY_RULES = [
+  {
+    category: "security",
+    keywords: [
+      "security",
+      "vulnerability",
+      "cve",
+      "xss",
+      "csrf",
+      "injection",
+      "sanitize",
+      "escape",
+      "auth",
+      "authentication",
+      "authorization",
+      "permission",
+      "helmet",
+      "cors",
+      "rate-limit",
+      "token",
+      "encrypt",
+      "decrypt",
+      "secret",
+      "redact",
+      "owasp"
+    ],
+    filePatterns: [/security/i, /auth/i, /secrets?\.ts/i],
+    weight: 10
+  },
+  {
+    category: "testing",
+    keywords: [
+      "test",
+      "spec",
+      "expect",
+      "assert",
+      "mock",
+      "stub",
+      "fixture",
+      "coverage",
+      "jest",
+      "vitest",
+      "bun test",
+      "unit test",
+      "integration test",
+      "e2e"
+    ],
+    types: ["test"],
+    filePatterns: [/\.test\./i, /\.spec\./i, /tests?\//i, /__tests__/i],
+    weight: 8
+  },
+  {
+    category: "debugging",
+    keywords: [
+      "debug",
+      "fix",
+      "bug",
+      "error",
+      "crash",
+      "stacktrace",
+      "stack trace",
+      "exception",
+      "breakpoint",
+      "investigate",
+      "root cause",
+      "troubleshoot",
+      "diagnose",
+      "bisect",
+      "regression"
+    ],
+    types: ["bugfix"],
+    weight: 8
+  },
+  {
+    category: "architecture",
+    keywords: [
+      "architect",
+      "design",
+      "pattern",
+      "modular",
+      "migration",
+      "schema",
+      "database",
+      "api design",
+      "abstract",
+      "dependency injection",
+      "singleton",
+      "factory",
+      "observer",
+      "middleware",
+      "pipeline",
+      "microservice",
+      "monolith"
+    ],
+    types: ["decision", "constraint"],
+    weight: 7
+  },
+  {
+    category: "refactoring",
+    keywords: [
+      "refactor",
+      "rename",
+      "extract",
+      "inline",
+      "move",
+      "split",
+      "merge",
+      "simplify",
+      "cleanup",
+      "clean up",
+      "dead code",
+      "consolidate",
+      "reorganize",
+      "restructure",
+      "decouple"
+    ],
+    weight: 6
+  },
+  {
+    category: "config",
+    keywords: [
+      "config",
+      "configuration",
+      "env",
+      "environment",
+      "dotenv",
+      ".env",
+      "settings",
+      "tsconfig",
+      "eslint",
+      "prettier",
+      "webpack",
+      "vite",
+      "esbuild",
+      "docker",
+      "ci/cd",
+      "github actions",
+      "deploy",
+      "build",
+      "bundle",
+      "package.json"
+    ],
+    filePatterns: [
+      /\.config\./i,
+      /\.env/i,
+      /tsconfig/i,
+      /\.ya?ml/i,
+      /Dockerfile/i,
+      /docker-compose/i
+    ],
+    weight: 5
+  },
+  {
+    category: "docs",
+    keywords: [
+      "document",
+      "readme",
+      "changelog",
+      "jsdoc",
+      "comment",
+      "explain",
+      "guide",
+      "tutorial",
+      "api doc",
+      "openapi",
+      "swagger"
+    ],
+    types: ["docs"],
+    filePatterns: [/\.md$/i, /docs?\//i, /readme/i, /changelog/i],
+    weight: 5
+  },
+  {
+    category: "feature-dev",
+    keywords: [
+      "feature",
+      "implement",
+      "add",
+      "create",
+      "new",
+      "endpoint",
+      "component",
+      "module",
+      "service",
+      "handler",
+      "route",
+      "hook",
+      "plugin",
+      "integration"
+    ],
+    types: ["feature", "file-write"],
+    weight: 3
+    // lowest — generic catch-all for development
+  }
+];
+function categorize(input) {
+  const scores = /* @__PURE__ */ new Map();
+  const searchText = [
+    input.title,
+    input.text || "",
+    input.narrative || "",
+    input.concepts || ""
+  ].join(" ").toLowerCase();
+  const allFiles = [input.filesModified || "", input.filesRead || ""].join(",");
+  for (const rule of CATEGORY_RULES) {
+    let score = 0;
+    for (const kw of rule.keywords) {
+      if (searchText.includes(kw.toLowerCase())) {
+        score += rule.weight;
+      }
+    }
+    if (rule.types && rule.types.includes(input.type)) {
+      score += rule.weight * 2;
+    }
+    if (rule.filePatterns && allFiles) {
+      for (const pattern of rule.filePatterns) {
+        if (pattern.test(allFiles)) {
+          score += rule.weight;
+        }
+      }
+    }
+    if (score > 0) {
+      scores.set(rule.category, (scores.get(rule.category) || 0) + score);
+    }
+  }
+  let bestCategory = "general";
+  let bestScore = 0;
+  for (const [category, score] of scores) {
+    if (score > bestScore) {
+      bestScore = score;
+      bestCategory = category;
+    }
+  }
+  return bestCategory;
+}
+
 // src/services/sqlite/Observations.ts
 function escapeLikePattern(input) {
   return input.replace(/[%_\\]/g, "\\$&");
@@ -792,11 +1069,23 @@ function isDuplicateObservation(db, contentHash, windowMs = 3e4) {
 }
 function createObservation(db, memorySessionId, project, type, title, subtitle, text, narrative, facts, concepts, filesRead, filesModified, promptNumber, contentHash = null, discoveryTokens = 0) {
   const now = /* @__PURE__ */ new Date();
+  const safeTitle = redactSecrets(title);
+  const safeText = text ? redactSecrets(text) : text;
+  const safeNarrative = narrative ? redactSecrets(narrative) : narrative;
+  const autoCategory = categorize({
+    type,
+    title: safeTitle,
+    text: safeText,
+    narrative: safeNarrative,
+    concepts,
+    filesModified,
+    filesRead
+  });
   const result = db.run(
     `INSERT INTO observations
-     (memory_session_id, project, type, title, subtitle, text, narrative, facts, concepts, files_read, files_modified, prompt_number, created_at, created_at_epoch, content_hash, discovery_tokens)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-    [memorySessionId, project, type, title, subtitle, text, narrative, facts, concepts, filesRead, filesModified, promptNumber, now.toISOString(), now.getTime(), contentHash, discoveryTokens]
+     (memory_session_id, project, type, title, subtitle, text, narrative, facts, concepts, files_read, files_modified, prompt_number, created_at, created_at_epoch, content_hash, discovery_tokens, auto_category)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [memorySessionId, project, type, safeTitle, subtitle, safeText, safeNarrative, facts, concepts, filesRead, filesModified, promptNumber, now.toISOString(), now.getTime(), contentHash, discoveryTokens, autoCategory]
   );
   return Number(result.lastInsertRowid);
 }
@@ -808,16 +1097,16 @@ function getObservationsBySession(db, memorySessionId) {
 }
 function getObservationsByProject(db, project, limit = 100) {
   const query = db.query(
-    "SELECT * FROM observations WHERE project = ? ORDER BY created_at_epoch DESC LIMIT ?"
+    "SELECT * FROM observations WHERE project = ? ORDER BY created_at_epoch DESC, id DESC LIMIT ?"
   );
   return query.all(project, limit);
 }
 function searchObservations(db, searchTerm, project) {
   const sql = project ? `SELECT * FROM observations
        WHERE project = ? AND (title LIKE ? ESCAPE '\\' OR text LIKE ? ESCAPE '\\' OR narrative LIKE ? ESCAPE '\\')
-       ORDER BY created_at_epoch DESC` : `SELECT * FROM observations
+       ORDER BY created_at_epoch DESC, id DESC` : `SELECT * FROM observations
        WHERE title LIKE ? ESCAPE '\\' OR text LIKE ? ESCAPE '\\' OR narrative LIKE ? ESCAPE '\\'
-       ORDER BY created_at_epoch DESC`;
+       ORDER BY created_at_epoch DESC, id DESC`;
   const pattern = `%${escapeLikePattern(searchTerm)}%`;
   const query = db.query(sql);
   if (project) {
@@ -850,21 +1139,32 @@ function consolidateObservations(db, project, options = {}) {
     ORDER BY cnt DESC
   `).all(project, minGroupSize);
   if (groups.length === 0) return { merged: 0, removed: 0 };
-  let totalMerged = 0;
-  let totalRemoved = 0;
+  if (options.dryRun) {
+    let totalMerged = 0;
+    let totalRemoved = 0;
+    for (const group of groups) {
+      const obsIds = group.ids.split(",").map(Number);
+      const placeholders = obsIds.map(() => "?").join(",");
+      const count = db.query(
+        `SELECT COUNT(*) as cnt FROM observations WHERE id IN (${placeholders})`
+      ).get(...obsIds)?.cnt || 0;
+      if (count >= minGroupSize) {
+        totalMerged += 1;
+        totalRemoved += count - 1;
+      }
+    }
+    return { merged: totalMerged, removed: totalRemoved };
+  }
   const runConsolidation = db.transaction(() => {
+    let merged = 0;
+    let removed = 0;
     for (const group of groups) {
       const obsIds = group.ids.split(",").map(Number);
       const placeholders = obsIds.map(() => "?").join(",");
       const observations = db.query(
-        `SELECT * FROM observations WHERE id IN (${placeholders}) ORDER BY created_at_epoch DESC`
+        `SELECT * FROM observations WHERE id IN (${placeholders}) ORDER BY created_at_epoch DESC, id DESC`
       ).all(...obsIds);
       if (observations.length < minGroupSize) continue;
-      if (options.dryRun) {
-        totalMerged += 1;
-        totalRemoved += observations.length - 1;
-        continue;
-      }
       const keeper = observations[0];
       const others = observations.slice(1);
       const uniqueTexts = /* @__PURE__ */ new Set();
@@ -877,18 +1177,18 @@ function consolidateObservations(db, project, options = {}) {
       const consolidatedText = Array.from(uniqueTexts).join("\n---\n").substring(0, 1e5);
       db.run(
         "UPDATE observations SET text = ?, title = ? WHERE id = ?",
-        [consolidatedText, `[consolidato x${observations.length}] ${keeper.title}`, keeper.id]
+        [consolidatedText, `[consolidated x${observations.length}] ${keeper.title}`, keeper.id]
       );
       const removeIds = others.map((o) => o.id);
       const removePlaceholders = removeIds.map(() => "?").join(",");
       db.run(`DELETE FROM observations WHERE id IN (${removePlaceholders})`, removeIds);
       db.run(`DELETE FROM observation_embeddings WHERE observation_id IN (${removePlaceholders})`, removeIds);
-      totalMerged += 1;
-      totalRemoved += removeIds.length;
+      merged += 1;
+      removed += removeIds.length;
     }
+    return { merged, removed };
   });
-  runConsolidation();
-  return { merged: totalMerged, removed: totalRemoved };
+  return runConsolidation();
 }
 
 // src/services/sqlite/Summaries.ts
@@ -906,21 +1206,21 @@ function createSummary(db, sessionId, project, request, investigated, learned, c
   return Number(result.lastInsertRowid);
 }
 function getSummaryBySession(db, sessionId) {
-  const query = db.query("SELECT * FROM summaries WHERE session_id = ? ORDER BY created_at_epoch DESC LIMIT 1");
+  const query = db.query("SELECT * FROM summaries WHERE session_id = ? ORDER BY created_at_epoch DESC, id DESC LIMIT 1");
   return query.get(sessionId);
 }
 function getSummariesByProject(db, project, limit = 50) {
   const query = db.query(
-    "SELECT * FROM summaries WHERE project = ? ORDER BY created_at_epoch DESC LIMIT ?"
+    "SELECT * FROM summaries WHERE project = ? ORDER BY created_at_epoch DESC, id DESC LIMIT ?"
   );
   return query.all(project, limit);
 }
 function searchSummaries(db, searchTerm, project) {
   const sql = project ? `SELECT * FROM summaries
        WHERE project = ? AND (request LIKE ? ESCAPE '\\' OR learned LIKE ? ESCAPE '\\' OR completed LIKE ? ESCAPE '\\' OR notes LIKE ? ESCAPE '\\')
-       ORDER BY created_at_epoch DESC` : `SELECT * FROM summaries
+       ORDER BY created_at_epoch DESC, id DESC` : `SELECT * FROM summaries
        WHERE request LIKE ? ESCAPE '\\' OR learned LIKE ? ESCAPE '\\' OR completed LIKE ? ESCAPE '\\' OR notes LIKE ? ESCAPE '\\'
-       ORDER BY created_at_epoch DESC`;
+       ORDER BY created_at_epoch DESC, id DESC`;
   const pattern = `%${escapeLikePattern2(searchTerm)}%`;
   const query = db.query(sql);
   if (project) {
@@ -951,7 +1251,7 @@ function getPromptsBySession(db, contentSessionId) {
 }
 function getPromptsByProject(db, project, limit = 100) {
   const query = db.query(
-    "SELECT * FROM prompts WHERE project = ? ORDER BY created_at_epoch DESC LIMIT ?"
+    "SELECT * FROM prompts WHERE project = ? ORDER BY created_at_epoch DESC, id DESC LIMIT ?"
   );
   return query.all(project, limit);
 }
@@ -988,19 +1288,19 @@ function createCheckpoint(db, sessionId, project, data) {
 }
 function getLatestCheckpoint(db, sessionId) {
   const query = db.query(
-    "SELECT * FROM checkpoints WHERE session_id = ? ORDER BY created_at_epoch DESC LIMIT 1"
+    "SELECT * FROM checkpoints WHERE session_id = ? ORDER BY created_at_epoch DESC, id DESC LIMIT 1"
   );
   return query.get(sessionId);
 }
 function getLatestCheckpointByProject(db, project) {
   const query = db.query(
-    "SELECT * FROM checkpoints WHERE project = ? ORDER BY created_at_epoch DESC LIMIT 1"
+    "SELECT * FROM checkpoints WHERE project = ? ORDER BY created_at_epoch DESC, id DESC LIMIT 1"
   );
   return query.get(project);
 }
 function getCheckpointsBySession(db, sessionId) {
   const query = db.query(
-    "SELECT * FROM checkpoints WHERE session_id = ? ORDER BY created_at_epoch DESC"
+    "SELECT * FROM checkpoints WHERE session_id = ? ORDER BY created_at_epoch DESC, id DESC"
   );
   return query.all(sessionId);
 }
@@ -1062,9 +1362,9 @@ function getReportData(db, project, startEpoch, endEpoch) {
   const staleCount = (project ? db.query(staleSql).get(project, startEpoch, endEpoch)?.count : db.query(staleSql).get(startEpoch, endEpoch)?.count) || 0;
   const summarySql = project ? `SELECT learned, completed, next_steps FROM summaries
        WHERE project = ? AND created_at_epoch >= ? AND created_at_epoch <= ?
-       ORDER BY created_at_epoch DESC` : `SELECT learned, completed, next_steps FROM summaries
+       ORDER BY created_at_epoch DESC, id DESC` : `SELECT learned, completed, next_steps FROM summaries
        WHERE created_at_epoch >= ? AND created_at_epoch <= ?
-       ORDER BY created_at_epoch DESC`;
+       ORDER BY created_at_epoch DESC, id DESC`;
   const summaryRows = project ? db.query(summarySql).all(project, startEpoch, endEpoch) : db.query(summarySql).all(startEpoch, endEpoch);
   const topLearnings = [];
   const completedTasks = [];
@@ -1134,7 +1434,7 @@ function escapeLikePattern3(input) {
 }
 function sanitizeFTS5Query(query) {
   const trimmed = query.length > 1e4 ? query.substring(0, 1e4) : query;
-  const terms = trimmed.replace(/[""]/g, "").split(/\s+/).filter((t) => t.length > 0).slice(0, 100).map((t) => `"${t}"`);
+  const terms = trimmed.replace(/[""\u0022]/g, "").split(/\s+/).filter((t) => t.length > 0).slice(0, 100).map((t) => `"${t}"`);
   return terms.join(" ");
 }
 function searchObservationsFTS(db, query, filters = {}) {
@@ -1231,7 +1531,7 @@ function searchObservationsLIKE(db, query, filters = {}) {
     sql += " AND created_at_epoch <= ?";
     params.push(filters.dateEnd);
   }
-  sql += " ORDER BY created_at_epoch DESC LIMIT ?";
+  sql += " ORDER BY created_at_epoch DESC, id DESC LIMIT ?";
   params.push(limit);
   const stmt = db.query(sql);
   return stmt.all(...params);
@@ -1256,7 +1556,7 @@ function searchSummariesFiltered(db, query, filters = {}) {
     sql += " AND created_at_epoch <= ?";
     params.push(filters.dateEnd);
   }
-  sql += " ORDER BY created_at_epoch DESC LIMIT ?";
+  sql += " ORDER BY created_at_epoch DESC, id DESC LIMIT ?";
   params.push(limit);
   const stmt = db.query(sql);
   return stmt.all(...params);
@@ -1266,7 +1566,7 @@ function getObservationsByIds(db, ids) {
   const validIds = ids.filter((id) => typeof id === "number" && Number.isInteger(id) && id > 0).slice(0, 500);
   if (validIds.length === 0) return [];
   const placeholders = validIds.map(() => "?").join(",");
-  const sql = `SELECT * FROM observations WHERE id IN (${placeholders}) ORDER BY created_at_epoch DESC`;
+  const sql = `SELECT * FROM observations WHERE id IN (${placeholders}) ORDER BY created_at_epoch DESC, id DESC`;
   const stmt = db.query(sql);
   return stmt.all(...validIds);
 }
@@ -1278,11 +1578,11 @@ function getTimeline(db, anchorId, depthBefore = 5, depthAfter = 5) {
   const beforeStmt = db.query(`
     SELECT id, 'observation' as type, title, text as content, project, created_at, created_at_epoch
     FROM observations
-    WHERE created_at_epoch < ?
-    ORDER BY created_at_epoch DESC
+    WHERE (created_at_epoch < ? OR (created_at_epoch = ? AND id < ?))
+    ORDER BY created_at_epoch DESC, id DESC
     LIMIT ?
   `);
-  const before = beforeStmt.all(anchorEpoch, depthBefore).reverse();
+  const before = beforeStmt.all(anchorEpoch, anchorEpoch, anchorId, depthBefore).reverse();
   const selfStmt = db.query(`
     SELECT id, 'observation' as type, title, text as content, project, created_at, created_at_epoch
     FROM observations WHERE id = ?
@@ -1291,34 +1591,46 @@ function getTimeline(db, anchorId, depthBefore = 5, depthAfter = 5) {
   const afterStmt = db.query(`
     SELECT id, 'observation' as type, title, text as content, project, created_at, created_at_epoch
     FROM observations
-    WHERE created_at_epoch > ?
-    ORDER BY created_at_epoch ASC
+    WHERE (created_at_epoch > ? OR (created_at_epoch = ? AND id > ?))
+    ORDER BY created_at_epoch ASC, id ASC
     LIMIT ?
   `);
-  const after = afterStmt.all(anchorEpoch, depthAfter);
+  const after = afterStmt.all(anchorEpoch, anchorEpoch, anchorId, depthAfter);
   return [...before, ...self, ...after];
 }
 function getProjectStats(db, project) {
-  const obsStmt = db.query("SELECT COUNT(*) as count FROM observations WHERE project = ?");
-  const sumStmt = db.query("SELECT COUNT(*) as count FROM summaries WHERE project = ?");
-  const sesStmt = db.query("SELECT COUNT(*) as count FROM sessions WHERE project = ?");
-  const prmStmt = db.query("SELECT COUNT(*) as count FROM prompts WHERE project = ?");
-  const discoveryStmt = db.query(
-    "SELECT COALESCE(SUM(discovery_tokens), 0) as total FROM observations WHERE project = ?"
-  );
-  const discoveryTokens = discoveryStmt.get(project)?.total || 0;
-  const readStmt = db.query(
-    `SELECT COALESCE(SUM(
-      CAST((LENGTH(COALESCE(title, '')) + LENGTH(COALESCE(narrative, ''))) / 4 AS INTEGER)
-    ), 0) as total FROM observations WHERE project = ?`
-  );
-  const readTokens = readStmt.get(project)?.total || 0;
+  const sql = `
+    WITH
+      obs_stats AS (
+        SELECT
+          COUNT(*) as count,
+          COALESCE(SUM(discovery_tokens), 0) as discovery_tokens,
+          COALESCE(SUM(
+            CAST((LENGTH(COALESCE(title, '')) + LENGTH(COALESCE(narrative, ''))) / 4 AS INTEGER)
+          ), 0) as read_tokens
+        FROM observations WHERE project = ?
+      ),
+      sum_count AS (SELECT COUNT(*) as count FROM summaries WHERE project = ?),
+      ses_count AS (SELECT COUNT(*) as count FROM sessions WHERE project = ?),
+      prm_count AS (SELECT COUNT(*) as count FROM prompts WHERE project = ?)
+    SELECT
+      obs_stats.count as observations,
+      obs_stats.discovery_tokens,
+      obs_stats.read_tokens,
+      sum_count.count as summaries,
+      ses_count.count as sessions,
+      prm_count.count as prompts
+    FROM obs_stats, sum_count, ses_count, prm_count
+  `;
+  const row = db.query(sql).get(project, project, project, project);
+  const discoveryTokens = row?.discovery_tokens || 0;
+  const readTokens = row?.read_tokens || 0;
   const savings = Math.max(0, discoveryTokens - readTokens);
   return {
-    observations: obsStmt.get(project)?.count || 0,
-    summaries: sumStmt.get(project)?.count || 0,
-    sessions: sesStmt.get(project)?.count || 0,
-    prompts: prmStmt.get(project)?.count || 0,
+    observations: row?.observations || 0,
+    summaries: row?.summaries || 0,
+    sessions: row?.sessions || 0,
+    prompts: row?.prompts || 0,
     tokenEconomics: { discoveryTokens, readTokens, savings }
   };
 }
@@ -1326,7 +1638,7 @@ function getStaleObservations(db, project) {
   const rows = db.query(`
     SELECT * FROM observations
     WHERE project = ? AND files_modified IS NOT NULL AND files_modified != ''
-    ORDER BY created_at_epoch DESC
+    ORDER BY created_at_epoch DESC, id DESC
     LIMIT 500
   `).all(project);
   const staleObs = [];
@@ -1361,25 +1673,925 @@ function markObservationsStale(db, ids, stale) {
     [stale ? 1 : 0, ...validIds]
   );
 }
+
+// src/services/sqlite/GithubLinks.ts
+function createGithubLink(db, data) {
+  const now = /* @__PURE__ */ new Date();
+  const result = db.run(
+    `INSERT INTO github_links
+     (observation_id, session_id, repo, issue_number, pr_number, event_type,
+      action, title, url, author, created_at, created_at_epoch)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [
+      data.observation_id ?? null,
+      data.session_id ?? null,
+      data.repo,
+      data.issue_number ?? null,
+      data.pr_number ?? null,
+      data.event_type,
+      data.action ?? null,
+      data.title ?? null,
+      data.url ?? null,
+      data.author ?? null,
+      now.toISOString(),
+      now.getTime()
+    ]
+  );
+  return Number(result.lastInsertRowid);
+}
+function getGithubLinksByObservation(db, observationId) {
+  return db.query(
+    `SELECT * FROM github_links
+     WHERE observation_id = ?
+     ORDER BY created_at_epoch DESC, id DESC`
+  ).all(observationId);
+}
+function getGithubLinksByRepo(db, repo, limit = 50) {
+  return db.query(
+    `SELECT * FROM github_links
+     WHERE repo = ?
+     ORDER BY created_at_epoch DESC, id DESC
+     LIMIT ?`
+  ).all(repo, limit);
+}
+function getGithubLinksByIssue(db, repo, issueNumber) {
+  return db.query(
+    `SELECT * FROM github_links
+     WHERE repo = ? AND issue_number = ?
+     ORDER BY created_at_epoch DESC, id DESC`
+  ).all(repo, issueNumber);
+}
+function getGithubLinksByPR(db, repo, prNumber) {
+  return db.query(
+    `SELECT * FROM github_links
+     WHERE repo = ? AND pr_number = ?
+     ORDER BY created_at_epoch DESC, id DESC`
+  ).all(repo, prNumber);
+}
+function searchGithubLinks(db, query, options = {}) {
+  const { repo, event_type, limit = 50 } = options;
+  const safeLimit = Math.min(Math.max(1, limit), 200);
+  const conditions = [];
+  const params = [];
+  if (query && query.trim().length > 0) {
+    const pattern = `%${query.replace(/[%_\\]/g, "\\$&")}%`;
+    conditions.push(`(title LIKE ? ESCAPE '\\' OR url LIKE ? ESCAPE '\\')`);
+    params.push(pattern, pattern);
+  }
+  if (repo) {
+    conditions.push("repo = ?");
+    params.push(repo);
+  }
+  if (event_type) {
+    conditions.push("event_type = ?");
+    params.push(event_type);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  params.push(safeLimit);
+  return db.query(
+    `SELECT * FROM github_links
+     ${where}
+     ORDER BY created_at_epoch DESC, id DESC
+     LIMIT ?`
+  ).all(...params);
+}
+function listReposWithLinkCount(db) {
+  return db.query(
+    `SELECT repo,
+            COUNT(*) as count,
+            MAX(created_at) as last_event_at
+     FROM github_links
+     GROUP BY repo
+     ORDER BY count DESC, repo ASC`
+  ).all();
+}
+
+// src/services/sqlite/ImportExport.ts
+import { createHash } from "crypto";
+var JSONL_SCHEMA_VERSION = "2.5.0";
+var IMPORT_BATCH_SIZE = 100;
+function countExportRecords(db, filters) {
+  const { fromEpoch, toEpoch } = filtersToEpoch(filters);
+  const obsConds = buildConditions({ project: filters.project, type: filters.type, fromEpoch, toEpoch });
+  const sumConds = buildConditions({ project: filters.project, fromEpoch, toEpoch });
+  const promptConds = buildConditions({ project: filters.project, fromEpoch, toEpoch });
+  const obsCount = db.query(
+    `SELECT COUNT(*) as c FROM observations WHERE ${obsConds.where}`
+  ).get(...obsConds.params).c;
+  const sumCount = db.query(
+    `SELECT COUNT(*) as c FROM summaries WHERE ${sumConds.where}`
+  ).get(...sumConds.params).c;
+  const promptCount = db.query(
+    `SELECT COUNT(*) as c FROM prompts WHERE ${promptConds.where}`
+  ).get(...promptConds.params).c;
+  return { observations: obsCount, summaries: sumCount, prompts: promptCount };
+}
+function generateMetaRecord(db, filters) {
+  const counts = countExportRecords(db, filters);
+  const meta = {
+    _meta: {
+      version: JSONL_SCHEMA_VERSION,
+      exported_at: (/* @__PURE__ */ new Date()).toISOString(),
+      counts,
+      filters: Object.keys(filters).length > 0 ? filters : void 0
+    }
+  };
+  return JSON.stringify(meta);
+}
+function exportObservationsStreaming(db, filters, onRow, batchSize = 200) {
+  const { fromEpoch, toEpoch } = filtersToEpoch(filters);
+  const conds = buildConditions({ project: filters.project, type: filters.type, fromEpoch, toEpoch });
+  let offset = 0;
+  let total = 0;
+  while (true) {
+    const rows = db.query(
+      `SELECT id, memory_session_id, project, type, title, subtitle, text, narrative, facts, concepts,
+              files_read, files_modified, prompt_number, content_hash, discovery_tokens, auto_category,
+              created_at, created_at_epoch
+       FROM observations
+       WHERE ${conds.where}
+       ORDER BY created_at_epoch ASC, id ASC
+       LIMIT ? OFFSET ?`
+    ).all(...conds.params, batchSize, offset);
+    if (rows.length === 0) break;
+    for (const row of rows) {
+      const record = {
+        _type: "observation",
+        id: row.id,
+        memory_session_id: row.memory_session_id,
+        project: row.project,
+        type: row.type,
+        title: row.title,
+        subtitle: row.subtitle,
+        text: row.text,
+        narrative: row.narrative,
+        facts: row.facts,
+        concepts: row.concepts,
+        files_read: row.files_read,
+        files_modified: row.files_modified,
+        prompt_number: row.prompt_number,
+        content_hash: row.content_hash,
+        discovery_tokens: row.discovery_tokens ?? 0,
+        auto_category: row.auto_category,
+        created_at: row.created_at,
+        created_at_epoch: row.created_at_epoch
+      };
+      onRow(JSON.stringify(record));
+      total++;
+    }
+    offset += rows.length;
+    if (rows.length < batchSize) break;
+  }
+  return total;
+}
+function exportSummariesStreaming(db, filters, onRow, batchSize = 200) {
+  const { fromEpoch, toEpoch } = filtersToEpoch(filters);
+  const conds = buildConditions({ project: filters.project, fromEpoch, toEpoch });
+  let offset = 0;
+  let total = 0;
+  while (true) {
+    const rows = db.query(
+      `SELECT id, session_id, project, request, investigated, learned, completed, next_steps, notes,
+              discovery_tokens, created_at, created_at_epoch
+       FROM summaries
+       WHERE ${conds.where}
+       ORDER BY created_at_epoch ASC, id ASC
+       LIMIT ? OFFSET ?`
+    ).all(...conds.params, batchSize, offset);
+    if (rows.length === 0) break;
+    for (const row of rows) {
+      const record = {
+        _type: "summary",
+        id: row.id,
+        session_id: row.session_id,
+        project: row.project,
+        request: row.request,
+        investigated: row.investigated,
+        learned: row.learned,
+        completed: row.completed,
+        next_steps: row.next_steps,
+        notes: row.notes,
+        discovery_tokens: row.discovery_tokens ?? 0,
+        created_at: row.created_at,
+        created_at_epoch: row.created_at_epoch
+      };
+      onRow(JSON.stringify(record));
+      total++;
+    }
+    offset += rows.length;
+    if (rows.length < batchSize) break;
+  }
+  return total;
+}
+function exportPromptsStreaming(db, filters, onRow, batchSize = 200) {
+  const { fromEpoch, toEpoch } = filtersToEpoch(filters);
+  const conds = buildConditions({ project: filters.project, fromEpoch, toEpoch });
+  let offset = 0;
+  let total = 0;
+  while (true) {
+    const rows = db.query(
+      `SELECT id, content_session_id, project, prompt_number, prompt_text, created_at, created_at_epoch
+       FROM prompts
+       WHERE ${conds.where}
+       ORDER BY created_at_epoch ASC, id ASC
+       LIMIT ? OFFSET ?`
+    ).all(...conds.params, batchSize, offset);
+    if (rows.length === 0) break;
+    for (const row of rows) {
+      const record = {
+        _type: "prompt",
+        id: row.id,
+        content_session_id: row.content_session_id,
+        project: row.project,
+        prompt_number: row.prompt_number,
+        prompt_text: row.prompt_text,
+        created_at: row.created_at,
+        created_at_epoch: row.created_at_epoch
+      };
+      onRow(JSON.stringify(record));
+      total++;
+    }
+    offset += rows.length;
+    if (rows.length < batchSize) break;
+  }
+  return total;
+}
+function validateJsonlRow(raw) {
+  if (!raw || typeof raw !== "object") {
+    return "Il record non \xE8 un oggetto JSON valido";
+  }
+  const rec = raw;
+  if ("_meta" in rec) return null;
+  const validTypes = ["observation", "summary", "prompt"];
+  if (!rec._type || typeof rec._type !== "string" || !validTypes.includes(rec._type)) {
+    return `Campo "_type" obbligatorio, uno di: ${validTypes.join(", ")}`;
+  }
+  if (rec._type === "observation") {
+    if (!rec.project || typeof rec.project !== "string") return 'observation: campo "project" obbligatorio';
+    if (!rec.type || typeof rec.type !== "string") return 'observation: campo "type" obbligatorio';
+    if (!rec.title || typeof rec.title !== "string") return 'observation: campo "title" obbligatorio';
+    if (rec.project.length > 200) return 'observation: "project" troppo lungo (max 200)';
+    if (rec.title.length > 500) return 'observation: "title" troppo lungo (max 500)';
+  } else if (rec._type === "summary") {
+    if (!rec.project || typeof rec.project !== "string") return 'summary: campo "project" obbligatorio';
+    if (!rec.session_id || typeof rec.session_id !== "string") return 'summary: campo "session_id" obbligatorio';
+  } else if (rec._type === "prompt") {
+    if (!rec.project || typeof rec.project !== "string") return 'prompt: campo "project" obbligatorio';
+    if (!rec.content_session_id || typeof rec.content_session_id !== "string") return 'prompt: campo "content_session_id" obbligatorio';
+    if (!rec.prompt_text || typeof rec.prompt_text !== "string") return 'prompt: campo "prompt_text" obbligatorio';
+  }
+  return null;
+}
+function computeImportHash(rec) {
+  const payload = [
+    rec.project ?? "",
+    rec.type ?? "",
+    rec.title ?? "",
+    rec.narrative ?? ""
+  ].join("|");
+  return createHash("sha256").update(payload).digest("hex");
+}
+function hashExistsInObservations(db, hash) {
+  const result = db.query(
+    "SELECT id FROM observations WHERE content_hash = ? LIMIT 1"
+  ).get(hash);
+  return !!result;
+}
+function importObservationBatch(db, records, dryRun) {
+  let imported = 0;
+  let skipped = 0;
+  for (let i = 0; i < records.length; i += IMPORT_BATCH_SIZE) {
+    const batch = records.slice(i, i + IMPORT_BATCH_SIZE);
+    if (dryRun) {
+      for (const rec of batch) {
+        const hash = rec.content_hash || computeImportHash(rec);
+        if (hashExistsInObservations(db, hash)) {
+          skipped++;
+        } else {
+          imported++;
+        }
+      }
+      continue;
+    }
+    const insertBatch = db.transaction(() => {
+      for (const rec of batch) {
+        const hash = rec.content_hash || computeImportHash(rec);
+        if (hashExistsInObservations(db, hash)) {
+          skipped++;
+          continue;
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        db.run(
+          `INSERT INTO observations
+           (memory_session_id, project, type, title, subtitle, text, narrative, facts, concepts,
+            files_read, files_modified, prompt_number, content_hash, discovery_tokens, auto_category,
+            created_at, created_at_epoch)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          [
+            rec.memory_session_id || "imported",
+            rec.project,
+            rec.type,
+            rec.title,
+            rec.subtitle ?? null,
+            rec.text ?? null,
+            rec.narrative ?? null,
+            rec.facts ?? null,
+            rec.concepts ?? null,
+            rec.files_read ?? null,
+            rec.files_modified ?? null,
+            rec.prompt_number ?? 0,
+            hash,
+            rec.discovery_tokens ?? 0,
+            rec.auto_category ?? null,
+            rec.created_at || now,
+            rec.created_at_epoch || Date.now()
+          ]
+        );
+        imported++;
+      }
+    });
+    insertBatch();
+  }
+  return { imported, skipped };
+}
+function importSummaryBatch(db, records, dryRun) {
+  let imported = 0;
+  let skipped = 0;
+  for (let i = 0; i < records.length; i += IMPORT_BATCH_SIZE) {
+    const batch = records.slice(i, i + IMPORT_BATCH_SIZE);
+    if (dryRun) {
+      for (const rec of batch) {
+        const exists = db.query(
+          "SELECT id FROM summaries WHERE session_id = ? AND project = ? AND created_at_epoch = ? LIMIT 1"
+        ).get(rec.session_id, rec.project, rec.created_at_epoch ?? 0);
+        if (exists) skipped++;
+        else imported++;
+      }
+      continue;
+    }
+    const insertBatch = db.transaction(() => {
+      for (const rec of batch) {
+        const exists = db.query(
+          "SELECT id FROM summaries WHERE session_id = ? AND project = ? AND created_at_epoch = ? LIMIT 1"
+        ).get(rec.session_id, rec.project, rec.created_at_epoch ?? 0);
+        if (exists) {
+          skipped++;
+          continue;
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        db.run(
+          `INSERT INTO summaries
+           (session_id, project, request, investigated, learned, completed, next_steps, notes,
+            discovery_tokens, created_at, created_at_epoch)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          [
+            rec.session_id,
+            rec.project,
+            rec.request ?? null,
+            rec.investigated ?? null,
+            rec.learned ?? null,
+            rec.completed ?? null,
+            rec.next_steps ?? null,
+            rec.notes ?? null,
+            rec.discovery_tokens ?? 0,
+            rec.created_at || now,
+            rec.created_at_epoch || Date.now()
+          ]
+        );
+        imported++;
+      }
+    });
+    insertBatch();
+  }
+  return { imported, skipped };
+}
+function importPromptBatch(db, records, dryRun) {
+  let imported = 0;
+  let skipped = 0;
+  for (let i = 0; i < records.length; i += IMPORT_BATCH_SIZE) {
+    const batch = records.slice(i, i + IMPORT_BATCH_SIZE);
+    if (dryRun) {
+      for (const rec of batch) {
+        const exists = db.query(
+          "SELECT id FROM prompts WHERE content_session_id = ? AND prompt_number = ? LIMIT 1"
+        ).get(rec.content_session_id, rec.prompt_number ?? 0);
+        if (exists) skipped++;
+        else imported++;
+      }
+      continue;
+    }
+    const insertBatch = db.transaction(() => {
+      for (const rec of batch) {
+        const exists = db.query(
+          "SELECT id FROM prompts WHERE content_session_id = ? AND prompt_number = ? LIMIT 1"
+        ).get(rec.content_session_id, rec.prompt_number ?? 0);
+        if (exists) {
+          skipped++;
+          continue;
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        db.run(
+          `INSERT INTO prompts
+           (content_session_id, project, prompt_number, prompt_text, created_at, created_at_epoch)
+           VALUES (?, ?, ?, ?, ?, ?)`,
+          [
+            rec.content_session_id,
+            rec.project,
+            rec.prompt_number ?? 0,
+            rec.prompt_text,
+            rec.created_at || now,
+            rec.created_at_epoch || Date.now()
+          ]
+        );
+        imported++;
+      }
+    });
+    insertBatch();
+  }
+  return { imported, skipped };
+}
+function importJsonl(db, content, dryRun = false) {
+  const lines = content.split("\n");
+  const result = {
+    imported: 0,
+    skipped: 0,
+    errors: 0,
+    total: 0,
+    errorDetails: []
+  };
+  const obsBuf = [];
+  const sumBuf = [];
+  const promptBuf = [];
+  const flushBuffers = () => {
+    if (obsBuf.length > 0) {
+      const r = importObservationBatch(db, obsBuf.splice(0), dryRun);
+      result.imported += r.imported;
+      result.skipped += r.skipped;
+    }
+    if (sumBuf.length > 0) {
+      const r = importSummaryBatch(db, sumBuf.splice(0), dryRun);
+      result.imported += r.imported;
+      result.skipped += r.skipped;
+    }
+    if (promptBuf.length > 0) {
+      const r = importPromptBatch(db, promptBuf.splice(0), dryRun);
+      result.imported += r.imported;
+      result.skipped += r.skipped;
+    }
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i].trim();
+    if (!raw || raw.startsWith("#")) continue;
+    result.total++;
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      result.errors++;
+      result.errorDetails.push({ line: i + 1, error: `JSON non valido: ${raw.substring(0, 60)}` });
+      continue;
+    }
+    if (parsed && typeof parsed === "object" && "_meta" in parsed) {
+      result.total--;
+      continue;
+    }
+    const validErr = validateJsonlRow(parsed);
+    if (validErr) {
+      result.errors++;
+      result.errorDetails.push({ line: i + 1, error: validErr });
+      continue;
+    }
+    const rec = parsed;
+    if (rec._type === "observation") {
+      obsBuf.push(rec);
+    } else if (rec._type === "summary") {
+      sumBuf.push(rec);
+    } else if (rec._type === "prompt") {
+      promptBuf.push(rec);
+    }
+    const totalBuf = obsBuf.length + sumBuf.length + promptBuf.length;
+    if (totalBuf >= IMPORT_BATCH_SIZE) {
+      flushBuffers();
+    }
+  }
+  flushBuffers();
+  return result;
+}
+function filtersToEpoch(filters) {
+  return {
+    fromEpoch: filters.from ? new Date(filters.from).getTime() : void 0,
+    toEpoch: filters.to ? new Date(filters.to).getTime() : void 0
+  };
+}
+function buildConditions(params) {
+  const conditions = ["1=1"];
+  const values = [];
+  if (params.project) {
+    conditions.push("project = ?");
+    values.push(params.project);
+  }
+  if (params.type) {
+    conditions.push("type = ?");
+    values.push(params.type);
+  }
+  if (params.fromEpoch !== void 0) {
+    conditions.push("created_at_epoch >= ?");
+    values.push(params.fromEpoch);
+  }
+  if (params.toEpoch !== void 0) {
+    conditions.push("created_at_epoch <= ?");
+    values.push(params.toEpoch);
+  }
+  return { where: conditions.join(" AND "), params: values };
+}
+
+// src/types/worker-types.ts
+var KNOWLEDGE_TYPES = ["constraint", "decision", "heuristic", "rejected"];
+
+// src/services/sqlite/Retention.ts
+var KNOWLEDGE_TYPE_LIST = KNOWLEDGE_TYPES;
+var KNOWLEDGE_PLACEHOLDERS = KNOWLEDGE_TYPE_LIST.map(() => "?").join(", ");
+function toEpochThreshold(maxAgeDays) {
+  if (maxAgeDays <= 0) return null;
+  return Date.now() - maxAgeDays * 864e5;
+}
+function buildKnowledgeImportanceExemptionClause() {
+  return `AND NOT (
+    facts IS NOT NULL AND (
+      facts LIKE '%"importance":4%'
+      OR facts LIKE '%"importance": 4%'
+      OR facts LIKE '%"importance":5%'
+      OR facts LIKE '%"importance": 5%'
+    )
+  )`;
+}
+function getRetentionStats(db, config) {
+  const obsThreshold = toEpochThreshold(config.observationsMaxAgeDays);
+  const sumThreshold = toEpochThreshold(config.summariesMaxAgeDays);
+  const promptThreshold = toEpochThreshold(config.promptsMaxAgeDays);
+  const knowledgeThreshold = toEpochThreshold(config.knowledgeMaxAgeDays);
+  const importanceExemption = buildKnowledgeImportanceExemptionClause();
+  let observations = 0;
+  if (obsThreshold !== null) {
+    const row = db.query(
+      `SELECT COUNT(*) as c FROM observations
+       WHERE created_at_epoch < ?
+         AND type NOT IN (${KNOWLEDGE_PLACEHOLDERS})`
+    ).get(obsThreshold, ...KNOWLEDGE_TYPE_LIST);
+    observations = row?.c ?? 0;
+  }
+  let summaries = 0;
+  if (sumThreshold !== null) {
+    const row = db.query(
+      "SELECT COUNT(*) as c FROM summaries WHERE created_at_epoch < ?"
+    ).get(sumThreshold);
+    summaries = row?.c ?? 0;
+  }
+  let prompts = 0;
+  if (promptThreshold !== null) {
+    const row = db.query(
+      "SELECT COUNT(*) as c FROM prompts WHERE created_at_epoch < ?"
+    ).get(promptThreshold);
+    prompts = row?.c ?? 0;
+  }
+  let knowledge = 0;
+  if (knowledgeThreshold !== null) {
+    const row = db.query(
+      `SELECT COUNT(*) as c FROM observations
+       WHERE created_at_epoch < ?
+         AND type IN (${KNOWLEDGE_PLACEHOLDERS})
+         ${importanceExemption}`
+    ).get(knowledgeThreshold, ...KNOWLEDGE_TYPE_LIST);
+    knowledge = row?.c ?? 0;
+  }
+  const total = observations + summaries + prompts + knowledge;
+  return { observations, summaries, prompts, knowledge, total };
+}
+function countRows(db, sql, params) {
+  const row = db.query(sql).get(...params);
+  return row?.c ?? 0;
+}
+function applyRetention(db, config) {
+  const obsThreshold = toEpochThreshold(config.observationsMaxAgeDays);
+  const sumThreshold = toEpochThreshold(config.summariesMaxAgeDays);
+  const promptThreshold = toEpochThreshold(config.promptsMaxAgeDays);
+  const knowledgeThreshold = toEpochThreshold(config.knowledgeMaxAgeDays);
+  const importanceExemption = buildKnowledgeImportanceExemptionClause();
+  const deleteAll = db.transaction(() => {
+    let observations = 0;
+    let summaries = 0;
+    let prompts = 0;
+    let knowledge = 0;
+    if (obsThreshold !== null) {
+      const obsParams = [obsThreshold, ...KNOWLEDGE_TYPE_LIST];
+      const obsWhere = `WHERE created_at_epoch < ? AND type NOT IN (${KNOWLEDGE_PLACEHOLDERS})`;
+      observations = countRows(
+        db,
+        `SELECT COUNT(*) as c FROM observations ${obsWhere}`,
+        obsParams
+      );
+      if (observations > 0) {
+        db.run(
+          `DELETE FROM observation_embeddings
+           WHERE observation_id IN (
+             SELECT id FROM observations ${obsWhere}
+           )`,
+          obsParams
+        );
+        db.run(
+          `DELETE FROM observations ${obsWhere}`,
+          obsParams
+        );
+      }
+    }
+    if (sumThreshold !== null) {
+      summaries = countRows(
+        db,
+        "SELECT COUNT(*) as c FROM summaries WHERE created_at_epoch < ?",
+        [sumThreshold]
+      );
+      if (summaries > 0) {
+        db.run("DELETE FROM summaries WHERE created_at_epoch < ?", [sumThreshold]);
+      }
+    }
+    if (promptThreshold !== null) {
+      prompts = countRows(
+        db,
+        "SELECT COUNT(*) as c FROM prompts WHERE created_at_epoch < ?",
+        [promptThreshold]
+      );
+      if (prompts > 0) {
+        db.run("DELETE FROM prompts WHERE created_at_epoch < ?", [promptThreshold]);
+      }
+    }
+    if (knowledgeThreshold !== null) {
+      const kParams = [knowledgeThreshold, ...KNOWLEDGE_TYPE_LIST];
+      const kWhere = `WHERE created_at_epoch < ? AND type IN (${KNOWLEDGE_PLACEHOLDERS}) ${importanceExemption}`;
+      knowledge = countRows(
+        db,
+        `SELECT COUNT(*) as c FROM observations ${kWhere}`,
+        kParams
+      );
+      if (knowledge > 0) {
+        db.run(
+          `DELETE FROM observation_embeddings
+           WHERE observation_id IN (
+             SELECT id FROM observations ${kWhere}
+           )`,
+          kParams
+        );
+        db.run(
+          `DELETE FROM observations ${kWhere}`,
+          kParams
+        );
+      }
+    }
+    return { observations, summaries, prompts, knowledge };
+  });
+  const counts = deleteAll();
+  const total = counts.observations + counts.summaries + counts.prompts + counts.knowledge;
+  return {
+    ...counts,
+    total,
+    executedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function buildRetentionConfig(config) {
+  function getNum(key, fallback) {
+    const v = config[key];
+    if (v === null || v === void 0) return fallback;
+    const n = Number(v);
+    return isNaN(n) ? fallback : n;
+  }
+  return {
+    observationsMaxAgeDays: getNum("retention.observations.maxAgeDays", 90),
+    summariesMaxAgeDays: getNum("retention.summaries.maxAgeDays", 365),
+    promptsMaxAgeDays: getNum("retention.prompts.maxAgeDays", 30),
+    knowledgeMaxAgeDays: getNum("retention.knowledge.maxAgeDays", 0)
+  };
+}
+
+// src/services/sqlite/Backup.ts
+import {
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync3,
+  copyFileSync,
+  readdirSync,
+  statSync as statSync2,
+  unlinkSync,
+  readFileSync as readFileSync2,
+  writeFileSync
+} from "fs";
+import { join as join3, basename as basename2 } from "path";
+function formatTimestamp(date) {
+  const pad = (n, len = 2) => String(n).padStart(len, "0");
+  const year = date.getFullYear();
+  const month = pad(date.getMonth() + 1);
+  const day = pad(date.getDate());
+  const hours = pad(date.getHours());
+  const mins = pad(date.getMinutes());
+  const secs = pad(date.getSeconds());
+  const ms = pad(date.getMilliseconds(), 3);
+  return `${year}-${month}-${day}-${hours}${mins}${secs}-${ms}`;
+}
+function collectStats(db, dbPath) {
+  const countTable = (table) => {
+    try {
+      const row = db.query(`SELECT COUNT(*) as c FROM ${table}`).get();
+      return row?.c ?? 0;
+    } catch {
+      return 0;
+    }
+  };
+  const dbSizeBytes = existsSync4(dbPath) ? statSync2(dbPath).size : 0;
+  return {
+    observations: countTable("observations"),
+    sessions: countTable("sessions"),
+    summaries: countTable("summaries"),
+    prompts: countTable("prompts"),
+    dbSizeBytes
+  };
+}
+function getSchemaVersion(db) {
+  try {
+    const row = db.query("SELECT MAX(version) as v FROM schema_versions").get();
+    return row?.v ?? 0;
+  } catch {
+    return 0;
+  }
+}
+function createBackup(dbPath, backupDir, db) {
+  mkdirSync3(backupDir, { recursive: true });
+  const now = /* @__PURE__ */ new Date();
+  const ts = formatTimestamp(now);
+  const filename = `backup-${ts}.db`;
+  const destPath = join3(backupDir, filename);
+  const metaFilename = `backup-${ts}.meta.json`;
+  const metaPath = join3(backupDir, metaFilename);
+  if (!existsSync4(dbPath)) {
+    throw new Error(`Database non trovato: ${dbPath}`);
+  }
+  copyFileSync(dbPath, destPath);
+  logger.info("BACKUP", `File DB copiato: ${dbPath} \u2192 ${destPath}`);
+  const walPath = `${dbPath}-wal`;
+  const shmPath = `${dbPath}-shm`;
+  if (existsSync4(walPath)) {
+    copyFileSync(walPath, `${destPath}-wal`);
+    logger.debug("BACKUP", "File WAL copiato");
+  }
+  if (existsSync4(shmPath)) {
+    copyFileSync(shmPath, `${destPath}-shm`);
+    logger.debug("BACKUP", "File SHM copiato");
+  }
+  const stats = collectStats(db, dbPath);
+  const schemaVersion = getSchemaVersion(db);
+  const metadata = {
+    timestamp: now.toISOString(),
+    timestampEpoch: now.getTime(),
+    schemaVersion,
+    stats,
+    sourcePath: dbPath,
+    filename
+  };
+  writeFileSync(metaPath, JSON.stringify(metadata, null, 2), "utf8");
+  logger.info("BACKUP", `Metadata scritto: ${metaPath}`);
+  return {
+    filePath: destPath,
+    metaPath,
+    metadata
+  };
+}
+function listBackups(backupDir) {
+  if (!existsSync4(backupDir)) {
+    return [];
+  }
+  const entries = [];
+  let files;
+  try {
+    files = readdirSync(backupDir);
+  } catch (err) {
+    logger.warn("BACKUP", `Impossibile leggere la directory backup: ${backupDir}`, {}, err);
+    return [];
+  }
+  const metaFiles = files.filter((f) => f.startsWith("backup-") && f.endsWith(".meta.json"));
+  for (const metaFile of metaFiles) {
+    const metaPath = join3(backupDir, metaFile);
+    const dbFilename = metaFile.replace(/\.meta\.json$/, ".db");
+    const filePath = join3(backupDir, dbFilename);
+    let metadata;
+    try {
+      const raw = readFileSync2(metaPath, "utf8");
+      metadata = JSON.parse(raw);
+    } catch (err) {
+      logger.warn("BACKUP", `Metadata non leggibile: ${metaPath}`, {}, err);
+      continue;
+    }
+    if (!existsSync4(filePath)) {
+      logger.warn("BACKUP", `File backup mancante per metadata: ${filePath}`);
+      continue;
+    }
+    entries.push({ filePath, metaPath, metadata });
+  }
+  entries.sort((a, b) => b.metadata.timestampEpoch - a.metadata.timestampEpoch);
+  return entries;
+}
+function restoreBackup(backupFile, dbPath) {
+  if (!existsSync4(backupFile)) {
+    throw new Error(`File backup non trovato: ${backupFile}`);
+  }
+  copyFileSync(backupFile, dbPath);
+  logger.info("BACKUP", `Database ripristinato: ${backupFile} \u2192 ${dbPath}`);
+  const walBackup = `${backupFile}-wal`;
+  const shmBackup = `${backupFile}-shm`;
+  const walDest = `${dbPath}-wal`;
+  const shmDest = `${dbPath}-shm`;
+  if (existsSync4(walBackup)) {
+    copyFileSync(walBackup, walDest);
+    logger.debug("BACKUP", "File WAL ripristinato");
+  } else if (existsSync4(walDest)) {
+    unlinkSync(walDest);
+    logger.debug("BACKUP", "File WAL corrente rimosso (non presente nel backup)");
+  }
+  if (existsSync4(shmBackup)) {
+    copyFileSync(shmBackup, shmDest);
+    logger.debug("BACKUP", "File SHM ripristinato");
+  } else if (existsSync4(shmDest)) {
+    unlinkSync(shmDest);
+    logger.debug("BACKUP", "File SHM corrente rimosso (non presente nel backup)");
+  }
+}
+function rotateBackups(backupDir, maxKeep) {
+  if (maxKeep <= 0) {
+    throw new Error(`maxKeep deve essere > 0, ricevuto: ${maxKeep}`);
+  }
+  const entries = listBackups(backupDir);
+  if (entries.length <= maxKeep) {
+    logger.debug("BACKUP", `Rotazione non necessaria: ${entries.length}/${maxKeep} backup presenti`);
+    return 0;
+  }
+  const toDelete = entries.slice(maxKeep);
+  let deleted = 0;
+  for (const entry of toDelete) {
+    try {
+      if (existsSync4(entry.filePath)) {
+        unlinkSync(entry.filePath);
+      }
+    } catch (err) {
+      logger.warn("BACKUP", `Impossibile eliminare: ${entry.filePath}`, {}, err);
+    }
+    for (const extra of [`${entry.filePath}-wal`, `${entry.filePath}-shm`]) {
+      try {
+        if (existsSync4(extra)) unlinkSync(extra);
+      } catch {
+      }
+    }
+    try {
+      if (existsSync4(entry.metaPath)) {
+        unlinkSync(entry.metaPath);
+      }
+    } catch (err) {
+      logger.warn("BACKUP", `Impossibile eliminare metadata: ${entry.metaPath}`, {}, err);
+    }
+    logger.info("BACKUP", `Backup rimosso (rotazione): ${basename2(entry.filePath)}`);
+    deleted++;
+  }
+  logger.info("BACKUP", `Rotazione completata: ${deleted} backup eliminati, ${maxKeep} mantenuti`);
+  return deleted;
+}
 export {
-  KiroMemoryDatabase as ContextKitDatabase,
-  DatabaseManager,
+  JSONL_SCHEMA_VERSION,
   KiroMemoryDatabase,
+  applyRetention,
+  buildNextCursor,
+  buildRetentionConfig,
   completeSession,
+  computeImportHash,
   consolidateObservations,
+  countExportRecords,
+  createBackup,
   createCheckpoint,
+  createGithubLink,
   createObservation,
   createPrompt,
   createSession,
   createSummary,
+  decodeCursor,
   deleteObservation,
   deletePrompt,
   deleteSummary,
+  encodeCursor,
+  exportObservationsStreaming,
+  exportPromptsStreaming,
+  exportSummariesStreaming,
   failSession,
+  generateMetaRecord,
   getActiveSessions,
   getAllSessions,
   getCheckpointsBySession,
-  getDatabase,
+  getGithubLinksByIssue,
+  getGithubLinksByObservation,
+  getGithubLinksByPR,
+  getGithubLinksByRepo,
   getLatestCheckpoint,
   getLatestCheckpointByProject,
   getLatestPrompt,
@@ -1390,6 +2602,7 @@ export {
   getPromptsByProject,
   getPromptsBySession,
   getReportData,
+  getRetentionStats,
   getSessionByContentId,
   getSessionById,
   getSessionsByProject,
@@ -1397,9 +2610,15 @@ export {
   getSummariesByProject,
   getSummaryBySession,
   getTimeline,
-  initializeDatabase,
+  hashExistsInObservations,
+  importJsonl,
   isDuplicateObservation,
+  listBackups,
+  listReposWithLinkCount,
   markObservationsStale,
+  restoreBackup,
+  rotateBackups,
+  searchGithubLinks,
   searchObservations,
   searchObservationsFTS,
   searchObservationsFTSWithRank,
@@ -1407,5 +2626,6 @@ export {
   searchSummaries,
   searchSummariesFiltered,
   updateLastAccessed,
-  updateSessionMemoryId
+  updateSessionMemoryId,
+  validateJsonlRow
 };