kiro-memory 1.9.0 → 3.0.0

package/plugin/dist/cli/contextkit.js

@@ -241,6 +241,290 @@ ${data.stack}` : ` ${data.message}`;
   }
 });
 
+// src/utils/secrets.ts
+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;
+}
+var SECRET_PATTERNS;
+var init_secrets = __esm({
+  "src/utils/secrets.ts"() {
+    "use strict";
+    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 }
+    ];
+  }
+});
+
+// src/utils/categorizer.ts
+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;
+}
+var CATEGORY_RULES;
+var init_categorizer = __esm({
+  "src/utils/categorizer.ts"() {
+    "use strict";
+    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
+      }
+    ];
+  }
+});
+
 // src/services/sqlite/Observations.ts
 var Observations_exports = {};
 __export(Observations_exports, {
@@ -266,11 +550,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);
 }
@@ -282,16 +578,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) {
@@ -324,21 +620,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();
@@ -351,22 +658,24 @@ 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();
 }
 var init_Observations = __esm({
   "src/services/sqlite/Observations.ts"() {
     "use strict";
+    init_secrets();
+    init_categorizer();
   }
 });
 
@@ -389,7 +698,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 = {}) {
@@ -486,7 +795,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);
@@ -511,7 +820,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);
@@ -521,7 +830,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);
 }
@@ -533,11 +842,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 = ?
@@ -546,34 +855,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 }
   };
 }
@@ -581,7 +902,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 = [];
@@ -624,6 +945,464 @@ var init_Search = __esm({
   }
 });
 
+// src/services/sqlite/ImportExport.ts
+var ImportExport_exports = {};
+__export(ImportExport_exports, {
+  JSONL_SCHEMA_VERSION: () => JSONL_SCHEMA_VERSION,
+  computeImportHash: () => computeImportHash,
+  countExportRecords: () => countExportRecords,
+  exportObservationsStreaming: () => exportObservationsStreaming,
+  exportPromptsStreaming: () => exportPromptsStreaming,
+  exportSummariesStreaming: () => exportSummariesStreaming,
+  generateMetaRecord: () => generateMetaRecord,
+  hashExistsInObservations: () => hashExistsInObservations,
+  importJsonl: () => importJsonl,
+  validateJsonlRow: () => validateJsonlRow
+});
+import { createHash } from "crypto";
+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 };
+}
+var JSONL_SCHEMA_VERSION, IMPORT_BATCH_SIZE;
+var init_ImportExport = __esm({
+  "src/services/sqlite/ImportExport.ts"() {
+    "use strict";
+    JSONL_SCHEMA_VERSION = "2.5.0";
+    IMPORT_BATCH_SIZE = 100;
+  }
+});
+
 // src/services/search/EmbeddingService.ts
 var EmbeddingService_exports = {};
 __export(EmbeddingService_exports, {
@@ -636,19 +1415,53 @@ function getEmbeddingService() {
   }
   return embeddingService;
 }
-var EmbeddingService, embeddingService;
+var MODEL_CONFIGS, FASTEMBED_COMPATIBLE_MODELS, EmbeddingService, embeddingService;
 var init_EmbeddingService = __esm({
   "src/services/search/EmbeddingService.ts"() {
     "use strict";
     init_logger();
+    MODEL_CONFIGS = {
+      "all-MiniLM-L6-v2": {
+        modelId: "Xenova/all-MiniLM-L6-v2",
+        dimensions: 384
+      },
+      "jina-code-v2": {
+        modelId: "jinaai/jina-embeddings-v2-base-code",
+        dimensions: 768
+      },
+      "bge-small-en": {
+        modelId: "BAAI/bge-small-en-v1.5",
+        dimensions: 384
+      }
+    };
+    FASTEMBED_COMPATIBLE_MODELS = /* @__PURE__ */ new Set(["all-MiniLM-L6-v2", "bge-small-en"]);
     EmbeddingService = class {
       provider = null;
       model = null;
       initialized = false;
       initializing = null;
+      config;
+      configName;
+      constructor() {
+        const envModel = process.env.KIRO_MEMORY_EMBEDDING_MODEL || "all-MiniLM-L6-v2";
+        this.configName = envModel;
+        if (MODEL_CONFIGS[envModel]) {
+          this.config = MODEL_CONFIGS[envModel];
+        } else if (envModel.includes("/")) {
+          const dimensions = parseInt(process.env.KIRO_MEMORY_EMBEDDING_DIMENSIONS || "384", 10);
+          this.config = {
+            modelId: envModel,
+            dimensions: isNaN(dimensions) ? 384 : dimensions
+          };
+        } else {
+          logger.warn("EMBEDDING", `Unknown model name '${envModel}', falling back to 'all-MiniLM-L6-v2'`);
+          this.configName = "all-MiniLM-L6-v2";
+          this.config = MODEL_CONFIGS["all-MiniLM-L6-v2"];
+        }
+      }
       /**
-       * Inizializza il servizio di embedding.
-       * Tenta fastembed, poi @huggingface/transformers, poi fallback a null.
+       * Initialize the embedding service.
+       * Tries fastembed (when compatible), then @huggingface/transformers, then falls back to null.
        */
       async initialize() {
         if (this.initialized) return this.provider !== null;
@@ -659,45 +1472,48 @@ var init_EmbeddingService = __esm({
         return result;
       }
       async _doInitialize() {
-        try {
-          const fastembed = await import("fastembed");
-          const EmbeddingModel = fastembed.EmbeddingModel || fastembed.default?.EmbeddingModel;
-          const FlagEmbedding = fastembed.FlagEmbedding || fastembed.default?.FlagEmbedding;
-          if (FlagEmbedding && EmbeddingModel) {
-            this.model = await FlagEmbedding.init({
-              model: EmbeddingModel.BGESmallENV15
-            });
-            this.provider = "fastembed";
-            this.initialized = true;
-            logger.info("EMBEDDING", "Inizializzato con fastembed (BGE-small-en-v1.5)");
-            return true;
+        const fastembedCompatible = FASTEMBED_COMPATIBLE_MODELS.has(this.configName);
+        if (fastembedCompatible) {
+          try {
+            const fastembed = await import("fastembed");
+            const EmbeddingModel = fastembed.EmbeddingModel || fastembed.default?.EmbeddingModel;
+            const FlagEmbedding = fastembed.FlagEmbedding || fastembed.default?.FlagEmbedding;
+            if (FlagEmbedding && EmbeddingModel) {
+              this.model = await FlagEmbedding.init({
+                model: EmbeddingModel.BGESmallENV15
+              });
+              this.provider = "fastembed";
+              this.initialized = true;
+              logger.info("EMBEDDING", `Initialized with fastembed (BGE-small-en-v1.5) for model '${this.configName}'`);
+              return true;
+            }
+          } catch (error) {
+            logger.debug("EMBEDDING", `fastembed not available: ${error}`);
           }
-        } catch (error) {
-          logger.debug("EMBEDDING", `fastembed non disponibile: ${error}`);
         }
         try {
           const transformers = await import("@huggingface/transformers");
           const pipeline = transformers.pipeline || transformers.default?.pipeline;
           if (pipeline) {
-            this.model = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2", {
+            this.model = await pipeline("feature-extraction", this.config.modelId, {
               quantized: true
             });
             this.provider = "transformers";
             this.initialized = true;
-            logger.info("EMBEDDING", "Inizializzato con @huggingface/transformers (all-MiniLM-L6-v2)");
+            logger.info("EMBEDDING", `Initialized with @huggingface/transformers (${this.config.modelId})`);
             return true;
           }
         } catch (error) {
-          logger.debug("EMBEDDING", `@huggingface/transformers non disponibile: ${error}`);
+          logger.debug("EMBEDDING", `@huggingface/transformers not available: ${error}`);
         }
         this.provider = null;
         this.initialized = true;
-        logger.warn("EMBEDDING", "Nessun provider embedding disponibile, ricerca semantica disabilitata");
+        logger.warn("EMBEDDING", "No embedding provider available, semantic search disabled");
         return false;
       }
       /**
-       * Genera embedding per un singolo testo.
-       * Ritorna Float32Array con 384 dimensioni, o null se non disponibile.
+       * Generate embedding for a single text.
+       * Returns Float32Array with configured dimensions, or null if not available.
        */
       async embed(text) {
         if (!this.initialized) await this.initialize();
@@ -710,46 +1526,118 @@ var init_EmbeddingService = __esm({
             return await this._embedTransformers(truncated);
           }
         } catch (error) {
-          logger.error("EMBEDDING", `Errore generazione embedding: ${error}`);
+          logger.error("EMBEDDING", `Error generating embedding: ${error}`);
         }
         return null;
       }
       /**
-       * Genera embeddings in batch.
+       * Generate embeddings in batch.
+       * Uses native batch support when available (fastembed, transformers),
+       * falls back to serial processing on batch failure.
        */
       async embedBatch(texts) {
         if (!this.initialized) await this.initialize();
         if (!this.provider || !this.model) return texts.map(() => null);
-        const results = [];
-        for (const text of texts) {
-          try {
-            const embedding = await this.embed(text);
-            results.push(embedding);
-          } catch {
-            results.push(null);
+        if (texts.length === 0) return [];
+        const truncated = texts.map((t) => t.substring(0, 2e3));
+        try {
+          if (this.provider === "fastembed") {
+            return await this._embedBatchFastembed(truncated);
+          } else if (this.provider === "transformers") {
+            return await this._embedBatchTransformers(truncated);
           }
+        } catch (error) {
+          logger.warn("EMBEDDING", `Batch embedding failed, falling back to serial: ${error}`);
         }
-        return results;
+        return this._embedBatchSerial(truncated);
       }
       /**
-       * Verifica se il servizio è disponibile.
+       * Check if the service is available.
        */
       isAvailable() {
         return this.initialized && this.provider !== null;
       }
       /**
-       * Nome del provider attivo.
+       * Name of the active provider.
        */
       getProvider() {
         return this.provider;
       }
       /**
-       * Dimensioni del vettore embedding.
+       * Embedding vector dimensions for the active model configuration.
        */
       getDimensions() {
-        return 384;
+        return this.config.dimensions;
+      }
+      /**
+       * Human-readable model name used as identifier in the observation_embeddings table.
+       * Returns the short name (e.g., 'all-MiniLM-L6-v2') or the full HF model ID for custom models.
+       */
+      getModelName() {
+        return this.configName;
+      }
+      // --- Batch implementations ---
+      /**
+       * Native batch embedding with fastembed.
+       * FlagEmbedding.embed() accepts string[] and returns an async iterable of batches.
+       */
+      async _embedBatchFastembed(texts) {
+        const results = [];
+        const embeddings = this.model.embed(texts, texts.length);
+        for await (const batch of embeddings) {
+          if (batch) {
+            for (const vec of batch) {
+              results.push(vec instanceof Float32Array ? vec : new Float32Array(vec));
+            }
+          }
+        }
+        while (results.length < texts.length) {
+          results.push(null);
+        }
+        return results;
+      }
+      /**
+       * Batch embedding with @huggingface/transformers pipeline.
+       * The pipeline accepts string[] and returns a Tensor with shape [N, dims].
+       */
+      async _embedBatchTransformers(texts) {
+        const output = await this.model(texts, {
+          pooling: "mean",
+          normalize: true
+        });
+        if (!output?.data) {
+          return texts.map(() => null);
+        }
+        const dims = this.getDimensions();
+        const data = output.data instanceof Float32Array ? output.data : new Float32Array(output.data);
+        const results = [];
+        for (let i = 0; i < texts.length; i++) {
+          const offset = i * dims;
+          if (offset + dims <= data.length) {
+            results.push(data.slice(offset, offset + dims));
+          } else {
+            results.push(null);
+          }
+        }
+        return results;
       }
-      // --- Provider specifici ---
+      /**
+       * Serial fallback: embed texts one at a time.
+       * Used when native batch fails.
+       */
+      async _embedBatchSerial(texts) {
+        const results = [];
+        for (const text of texts) {
+          try {
+            const embedding = await this.embed(text);
+            results.push(embedding);
+          } catch {
+            results.push(null);
+          }
+        }
+        return results;
+      }
+      // --- Single-text provider implementations ---
       async _embedFastembed(text) {
         const embeddings = this.model.embed([text], 1);
         for await (const batch of embeddings) {
@@ -775,18 +1663,334 @@ var init_EmbeddingService = __esm({
   }
 });
 
+// src/cli/cli-utils.ts
+var cli_utils_exports = {};
+__export(cli_utils_exports, {
+  CONFIG_DEFAULTS: () => CONFIG_DEFAULTS,
+  buildProgressBar: () => buildProgressBar,
+  checkFtsIntegrity: () => checkFtsIntegrity,
+  formatBytes: () => formatBytes,
+  formatImportResult: () => formatImportResult,
+  formatStatsOutput: () => formatStatsOutput,
+  generateExportOutput: () => generateExportOutput,
+  generateJsonOutput: () => generateJsonOutput,
+  generateJsonlOutput: () => generateJsonlOutput,
+  generateMarkdownOutput: () => generateMarkdownOutput,
+  getConfigPath: () => getConfigPath,
+  getConfigValue: () => getConfigValue,
+  getDbFileSize: () => getDbFileSize,
+  listConfig: () => listConfig,
+  observationToJsonl: () => observationToJsonl,
+  observationToMarkdown: () => observationToMarkdown,
+  parseJsonlFile: () => parseJsonlFile,
+  readConfig: () => readConfig,
+  rebuildFtsIndex: () => rebuildFtsIndex,
+  removeOrphanedEmbeddings: () => removeOrphanedEmbeddings,
+  setConfigValue: () => setConfigValue,
+  vacuumDatabase: () => vacuumDatabase,
+  validateImportRecord: () => validateImportRecord,
+  writeConfig: () => writeConfig
+});
+import { existsSync as existsSync5, statSync as statSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync4 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+function observationToJsonl(obs) {
+  return JSON.stringify(obs);
+}
+function generateJsonlOutput(observations) {
+  return observations.map(observationToJsonl).join("\n");
+}
+function generateJsonOutput(observations) {
+  return JSON.stringify(observations, null, 2);
+}
+function observationToMarkdown(obs) {
+  const date = new Date(obs.created_at).toLocaleDateString("it-IT", {
+    year: "numeric",
+    month: "long",
+    day: "numeric"
+  });
+  const lines = [
+    `## ${obs.title}`,
+    "",
+    `- **Tipo:** ${obs.type}`,
+    `- **Progetto:** ${obs.project}`,
+    `- **Data:** ${date}`
+  ];
+  if (obs.subtitle) lines.push(`- **Sottotitolo:** ${obs.subtitle}`);
+  if (obs.files_modified) lines.push(`- **File modificati:** ${obs.files_modified}`);
+  if (obs.files_read) lines.push(`- **File letti:** ${obs.files_read}`);
+  if (obs.text) {
+    lines.push("", "### Contenuto", "", obs.text);
+  }
+  if (obs.narrative) {
+    lines.push("", "### Narrativa", "", obs.narrative);
+  }
+  if (obs.facts) {
+    lines.push("", "### Fatti", "", obs.facts);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function generateMarkdownOutput(observations) {
+  if (observations.length === 0) return "# Nessuna observation trovata\n";
+  const header = [
+    "# Kiro Memory \u2014 Export Observations",
+    "",
+    `> Progetto: ${observations[0].project} | Totale: ${observations.length}`,
+    "",
+    "---",
+    ""
+  ].join("\n");
+  return header + observations.map(observationToMarkdown).join("\n---\n\n");
+}
+function generateExportOutput(observations, format) {
+  switch (format) {
+    case "jsonl":
+      return generateJsonlOutput(observations);
+    case "json":
+      return generateJsonOutput(observations);
+    case "md":
+      return generateMarkdownOutput(observations);
+  }
+}
+function validateImportRecord(raw) {
+  if (!raw || typeof raw !== "object") {
+    return "Record non \xE8 un oggetto JSON valido";
+  }
+  const rec = raw;
+  if (!rec.project || typeof rec.project !== "string" || rec.project.trim() === "") {
+    return 'Campo "project" obbligatorio (stringa non vuota)';
+  }
+  if (!rec.type || typeof rec.type !== "string" || rec.type.trim() === "") {
+    return 'Campo "type" obbligatorio (stringa non vuota)';
+  }
+  if (!rec.title || typeof rec.title !== "string" || rec.title.trim() === "") {
+    return 'Campo "title" obbligatorio (stringa non vuota)';
+  }
+  if (rec.project.length > 200) return '"project" troppo lungo (max 200 caratteri)';
+  if (rec.type.length > 100) return '"type" troppo lungo (max 100 caratteri)';
+  if (rec.title.length > 500) return '"title" troppo lungo (max 500 caratteri)';
+  for (const field of ["subtitle", "text", "narrative", "facts", "concepts", "files_read", "files_modified", "content_hash"]) {
+    const val = rec[field];
+    if (val !== void 0 && val !== null && typeof val !== "string") {
+      return `Campo "${field}" deve essere stringa o null`;
+    }
+  }
+  return null;
+}
+function parseJsonlFile(content) {
+  const lines = content.split("\n");
+  const results = [];
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i].trim();
+    if (!raw || raw.startsWith("#")) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      results.push({ line: i + 1, error: `JSON non valido: ${raw.substring(0, 50)}` });
+      continue;
+    }
+    const validationError = validateImportRecord(parsed);
+    if (validationError) {
+      results.push({ line: i + 1, error: validationError });
+      continue;
+    }
+    results.push({ line: i + 1, record: parsed });
+  }
+  return results;
+}
+function getConfigPath() {
+  const dataDir = process.env.KIRO_MEMORY_DATA_DIR || process.env.CONTEXTKIT_DATA_DIR || join4(homedir3(), ".contextkit");
+  return join4(dataDir, "config.json");
+}
+function readConfig(configPath) {
+  const path = configPath || getConfigPath();
+  if (!existsSync5(path)) return {};
+  try {
+    const raw = readFileSync3(path, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null) return parsed;
+    return {};
+  } catch {
+    return {};
+  }
+}
+function writeConfig(config, configPath) {
+  const path = configPath || getConfigPath();
+  const dir = path.substring(0, path.lastIndexOf("/"));
+  mkdirSync4(dir, { recursive: true });
+  writeFileSync2(path, JSON.stringify(config, null, 2), "utf8");
+}
+function getConfigValue(key, configPath) {
+  const config = readConfig(configPath);
+  if (key in config) return config[key];
+  if (key in CONFIG_DEFAULTS) return CONFIG_DEFAULTS[key];
+  return null;
+}
+function setConfigValue(key, rawValue, configPath) {
+  const config = readConfig(configPath);
+  let value = rawValue;
+  if (rawValue === "true") value = true;
+  else if (rawValue === "false") value = false;
+  else {
+    const num = Number(rawValue);
+    if (!isNaN(num) && rawValue.trim() !== "") value = num;
+  }
+  config[key] = value;
+  writeConfig(config, configPath);
+  return value;
+}
+function listConfig(configPath) {
+  const config = readConfig(configPath);
+  const merged = { ...CONFIG_DEFAULTS };
+  for (const [k, v] of Object.entries(config)) {
+    merged[k] = v;
+  }
+  return merged;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+  return `${(bytes / 1024 / 1024 / 1024).toFixed(2)} GB`;
+}
+function getDbFileSize(dbPath) {
+  try {
+    if (!existsSync5(dbPath)) return 0;
+    return statSync3(dbPath).size;
+  } catch {
+    return 0;
+  }
+}
+function formatStatsOutput(stats) {
+  const lines = [
+    "",
+    "=== Kiro Memory \u2014 Statistiche Database ===",
+    "",
+    `  Observations totali:   ${stats.totalObservations}`,
+    `  Sessioni totali:       ${stats.totalSessions}`,
+    `  Progetti distinti:     ${stats.totalProjects}`,
+    `  Dimensione DB:         ${formatBytes(stats.dbSizeBytes)}`
+  ];
+  if (stats.mostActiveProject) {
+    lines.push(`  Progetto piu' attivo:  ${stats.mostActiveProject}`);
+  }
+  const coverage = stats.embeddingCoverage;
+  const coverageBar = buildProgressBar(coverage, 20);
+  lines.push(`  Copertura embeddings:  ${coverageBar} ${coverage}%`);
+  lines.push("");
+  return lines.join("\n");
+}
+function buildProgressBar(percent, width = 20) {
+  const filled = Math.round(percent / 100 * width);
+  const empty = width - filled;
+  return `[${"#".repeat(filled)}${"-".repeat(empty)}]`;
+}
+function formatImportResult(result) {
+  const prefix = result.dryRun ? "[DRY RUN] " : "";
+  const lines = [
+    "",
+    `=== ${prefix}Kiro Memory \u2014 Import JSONL ===`,
+    "",
+    `  Record totali analizzati: ${result.total}`,
+    `  Importati:                ${result.imported}`,
+    `  Saltati (duplicati):      ${result.skipped}`,
+    `  Errori di validazione:    ${result.errors}`
+  ];
+  if (result.dryRun) {
+    lines.push("");
+    lines.push("  (Dry run: nessun dato inserito. Rimuovi --dry-run per applicare.)");
+  }
+  if (result.errorDetails && result.errorDetails.length > 0) {
+    lines.push("");
+    lines.push("  Errori:");
+    for (const err of result.errorDetails.slice(0, 20)) {
+      lines.push(`    Riga ${err.line}: ${err.error}`);
+    }
+    if (result.errorDetails.length > 20) {
+      lines.push(`    ... e altri ${result.errorDetails.length - 20} errori`);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function checkFtsIntegrity(db) {
+  try {
+    db.query("INSERT INTO observations_fts(observations_fts) VALUES('integrity-check')").run();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function rebuildFtsIndex(db) {
+  try {
+    db.run("INSERT INTO observations_fts(observations_fts) VALUES('rebuild')");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function removeOrphanedEmbeddings(db) {
+  try {
+    const result = db.run(
+      `DELETE FROM observation_embeddings
+       WHERE observation_id NOT IN (SELECT id FROM observations)`
+    );
+    return Number(result.changes);
+  } catch {
+    return 0;
+  }
+}
+function vacuumDatabase(db) {
+  try {
+    db.run("VACUUM");
+    return true;
+  } catch {
+    return false;
+  }
+}
+var CONFIG_DEFAULTS;
+var init_cli_utils = __esm({
+  "src/cli/cli-utils.ts"() {
+    "use strict";
+    CONFIG_DEFAULTS = {
+      "worker.port": 3001,
+      "worker.host": "127.0.0.1",
+      "log.level": "INFO",
+      "search.limit": 20,
+      "embeddings.enabled": false,
+      "decay.staleThresholdDays": 30,
+      // Politiche di retention: età massima in giorni (0 = mai eliminare)
+      "retention.observations.maxAgeDays": 90,
+      "retention.summaries.maxAgeDays": 365,
+      "retention.prompts.maxAgeDays": 30,
+      "retention.knowledge.maxAgeDays": 0,
+      // Cleanup automatico schedulato
+      "retention.autoCleanupEnabled": true,
+      "retention.autoCleanupIntervalHours": 24,
+      // Backup automatico schedulato
+      "backup.enabled": true,
+      "backup.intervalHours": 24,
+      "backup.maxKeep": 7,
+      "backup.compress": false
+    };
+  }
+});
+
 // src/shims/bun-sqlite.ts
 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);
@@ -794,51 +1998,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();
   }
 };
 
@@ -881,40 +2087,62 @@ init_logger();
 var SQLITE_MMAP_SIZE_BYTES = 256 * 1024 * 1024;
 var SQLITE_CACHE_SIZE_PAGES = 1e4;
 var KiroMemoryDatabase = class {
-  db;
+  _db;
+  /**
+   * Readonly accessor for the underlying Database instance.
+   * Prefer using query() and run() proxy methods directly.
+   */
+  get db() {
+    return this._db;
+  }
   /**
-   * @param dbPath - Percorso al file SQLite (default: DB_PATH)
-   * @param skipMigrations - Se true, salta il migration runner (per hook ad alta frequenza)
+   * @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.
+   * Prepare a query (delegates to underlying Database).
+   * Proxy method to avoid ctx.db.db.query() double access.
+   */
+  query(sql) {
+    return this._db.query(sql);
+  }
+  /**
+   * Execute a SQL statement without results (delegates to underlying Database).
+   * Proxy method to avoid ctx.db.db.run() double access.
+   */
+  run(sql, params) {
+    return this._db.run(sql, params);
+  }
+  /**
+   * Executes a function within an atomic transaction.
+   * If fn() throws an error, the transaction is automatically rolled back.
    */
   withTransaction(fn) {
-    const transaction = this.db.transaction(fn);
-    return transaction(this.db);
+    const transaction = this._db.transaction(fn);
+    return transaction(this._db);
   }
   /**
    * Close the database connection
    */
   close() {
-    this.db.close();
+    this._db.close();
   }
 };
 var MigrationRunner = class {
@@ -1155,11 +2383,104 @@ 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)");
+        }
       }
     ];
   }
 };
 
+// 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;
+  }
+}
+
 // src/services/sqlite/Sessions.ts
 function createSession(db, contentSessionId, project, userPrompt) {
   const now = /* @__PURE__ */ new Date();
@@ -1191,28 +2512,28 @@ init_Observations();
 function escapeLikePattern2(input) {
   return input.replace(/[%_\\]/g, "\\$&");
 }
-function createSummary(db, sessionId, project, request, investigated, learned, completed, nextSteps, notes) {
+function createSummary(db, sessionId, project, request2, investigated, learned, completed, nextSteps, notes) {
   const now = /* @__PURE__ */ new Date();
   const result = db.run(
     `INSERT INTO summaries 
      (session_id, project, request, investigated, learned, completed, next_steps, notes, created_at, created_at_epoch)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-    [sessionId, project, request, investigated, learned, completed, nextSteps, notes, now.toISOString(), now.getTime()]
+    [sessionId, project, request2, investigated, learned, completed, nextSteps, notes, now.toISOString(), now.getTime()]
   );
   return Number(result.lastInsertRowid);
 }
 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) {
@@ -1234,7 +2555,7 @@ function createPrompt(db, contentSessionId, project, promptNumber, promptText) {
 }
 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);
 }
@@ -1262,13 +2583,13 @@ 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);
 }
@@ -1330,9 +2651,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 = [];
@@ -1396,10 +2717,207 @@ function getReportData(db, project, startEpoch, endEpoch) {
 
 // src/services/sqlite/index.ts
 init_Search();
+init_ImportExport();
+
+// 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(", ");
+
+// src/services/sqlite/Backup.ts
+init_logger();
+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;
+}
 
 // src/sdk/index.ts
 init_Observations();
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 init_Search();
 
 // src/services/search/HybridSearch.ts
@@ -1408,17 +2926,21 @@ init_EmbeddingService();
 // src/services/search/VectorSearch.ts
 init_EmbeddingService();
 init_logger();
+var DEFAULT_MAX_CANDIDATES = 2e3;
 function cosineSimilarity(a, b) {
-  if (a.length !== b.length) return 0;
+  const len = a.length;
+  if (len !== b.length) return 0;
   let dotProduct = 0;
   let normA = 0;
   let normB = 0;
-  for (let i = 0; i < a.length; i++) {
-    dotProduct += a[i] * b[i];
-    normA += a[i] * a[i];
-    normB += b[i] * b[i];
-  }
-  const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+  for (let i = 0; i < len; i++) {
+    const ai = a[i];
+    const bi = b[i];
+    dotProduct += ai * bi;
+    normA += ai * ai;
+    normB += bi * bi;
+  }
+  const denominator = Math.sqrt(normA * normB);
   if (denominator === 0) return 0;
   return dotProduct / denominator;
 }
@@ -1431,23 +2953,36 @@ function bufferToFloat32(buf) {
 }
 var VectorSearch = class {
   /**
-   * Ricerca semantica: calcola cosine similarity tra query e tutti gli embeddings.
+   * Semantic search with SQL pre-filtering for scalability.
+   *
+   * 2-phase strategy:
+   * 1. SQL pre-filters by project + sorts by recency (loads max N candidates)
+   * 2. JS computes cosine similarity only on filtered candidates
+   *
+   * With 50k observations and maxCandidates=2000, loads only ~4% of data.
    */
   async search(db, queryEmbedding, options = {}) {
     const limit = options.limit || 10;
     const threshold = options.threshold || 0.3;
+    const maxCandidates = options.maxCandidates || DEFAULT_MAX_CANDIDATES;
     try {
-      let sql = `
+      const conditions = [];
+      const params = [];
+      if (options.project) {
+        conditions.push("o.project = ?");
+        params.push(options.project);
+      }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const sql = `
         SELECT e.observation_id, e.embedding,
                o.title, o.text, o.type, o.project, o.created_at, o.created_at_epoch
         FROM observation_embeddings e
         JOIN observations o ON o.id = e.observation_id
+        ${whereClause}
+        ORDER BY o.created_at_epoch DESC
+        LIMIT ?
       `;
-      const params = [];
-      if (options.project) {
-        sql += " WHERE o.project = ?";
-        params.push(options.project);
-      }
+      params.push(maxCandidates);
       const rows = db.query(sql).all(...params);
       const scored = [];
       for (const row of rows) {
@@ -1468,14 +3003,15 @@ var VectorSearch = class {
         }
       }
       scored.sort((a, b) => b.similarity - a.similarity);
+      logger.debug("VECTOR", `Search: ${rows.length} candidates \u2192 ${scored.length} above threshold \u2192 ${Math.min(scored.length, limit)} results`);
       return scored.slice(0, limit);
     } catch (error) {
-      logger.error("VECTOR", `Errore ricerca vettoriale: ${error}`);
+      logger.error("VECTOR", `Vector search error: ${error}`);
       return [];
     }
   }
   /**
-   * Salva embedding per un'osservazione.
+   * Store embedding for an observation.
    */
   async storeEmbedding(db, observationId, embedding, model) {
     try {
@@ -1491,18 +3027,18 @@ var VectorSearch = class {
         embedding.length,
         (/* @__PURE__ */ new Date()).toISOString()
       );
-      logger.debug("VECTOR", `Embedding salvato per osservazione ${observationId}`);
+      logger.debug("VECTOR", `Embedding saved for observation ${observationId}`);
     } catch (error) {
-      logger.error("VECTOR", `Errore salvataggio embedding: ${error}`);
+      logger.error("VECTOR", `Error saving embedding: ${error}`);
     }
   }
   /**
-   * Genera embeddings per osservazioni che non li hanno ancora.
+   * Generate embeddings for observations that don't have them yet.
    */
   async backfillEmbeddings(db, batchSize = 50) {
     const embeddingService2 = getEmbeddingService();
     if (!await embeddingService2.initialize()) {
-      logger.warn("VECTOR", "Embedding service non disponibile, backfill saltato");
+      logger.warn("VECTOR", "Embedding service not available, backfill skipped");
       return 0;
     }
     const rows = db.query(`
@@ -1515,7 +3051,7 @@ var VectorSearch = class {
     `).all(batchSize);
     if (rows.length === 0) return 0;
     let count = 0;
-    const model = embeddingService2.getProvider() || "unknown";
+    const model = embeddingService2.getModelName();
     for (const row of rows) {
       const parts = [row.title];
       if (row.text) parts.push(row.text);
@@ -1528,11 +3064,11 @@ var VectorSearch = class {
         count++;
       }
     }
-    logger.info("VECTOR", `Backfill completato: ${count}/${rows.length} embeddings generati`);
+    logger.info("VECTOR", `Backfill completed: ${count}/${rows.length} embeddings generated`);
     return count;
   }
   /**
-   * Statistiche sugli embeddings.
+   * Embedding statistics.
    */
   getStats(db) {
     try {
@@ -1606,21 +3142,21 @@ init_logger();
 var HybridSearch = class {
   embeddingInitialized = false;
   /**
-   * Inizializza il servizio di embedding (lazy, non bloccante)
+   * Initialize the embedding service (lazy, non-blocking)
    */
   async initialize() {
     try {
       const embeddingService2 = getEmbeddingService();
       await embeddingService2.initialize();
       this.embeddingInitialized = embeddingService2.isAvailable();
-      logger.info("SEARCH", `HybridSearch inizializzato (embedding: ${this.embeddingInitialized ? "attivo" : "disattivato"})`);
+      logger.info("SEARCH", `HybridSearch initialized (embedding: ${this.embeddingInitialized ? "active" : "disabled"})`);
     } catch (error) {
-      logger.warn("SEARCH", "Inizializzazione embedding fallita, uso solo FTS5", {}, error);
+      logger.warn("SEARCH", "Embedding initialization failed, using only FTS5", {}, error);
       this.embeddingInitialized = false;
     }
   }
   /**
-   * Ricerca ibrida con scoring a 4 segnali
+   * Hybrid search with 4-signal scoring
    */
   async search(db, query, options = {}) {
     const limit = options.limit || 10;
@@ -1636,7 +3172,7 @@ var HybridSearch = class {
           const vectorResults = await vectorSearch2.search(db, queryEmbedding, {
             project: options.project,
             limit: limit * 2,
-            // Prendiamo piu risultati per il ranking
+            // Fetch more results for ranking
             threshold: 0.3
           });
           for (const hit of vectorResults) {
@@ -1653,10 +3189,10 @@ var HybridSearch = class {
               source: "vector"
             });
           }
-          logger.debug("SEARCH", `Vector search: ${vectorResults.length} risultati`);
+          logger.debug("SEARCH", `Vector search: ${vectorResults.length} results`);
         }
       } catch (error) {
-        logger.warn("SEARCH", "Ricerca vettoriale fallita, uso solo keyword", {}, error);
+        logger.warn("SEARCH", "Vector search failed, using only keyword", {}, error);
       }
     }
     try {
@@ -1686,9 +3222,9 @@ var HybridSearch = class {
           });
         }
       }
-      logger.debug("SEARCH", `Keyword search: ${keywordResults.length} risultati`);
+      logger.debug("SEARCH", `Keyword search: ${keywordResults.length} results`);
     } catch (error) {
-      logger.error("SEARCH", "Ricerca keyword fallita", {}, error);
+      logger.error("SEARCH", "Keyword search failed", {}, error);
     }
     if (rawItems.size === 0) return [];
     const allFTS5Ranks = Array.from(rawItems.values()).filter((item) => item.fts5Rank !== null).map((item) => item.fts5Rank);
@@ -1743,11 +3279,6 @@ function getHybridSearch() {
 // src/sdk/index.ts
 init_EmbeddingService();
 init_logger();
-
-// src/types/worker-types.ts
-var KNOWLEDGE_TYPES = ["constraint", "decision", "heuristic", "rejected"];
-
-// src/sdk/index.ts
 var KiroMemorySDK = class {
   db;
   project;
@@ -1780,33 +3311,33 @@ var KiroMemorySDK = class {
     };
   }
   /**
-   * Valida input per storeObservation
+   * Validate input for storeObservation
    */
   validateObservationInput(data) {
     if (!data.type || typeof data.type !== "string" || data.type.length > 100) {
-      throw new Error("type \xE8 obbligatorio (stringa, max 100 caratteri)");
+      throw new Error("type is required (string, max 100 chars)");
     }
     if (!data.title || typeof data.title !== "string" || data.title.length > 500) {
-      throw new Error("title \xE8 obbligatorio (stringa, max 500 caratteri)");
+      throw new Error("title is required (string, max 500 chars)");
     }
     if (!data.content || typeof data.content !== "string" || data.content.length > 1e5) {
-      throw new Error("content \xE8 obbligatorio (stringa, max 100KB)");
+      throw new Error("content is required (string, max 100KB)");
     }
   }
   /**
-   * Valida input per storeSummary
+   * Validate input for storeSummary
    */
   validateSummaryInput(data) {
     const MAX = 5e4;
     for (const [key, val] of Object.entries(data)) {
       if (val !== void 0 && val !== null) {
-        if (typeof val !== "string") throw new Error(`${key} deve essere una stringa`);
-        if (val.length > MAX) throw new Error(`${key} troppo grande (max 50KB)`);
+        if (typeof val !== "string") throw new Error(`${key} must be a string`);
+        if (val.length > MAX) throw new Error(`${key} too large (max 50KB)`);
       }
     }
   }
   /**
-   * Genera e salva embedding per un'osservazione (fire-and-forget, non blocca)
+   * Generate and store embedding for an observation (fire-and-forget, non-blocking)
    */
   async generateEmbeddingAsync(observationId, title, content, concepts) {
     try {
@@ -1826,39 +3357,39 @@ var KiroMemorySDK = class {
         );
       }
     } catch (error) {
-      logger.debug("SDK", `Embedding generation fallita per obs ${observationId}: ${error}`);
+      logger.debug("SDK", `Embedding generation failed for obs ${observationId}: ${error}`);
     }
   }
   /**
-   * Genera content hash SHA256 per deduplicazione basata su contenuto.
-   * Usa (project + type + title + narrative) come tupla di identità semantica.
-   * NON include sessionId perché è unico ad ogni invocazione.
+   * Generate SHA256 content hash for content-based deduplication.
+   * Uses (project + type + title + narrative) as semantic identity tuple.
+   * Does NOT include sessionId since it's unique per invocation.
    */
   generateContentHash(type, title, narrative) {
     const payload = `${this.project}|${type}|${title}|${narrative || ""}`;
-    return createHash("sha256").update(payload).digest("hex");
+    return createHash2("sha256").update(payload).digest("hex");
   }
   /**
-   * Finestre di deduplicazione per tipo (ms).
-   * Tipi con molte ripetizioni hanno finestre più ampie.
+   * Deduplication windows per type (ms).
+   * Types with many repetitions have wider windows.
    */
   getDeduplicationWindow(type) {
     switch (type) {
       case "file-read":
         return 6e4;
-      // 60s — letture frequenti sugli stessi file
+      // 60s — frequent reads on the same files
       case "file-write":
         return 1e4;
-      // 10s — scritture rapide consecutive
+      // 10s — rapid consecutive writes
       case "command":
         return 3e4;
       // 30s — standard
       case "research":
         return 12e4;
-      // 120s — web search e fetch ripetuti
+      // 120s — repeated web search and fetch
       case "delegation":
         return 6e4;
-      // 60s — delegazioni rapide
+      // 60s — rapid delegations
       default:
         return 3e4;
     }
@@ -1872,7 +3403,7 @@ var KiroMemorySDK = class {
     const contentHash = this.generateContentHash(data.type, data.title, data.narrative);
     const dedupWindow = this.getDeduplicationWindow(data.type);
     if (isDuplicateObservation(this.db.db, contentHash, dedupWindow)) {
-      logger.debug("SDK", `Osservazione duplicata scartata (${data.type}, ${dedupWindow}ms): ${data.title}`);
+      logger.debug("SDK", `Duplicate observation discarded (${data.type}, ${dedupWindow}ms): ${data.title}`);
       return -1;
     }
     const filesRead = data.filesRead || (data.type === "file-read" ? data.files : void 0);
@@ -1900,12 +3431,12 @@ var KiroMemorySDK = class {
     return observationId;
   }
   /**
-   * Salva conoscenza strutturata (constraint, decision, heuristic, rejected).
-   * Usa il campo `type` per il knowledgeType e `facts` per i metadati JSON.
+   * Store structured knowledge (constraint, decision, heuristic, rejected).
+   * Uses the `type` field for knowledgeType and `facts` for JSON metadata.
    */
   async storeKnowledge(data) {
     if (!KNOWLEDGE_TYPES.includes(data.knowledgeType)) {
-      throw new Error(`knowledgeType non valido: ${data.knowledgeType}. Valori ammessi: ${KNOWLEDGE_TYPES.join(", ")}`);
+      throw new Error(`Invalid knowledgeType: ${data.knowledgeType}. Allowed values: ${KNOWLEDGE_TYPES.join(", ")}`);
     }
     this.validateObservationInput({ type: data.knowledgeType, title: data.title, content: data.content });
     const metadata = (() => {
@@ -1937,9 +3468,9 @@ var KiroMemorySDK = class {
       }
     })();
     const sessionId = "sdk-" + Date.now();
-    const contentHash = this.generateContentHash(data.type, data.title);
+    const contentHash = this.generateContentHash(data.knowledgeType, data.title);
     if (isDuplicateObservation(this.db.db, contentHash)) {
-      logger.debug("SDK", `Knowledge duplicata scartata: ${data.title}`);
+      logger.debug("SDK", `Duplicate knowledge discarded: ${data.title}`);
       return -1;
     }
     const discoveryTokens = Math.ceil(data.content.length / 4);
@@ -1956,11 +3487,11 @@ var KiroMemorySDK = class {
       null,
       // narrative
       JSON.stringify(metadata),
-      // facts = metadati JSON
+      // facts = JSON metadata
       data.concepts?.join(", ") || null,
       data.files?.join(", ") || null,
       null,
-      // filesModified: knowledge non modifica file
+      // filesModified: knowledge doesn't modify files
       0,
       // prompt_number
       contentHash,
@@ -2071,8 +3602,8 @@ var KiroMemorySDK = class {
     return this.project;
   }
   /**
-   * Ricerca ibrida: vector search + keyword FTS5
-   * Richiede inizializzazione HybridSearch (embedding service)
+   * Hybrid search: vector search + keyword FTS5
+   * Requires HybridSearch initialization (embedding service)
    */
   async hybridSearch(query, options = {}) {
     const hybridSearch2 = getHybridSearch();
@@ -2082,8 +3613,8 @@ var KiroMemorySDK = class {
     });
   }
   /**
-   * Ricerca solo semantica (vector search)
-   * Ritorna risultati basati su similarità coseno con gli embeddings
+   * Semantic-only search (vector search)
+   * Returns results based on cosine similarity with embeddings
    */
   async semanticSearch(query, options = {}) {
     const embeddingService2 = getEmbeddingService();
@@ -2118,21 +3649,21 @@ var KiroMemorySDK = class {
     }));
   }
   /**
-   * Genera embeddings per osservazioni che non li hanno ancora
+   * Generate embeddings for observations that don't have them yet
    */
   async backfillEmbeddings(batchSize = 50) {
     const vectorSearch2 = getVectorSearch();
     return vectorSearch2.backfillEmbeddings(this.db.db, batchSize);
   }
   /**
-   * Statistiche sugli embeddings nel database
+   * Embedding statistics in the database
    */
   getEmbeddingStats() {
     const vectorSearch2 = getVectorSearch();
     return vectorSearch2.getStats(this.db.db);
   }
   /**
-   * Inizializza il servizio di embedding (lazy, chiamare prima di hybridSearch)
+   * Initialize the embedding service (lazy, call before hybridSearch)
    */
   async initializeEmbeddings() {
     const hybridSearch2 = getHybridSearch();
@@ -2140,10 +3671,10 @@ var KiroMemorySDK = class {
     return getEmbeddingService().isAvailable();
   }
   /**
-   * Contesto smart con ranking a 4 segnali e budget token.
+   * Smart context with 4-signal ranking and token budget.
    *
-   * Se query presente: usa HybridSearch con SEARCH_WEIGHTS.
-   * Se senza query: ranking per recency + project match (CONTEXT_WEIGHTS).
+   * If query present: uses HybridSearch with SEARCH_WEIGHTS.
+   * If no query: ranking by recency + project match (CONTEXT_WEIGHTS).
    */
   async getSmartContext(options = {}) {
     const tokenBudget = options.tokenBudget || parseInt(process.env.KIRO_MEMORY_CONTEXT_TOKENS || "0", 10) || 2e3;
@@ -2217,8 +3748,8 @@ var KiroMemorySDK = class {
     };
   }
   /**
-   * Rileva osservazioni stale (file modificati dopo la creazione) e le marca nel DB.
-   * Ritorna il numero di osservazioni marcate come stale.
+   * Detect stale observations (files modified after creation) and mark them in DB.
+   * Returns the number of observations marked as stale.
    */
   async detectStaleObservations() {
     const staleObs = getStaleObservations(this.db.db, this.project);
@@ -2229,14 +3760,14 @@ var KiroMemorySDK = class {
     return staleObs.length;
   }
   /**
-   * Consolida osservazioni duplicate sullo stesso file e tipo.
-   * Raggruppa per (project, type, files_modified), mantiene la piu recente.
+   * Consolidate duplicate observations on the same file and type.
+   * Groups by (project, type, files_modified), keeps the most recent.
    */
   async consolidateObservations(options = {}) {
     return consolidateObservations(this.db.db, this.project, options);
   }
   /**
-   * Statistiche decay: totale, stale, mai accedute, accedute di recente.
+   * Decay statistics: total, stale, never accessed, recently accessed.
    */
   async getDecayStats() {
     const total = this.db.db.query(
@@ -2255,8 +3786,8 @@ var KiroMemorySDK = class {
     return { total, stale, neverAccessed, recentlyAccessed };
   }
   /**
-   * Crea un checkpoint strutturato per resume sessione.
-   * Salva automaticamente un context_snapshot con le ultime 10 osservazioni.
+   * Create a structured checkpoint for session resume.
+   * Automatically saves a context_snapshot with the last 10 observations.
    */
   async createCheckpoint(sessionId, data) {
     const recentObs = getObservationsByProject(this.db.db, this.project, 10);
@@ -2273,21 +3804,21 @@ var KiroMemorySDK = class {
     });
   }
   /**
-   * Recupera l'ultimo checkpoint di una sessione specifica.
+   * Retrieve the latest checkpoint of a specific session.
    */
   async getCheckpoint(sessionId) {
     return getLatestCheckpoint(this.db.db, sessionId);
   }
   /**
-   * Recupera l'ultimo checkpoint per il progetto corrente.
-   * Utile per resume automatico senza specificare session ID.
+   * Retrieve the latest checkpoint for the current project.
+   * Useful for automatic resume without specifying session ID.
    */
   async getLatestProjectCheckpoint() {
     return getLatestCheckpointByProject(this.db.db, this.project);
   }
   /**
-   * Genera un report di attività per il progetto corrente.
-   * Aggrega osservazioni, sessioni, summaries e file per un periodo temporale.
+   * Generate an activity report for the current project.
+   * Aggregates observations, sessions, summaries and files for a time period.
    */
   async generateReport(options) {
     const now = /* @__PURE__ */ new Date();
@@ -2303,6 +3834,66 @@ var KiroMemorySDK = class {
     }
     return getReportData(this.db.db, this.project, startEpoch, endEpoch);
   }
+  /**
+   * Lista osservazioni con keyset pagination.
+   * Restituisce un oggetto { data, next_cursor, has_more }.
+   *
+   * Esempio:
+   *   const page1 = await sdk.listObservations({ limit: 50 });
+   *   const page2 = await sdk.listObservations({ cursor: page1.next_cursor });
+   */
+  async listObservations(options = {}) {
+    const limit = Math.min(Math.max(options.limit ?? 50, 1), 200);
+    const project = options.project ?? this.project;
+    let rows;
+    if (options.cursor) {
+      const decoded = decodeCursor(options.cursor);
+      if (!decoded) throw new Error("Cursor non valido");
+      const sql = project ? `SELECT * FROM observations
+           WHERE project = ? AND (created_at_epoch < ? OR (created_at_epoch = ? AND id < ?))
+           ORDER BY created_at_epoch DESC, id DESC
+           LIMIT ?` : `SELECT * FROM observations
+           WHERE (created_at_epoch < ? OR (created_at_epoch = ? AND id < ?))
+           ORDER BY created_at_epoch DESC, id DESC
+           LIMIT ?`;
+      rows = project ? this.db.db.query(sql).all(project, decoded.epoch, decoded.epoch, decoded.id, limit) : this.db.db.query(sql).all(decoded.epoch, decoded.epoch, decoded.id, limit);
+    } else {
+      const sql = project ? "SELECT * FROM observations WHERE project = ? ORDER BY created_at_epoch DESC, id DESC LIMIT ?" : "SELECT * FROM observations ORDER BY created_at_epoch DESC, id DESC LIMIT ?";
+      rows = project ? this.db.db.query(sql).all(project, limit) : this.db.db.query(sql).all(limit);
+    }
+    const next_cursor = rows.length >= limit ? encodeCursor(rows[rows.length - 1].id, rows[rows.length - 1].created_at_epoch) : null;
+    return { data: rows, next_cursor, has_more: next_cursor !== null };
+  }
+  /**
+   * Lista sommari con keyset pagination.
+   * Restituisce un oggetto { data, next_cursor, has_more }.
+   *
+   * Esempio:
+   *   const page1 = await sdk.listSummaries({ limit: 20 });
+   *   const page2 = await sdk.listSummaries({ cursor: page1.next_cursor });
+   */
+  async listSummaries(options = {}) {
+    const limit = Math.min(Math.max(options.limit ?? 20, 1), 200);
+    const project = options.project ?? this.project;
+    let rows;
+    if (options.cursor) {
+      const decoded = decodeCursor(options.cursor);
+      if (!decoded) throw new Error("Cursor non valido");
+      const sql = project ? `SELECT * FROM summaries
+           WHERE project = ? AND (created_at_epoch < ? OR (created_at_epoch = ? AND id < ?))
+           ORDER BY created_at_epoch DESC, id DESC
+           LIMIT ?` : `SELECT * FROM summaries
+           WHERE (created_at_epoch < ? OR (created_at_epoch = ? AND id < ?))
+           ORDER BY created_at_epoch DESC, id DESC
+           LIMIT ?`;
+      rows = project ? this.db.db.query(sql).all(project, decoded.epoch, decoded.epoch, decoded.id, limit) : this.db.db.query(sql).all(decoded.epoch, decoded.epoch, decoded.id, limit);
+    } else {
+      const sql = project ? "SELECT * FROM summaries WHERE project = ? ORDER BY created_at_epoch DESC, id DESC LIMIT ?" : "SELECT * FROM summaries ORDER BY created_at_epoch DESC, id DESC LIMIT ?";
+      rows = project ? this.db.db.query(sql).all(project, limit) : this.db.db.query(sql).all(limit);
+    }
+    const next_cursor = rows.length >= limit ? encodeCursor(rows[rows.length - 1].id, rows[rows.length - 1].created_at_epoch) : null;
+    return { data: rows, next_cursor, has_more: next_cursor !== null };
+  }
   /**
    * Getter for direct database access (for API routes)
    */
@@ -2549,12 +4140,15 @@ function printBanner(opts) {
 }
 
 // src/cli/contextkit.ts
+init_cli_utils();
+init_Observations();
 import { execSync } from "child_process";
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync, appendFileSync as appendFileSync2 } from "fs";
-import { join as join3, dirname as dirname2 } from "path";
-import { homedir as homedir3, platform, release } from "os";
+import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3, appendFileSync as appendFileSync2 } from "fs";
+import { join as join5, dirname as dirname2 } from "path";
+import { homedir as homedir4, platform, release } from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { createInterface } from "readline";
+import * as http from "http";
 var args = process.argv.slice(2);
 var command = args[0];
 var __filename = fileURLToPath2(import.meta.url);
@@ -2562,8 +4156,8 @@ var __dirname2 = dirname2(__filename);
 var DIST_DIR = dirname2(__dirname2);
 var PKG_VERSION = "unknown";
 try {
-  const pkgPath = join3(DIST_DIR, "..", "..", "package.json");
-  PKG_VERSION = JSON.parse(readFileSync2(pkgPath, "utf8")).version;
+  const pkgPath = join5(DIST_DIR, "..", "..", "package.json");
+  PKG_VERSION = JSON.parse(readFileSync4(pkgPath, "utf8")).version;
 } catch {
 }
 var AGENT_TEMPLATE = JSON.stringify({
@@ -2617,8 +4211,8 @@ function isWSL() {
   try {
     const rel = release().toLowerCase();
     if (rel.includes("microsoft") || rel.includes("wsl")) return true;
-    if (existsSync4("/proc/version")) {
-      const proc = readFileSync2("/proc/version", "utf8").toLowerCase();
+    if (existsSync6("/proc/version")) {
+      const proc = readFileSync4("/proc/version", "utf8").toLowerCase();
       return proc.includes("microsoft") || proc.includes("wsl");
     }
     return false;
@@ -2757,9 +4351,9 @@ function askUser(question) {
 }
 function detectShellRc() {
   const shell = process.env.SHELL || "/bin/bash";
-  if (shell.includes("zsh")) return { name: "zsh", rcFile: join3(homedir3(), ".zshrc") };
-  if (shell.includes("fish")) return { name: "fish", rcFile: join3(homedir3(), ".config/fish/config.fish") };
-  return { name: "bash", rcFile: join3(homedir3(), ".bashrc") };
+  if (shell.includes("zsh")) return { name: "zsh", rcFile: join5(homedir4(), ".zshrc") };
+  if (shell.includes("fish")) return { name: "fish", rcFile: join5(homedir4(), ".config/fish/config.fish") };
+  return { name: "bash", rcFile: join5(homedir4(), ".bashrc") };
 }
 var AUTOFIXABLE_CHECKS = /* @__PURE__ */ new Set([
   "WSL: npm global prefix",
@@ -2789,14 +4383,14 @@ async function tryAutoFix(failedChecks) {
   if (prefixCheck) {
     console.log("  Fixing npm global prefix...");
     try {
-      const npmGlobalDir = join3(homedir3(), ".npm-global");
-      mkdirSync3(npmGlobalDir, { recursive: true });
+      const npmGlobalDir = join5(homedir4(), ".npm-global");
+      mkdirSync5(npmGlobalDir, { recursive: true });
       const { spawnSync: spawnNpmConfig } = __require("child_process");
       spawnNpmConfig("npm", ["config", "set", "prefix", npmGlobalDir], { stdio: "ignore" });
       const exportLine = 'export PATH="$HOME/.npm-global/bin:$PATH"';
       let alreadyInRc = false;
-      if (existsSync4(rcFile)) {
-        const content = readFileSync2(rcFile, "utf8");
+      if (existsSync6(rcFile)) {
+        const content = readFileSync4(rcFile, "utf8");
         alreadyInRc = content.includes(".npm-global/bin");
       }
       if (!alreadyInRc) {
@@ -2816,9 +4410,9 @@ ${exportLine}
   const npmBinaryCheck = fixable.find((c) => c.name === "WSL: npm binary");
   if (npmBinaryCheck) {
     console.log("\n  Fixing npm binary (installing nvm + Node.js 22)...");
-    const nvmDir = join3(homedir3(), ".nvm");
+    const nvmDir = join5(homedir4(), ".nvm");
     try {
-      if (existsSync4(nvmDir)) {
+      if (existsSync6(nvmDir)) {
         console.log(`  nvm already installed at ${nvmDir}`);
       } else {
         console.log("  Downloading nvm...");
@@ -2866,8 +4460,8 @@ ${exportLine}
       const { spawnSync: spawnRebuild } = __require("child_process");
       const globalDirResult = spawnRebuild("npm", ["prefix", "-g"], { encoding: "utf8", stdio: ["pipe", "pipe", "ignore"] });
       const globalDir = (globalDirResult.stdout || "").trim();
-      const sqlitePkg = join3(globalDir, "lib", "node_modules", "kiro-memory");
-      if (existsSync4(sqlitePkg)) {
+      const sqlitePkg = join5(globalDir, "lib", "node_modules", "kiro-memory");
+      if (existsSync6(sqlitePkg)) {
         spawnRebuild("npm", ["rebuild", "better-sqlite3"], {
           cwd: sqlitePkg,
           stdio: "inherit",
@@ -2915,44 +4509,44 @@ async function installKiro() {
     }
   }
   const distDir = DIST_DIR;
-  const kiroDir = process.env.KIRO_CONFIG_DIR || join3(homedir3(), ".kiro");
-  const agentsDir = join3(kiroDir, "agents");
-  const settingsDir = join3(kiroDir, "settings");
-  const steeringDir = join3(kiroDir, "steering");
-  const dataDir = process.env.KIRO_MEMORY_DATA_DIR || process.env.CONTEXTKIT_DATA_DIR || join3(homedir3(), ".contextkit");
+  const kiroDir = process.env.KIRO_CONFIG_DIR || join5(homedir4(), ".kiro");
+  const agentsDir = join5(kiroDir, "agents");
+  const settingsDir = join5(kiroDir, "settings");
+  const steeringDir = join5(kiroDir, "steering");
+  const dataDir = process.env.KIRO_MEMORY_DATA_DIR || process.env.CONTEXTKIT_DATA_DIR || join5(homedir4(), ".contextkit");
   console.log("[2/4] Installing Kiro configuration...\n");
   for (const dir of [agentsDir, settingsDir, steeringDir, dataDir]) {
-    mkdirSync3(dir, { recursive: true });
+    mkdirSync5(dir, { recursive: true });
   }
   const agentConfig = AGENT_TEMPLATE.replace(/__DIST_DIR__/g, distDir);
-  const agentDestPath = join3(agentsDir, "kiro-memory.json");
-  writeFileSync(agentDestPath, agentConfig, "utf8");
+  const agentDestPath = join5(agentsDir, "kiro-memory.json");
+  writeFileSync3(agentDestPath, agentConfig, "utf8");
   console.log(`  \u2192 Agent config: ${agentDestPath}`);
-  const mcpFilePath = join3(settingsDir, "mcp.json");
+  const mcpFilePath = join5(settingsDir, "mcp.json");
   let mcpConfig = { mcpServers: {} };
-  if (existsSync4(mcpFilePath)) {
+  if (existsSync6(mcpFilePath)) {
     try {
-      mcpConfig = JSON.parse(readFileSync2(mcpFilePath, "utf8"));
+      mcpConfig = JSON.parse(readFileSync4(mcpFilePath, "utf8"));
       if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
     } catch {
     }
   }
   mcpConfig.mcpServers["kiro-memory"] = {
     command: "node",
-    args: [join3(distDir, "servers", "mcp-server.js")]
+    args: [join5(distDir, "servers", "mcp-server.js")]
   };
-  writeFileSync(mcpFilePath, JSON.stringify(mcpConfig, null, 2), "utf8");
+  writeFileSync3(mcpFilePath, JSON.stringify(mcpConfig, null, 2), "utf8");
   console.log(`  \u2192 MCP config:   ${mcpFilePath}`);
-  const steeringDestPath = join3(steeringDir, "kiro-memory.md");
-  writeFileSync(steeringDestPath, STEERING_CONTENT, "utf8");
+  const steeringDestPath = join5(steeringDir, "kiro-memory.md");
+  writeFileSync3(steeringDestPath, STEERING_CONTENT, "utf8");
   console.log(`  \u2192 Steering:     ${steeringDestPath}`);
   console.log(`  \u2192 Data dir:     ${dataDir}`);
   console.log("\n[3/4] Shell alias setup\n");
   const { rcFile } = detectShellRc();
   const aliasLine = 'alias kiro="kiro-cli --agent kiro-memory"';
   let aliasAlreadySet = false;
-  if (existsSync4(rcFile)) {
-    const rcContent = readFileSync2(rcFile, "utf8");
+  if (existsSync6(rcFile)) {
+    const rcContent = readFileSync4(rcFile, "utf8");
     aliasAlreadySet = rcContent.includes("alias kiro=") && rcContent.includes("kiro-memory");
   }
   if (aliasAlreadySet) {
@@ -3059,16 +4653,16 @@ async function installClaudeCode() {
     }
   }
   const distDir = DIST_DIR;
-  const claudeDir = join3(homedir3(), ".claude");
-  const dataDir = process.env.KIRO_MEMORY_DATA_DIR || process.env.CONTEXTKIT_DATA_DIR || join3(homedir3(), ".kiro-memory");
+  const claudeDir = join5(homedir4(), ".claude");
+  const dataDir = process.env.KIRO_MEMORY_DATA_DIR || process.env.CONTEXTKIT_DATA_DIR || join5(homedir4(), ".kiro-memory");
   console.log("[2/3] Installing Claude Code configuration...\n");
-  mkdirSync3(claudeDir, { recursive: true });
-  mkdirSync3(dataDir, { recursive: true });
-  const settingsPath = join3(claudeDir, "settings.json");
+  mkdirSync5(claudeDir, { recursive: true });
+  mkdirSync5(dataDir, { recursive: true });
+  const settingsPath = join5(claudeDir, "settings.json");
   let settings = {};
-  if (existsSync4(settingsPath)) {
+  if (existsSync6(settingsPath)) {
     try {
-      settings = JSON.parse(readFileSync2(settingsPath, "utf8"));
+      settings = JSON.parse(readFileSync4(settingsPath, "utf8"));
     } catch {
     }
   }
@@ -3083,7 +4677,7 @@ async function installClaudeCode() {
       matcher: "",
       hooks: [{
         type: "command",
-        command: `node ${join3(distDir, config.script)}`,
+        command: `node ${join5(distDir, config.script)}`,
         timeout: config.timeout
       }]
     };
@@ -3098,31 +4692,31 @@ async function installClaudeCode() {
       settings[event].push(hookEntry);
     }
   }
-  writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf8");
+  writeFileSync3(settingsPath, JSON.stringify(settings, null, 2), "utf8");
   console.log(`  \u2192 Hooks config: ${settingsPath}`);
-  const mcpPath = join3(homedir3(), ".mcp.json");
+  const mcpPath = join5(homedir4(), ".mcp.json");
   let mcpConfig = {};
-  if (existsSync4(mcpPath)) {
+  if (existsSync6(mcpPath)) {
     try {
-      mcpConfig = JSON.parse(readFileSync2(mcpPath, "utf8"));
+      mcpConfig = JSON.parse(readFileSync4(mcpPath, "utf8"));
     } catch {
     }
   }
   if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
   mcpConfig.mcpServers["kiro-memory"] = {
     command: "node",
-    args: [join3(distDir, "servers", "mcp-server.js")]
+    args: [join5(distDir, "servers", "mcp-server.js")]
   };
-  writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf8");
+  writeFileSync3(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf8");
   console.log(`  \u2192 MCP config:   ${mcpPath}`);
-  const steeringPath = join3(claudeDir, "CLAUDE.md");
+  const steeringPath = join5(claudeDir, "CLAUDE.md");
   let existingSteering = "";
-  if (existsSync4(steeringPath)) {
-    existingSteering = readFileSync2(steeringPath, "utf8");
+  if (existsSync6(steeringPath)) {
+    existingSteering = readFileSync4(steeringPath, "utf8");
   }
   if (!existingSteering.includes("Kiro Memory")) {
     const separator = existingSteering.length > 0 ? "\n\n---\n\n" : "";
-    writeFileSync(steeringPath, existingSteering + separator + CLAUDE_CODE_STEERING, "utf8");
+    writeFileSync3(steeringPath, existingSteering + separator + CLAUDE_CODE_STEERING, "utf8");
     console.log(`  \u2192 Steering:     ${steeringPath}`);
   } else {
     console.log(`  \u2192 Steering:     ${steeringPath} (already configured)`);
@@ -3166,16 +4760,16 @@ async function installCursor() {
     }
   }
   const distDir = DIST_DIR;
-  const cursorDir = join3(homedir3(), ".cursor");
-  const dataDir = process.env.KIRO_MEMORY_DATA_DIR || process.env.CONTEXTKIT_DATA_DIR || join3(homedir3(), ".kiro-memory");
+  const cursorDir = join5(homedir4(), ".cursor");
+  const dataDir = process.env.KIRO_MEMORY_DATA_DIR || process.env.CONTEXTKIT_DATA_DIR || join5(homedir4(), ".kiro-memory");
   console.log("[2/3] Installing Cursor configuration...\n");
-  mkdirSync3(cursorDir, { recursive: true });
-  mkdirSync3(dataDir, { recursive: true });
-  const hooksPath = join3(cursorDir, "hooks.json");
+  mkdirSync5(cursorDir, { recursive: true });
+  mkdirSync5(dataDir, { recursive: true });
+  const hooksPath = join5(cursorDir, "hooks.json");
   let hooksConfig = { version: 1, hooks: {} };
-  if (existsSync4(hooksPath)) {
+  if (existsSync6(hooksPath)) {
     try {
-      hooksConfig = JSON.parse(readFileSync2(hooksPath, "utf8"));
+      hooksConfig = JSON.parse(readFileSync4(hooksPath, "utf8"));
       if (!hooksConfig.hooks) hooksConfig.hooks = {};
       if (!hooksConfig.version) hooksConfig.version = 1;
     } catch {
@@ -3191,7 +4785,7 @@ async function installCursor() {
   };
   for (const [event, script] of Object.entries(cursorHookMap)) {
     const hookEntry = {
-      command: `node ${join3(distDir, script)}`
+      command: `node ${join5(distDir, script)}`
     };
     if (!hooksConfig.hooks[event]) {
       hooksConfig.hooks[event] = [hookEntry];
@@ -3202,22 +4796,22 @@ async function installCursor() {
       hooksConfig.hooks[event].push(hookEntry);
     }
   }
-  writeFileSync(hooksPath, JSON.stringify(hooksConfig, null, 2), "utf8");
+  writeFileSync3(hooksPath, JSON.stringify(hooksConfig, null, 2), "utf8");
   console.log(`  \u2192 Hooks config: ${hooksPath}`);
-  const mcpPath = join3(cursorDir, "mcp.json");
+  const mcpPath = join5(cursorDir, "mcp.json");
   let mcpConfig = {};
-  if (existsSync4(mcpPath)) {
+  if (existsSync6(mcpPath)) {
     try {
-      mcpConfig = JSON.parse(readFileSync2(mcpPath, "utf8"));
+      mcpConfig = JSON.parse(readFileSync4(mcpPath, "utf8"));
     } catch {
     }
   }
   if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
   mcpConfig.mcpServers["kiro-memory"] = {
     command: "node",
-    args: [join3(distDir, "servers", "mcp-server.js")]
+    args: [join5(distDir, "servers", "mcp-server.js")]
   };
-  writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf8");
+  writeFileSync3(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf8");
   console.log(`  \u2192 MCP config:   ${mcpPath}`);
   console.log(`  \u2192 Data dir:     ${dataDir}`);
   console.log("\n[3/3] Done!\n");
@@ -3257,25 +4851,25 @@ async function installWindsurf() {
     }
   }
   const distDir = DIST_DIR;
-  const dataDir = process.env.KIRO_MEMORY_DATA_DIR || process.env.CONTEXTKIT_DATA_DIR || join3(homedir3(), ".kiro-memory");
+  const dataDir = process.env.KIRO_MEMORY_DATA_DIR || process.env.CONTEXTKIT_DATA_DIR || join5(homedir4(), ".kiro-memory");
   console.log("[2/3] Installing Windsurf configuration...\n");
-  mkdirSync3(dataDir, { recursive: true });
-  const windsurfDir = join3(homedir3(), ".codeium", "windsurf");
-  mkdirSync3(windsurfDir, { recursive: true });
-  const mcpPath = join3(windsurfDir, "mcp_config.json");
+  mkdirSync5(dataDir, { recursive: true });
+  const windsurfDir = join5(homedir4(), ".codeium", "windsurf");
+  mkdirSync5(windsurfDir, { recursive: true });
+  const mcpPath = join5(windsurfDir, "mcp_config.json");
   let mcpConfig = {};
-  if (existsSync4(mcpPath)) {
+  if (existsSync6(mcpPath)) {
     try {
-      mcpConfig = JSON.parse(readFileSync2(mcpPath, "utf8"));
+      mcpConfig = JSON.parse(readFileSync4(mcpPath, "utf8"));
     } catch {
     }
   }
   if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
   mcpConfig.mcpServers["kiro-memory"] = {
     command: "node",
-    args: [join3(distDir, "servers", "mcp-server.js")]
+    args: [join5(distDir, "servers", "mcp-server.js")]
   };
-  writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf8");
+  writeFileSync3(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf8");
   console.log(`  \u2192 MCP config:   ${mcpPath}`);
   console.log(`  \u2192 Data dir:     ${dataDir}`);
   console.log("\n[3/3] Done!\n");
@@ -3316,31 +4910,31 @@ async function installCline() {
     }
   }
   const distDir = DIST_DIR;
-  const dataDir = process.env.KIRO_MEMORY_DATA_DIR || process.env.CONTEXTKIT_DATA_DIR || join3(homedir3(), ".kiro-memory");
+  const dataDir = process.env.KIRO_MEMORY_DATA_DIR || process.env.CONTEXTKIT_DATA_DIR || join5(homedir4(), ".kiro-memory");
   console.log("[2/3] Installing Cline configuration...\n");
-  mkdirSync3(dataDir, { recursive: true });
+  mkdirSync5(dataDir, { recursive: true });
   const platform2 = process.platform;
   let clineSettingsDir;
   if (platform2 === "darwin") {
-    clineSettingsDir = join3(homedir3(), "Library", "Application Support", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings");
+    clineSettingsDir = join5(homedir4(), "Library", "Application Support", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings");
   } else {
-    clineSettingsDir = join3(homedir3(), ".config", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings");
+    clineSettingsDir = join5(homedir4(), ".config", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings");
   }
-  mkdirSync3(clineSettingsDir, { recursive: true });
-  const mcpPath = join3(clineSettingsDir, "cline_mcp_settings.json");
+  mkdirSync5(clineSettingsDir, { recursive: true });
+  const mcpPath = join5(clineSettingsDir, "cline_mcp_settings.json");
   let mcpConfig = {};
-  if (existsSync4(mcpPath)) {
+  if (existsSync6(mcpPath)) {
     try {
-      mcpConfig = JSON.parse(readFileSync2(mcpPath, "utf8"));
+      mcpConfig = JSON.parse(readFileSync4(mcpPath, "utf8"));
     } catch {
     }
   }
   if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
   mcpConfig.mcpServers["kiro-memory"] = {
     command: "node",
-    args: [join3(distDir, "servers", "mcp-server.js")]
+    args: [join5(distDir, "servers", "mcp-server.js")]
   };
-  writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf8");
+  writeFileSync3(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf8");
   console.log(`  \u2192 MCP config:   ${mcpPath}`);
   console.log(`  \u2192 Data dir:     ${dataDir}`);
   console.log("\n[3/3] Done!\n");
@@ -3359,20 +4953,20 @@ async function installCline() {
 async function runDoctor() {
   console.log("\n=== Kiro Memory - Diagnostics ===");
   const checks = runEnvironmentChecks();
-  const kiroDir = process.env.KIRO_CONFIG_DIR || join3(homedir3(), ".kiro");
-  const agentPath = join3(kiroDir, "agents", "kiro-memory.json");
-  const mcpPath = join3(kiroDir, "settings", "mcp.json");
-  const dataDir = process.env.KIRO_MEMORY_DATA_DIR || process.env.CONTEXTKIT_DATA_DIR || join3(homedir3(), ".contextkit");
+  const kiroDir = process.env.KIRO_CONFIG_DIR || join5(homedir4(), ".kiro");
+  const agentPath = join5(kiroDir, "agents", "kiro-memory.json");
+  const mcpPath = join5(kiroDir, "settings", "mcp.json");
+  const dataDir = process.env.KIRO_MEMORY_DATA_DIR || process.env.CONTEXTKIT_DATA_DIR || join5(homedir4(), ".contextkit");
   checks.push({
     name: "Kiro agent config",
-    ok: existsSync4(agentPath),
-    message: existsSync4(agentPath) ? agentPath : "Not found",
-    fix: !existsSync4(agentPath) ? "Run: kiro-memory install" : void 0
+    ok: existsSync6(agentPath),
+    message: existsSync6(agentPath) ? agentPath : "Not found",
+    fix: !existsSync6(agentPath) ? "Run: kiro-memory install" : void 0
   });
   let mcpOk = false;
-  if (existsSync4(mcpPath)) {
+  if (existsSync6(mcpPath)) {
     try {
-      const mcp = JSON.parse(readFileSync2(mcpPath, "utf8"));
+      const mcp = JSON.parse(readFileSync4(mcpPath, "utf8"));
       mcpOk = !!mcp.mcpServers?.["kiro-memory"] || !!mcp.mcpServers?.contextkit;
     } catch {
     }
@@ -3385,15 +4979,15 @@ async function runDoctor() {
   });
   checks.push({
     name: "Data directory",
-    ok: existsSync4(dataDir),
-    message: existsSync4(dataDir) ? dataDir : "Not created (will be created on first use)"
+    ok: existsSync6(dataDir),
+    message: existsSync6(dataDir) ? dataDir : "Not created (will be created on first use)"
   });
-  const claudeDir = join3(homedir3(), ".claude");
-  const claudeSettingsPath = join3(claudeDir, "settings.json");
+  const claudeDir = join5(homedir4(), ".claude");
+  const claudeSettingsPath = join5(claudeDir, "settings.json");
   let claudeHooksOk = false;
-  if (existsSync4(claudeSettingsPath)) {
+  if (existsSync6(claudeSettingsPath)) {
     try {
-      const claudeSettings = JSON.parse(readFileSync2(claudeSettingsPath, "utf8"));
+      const claudeSettings = JSON.parse(readFileSync4(claudeSettingsPath, "utf8"));
       claudeHooksOk = !!(claudeSettings?.SessionStart || claudeSettings?.PostToolUse);
       if (claudeHooksOk) {
         const allSettings = JSON.stringify(claudeSettings);
@@ -3402,11 +4996,11 @@ async function runDoctor() {
     } catch {
     }
   }
-  const claudeMcpPath = join3(homedir3(), ".mcp.json");
+  const claudeMcpPath = join5(homedir4(), ".mcp.json");
   let claudeMcpOk = false;
-  if (existsSync4(claudeMcpPath)) {
+  if (existsSync6(claudeMcpPath)) {
     try {
-      const claudeMcp = JSON.parse(readFileSync2(claudeMcpPath, "utf8"));
+      const claudeMcp = JSON.parse(readFileSync4(claudeMcpPath, "utf8"));
       claudeMcpOk = !!claudeMcp.mcpServers?.["kiro-memory"];
     } catch {
     }
@@ -3414,21 +5008,21 @@ async function runDoctor() {
   checks.push({
     name: "Claude Code hooks",
     ok: true,
-    // Non-blocking: installazione opzionale
+    // Non-blocking: optional installation
     message: claudeHooksOk ? "Configured in ~/.claude/settings.json" : "Not configured (optional: run kiro-memory install --claude-code)"
   });
   checks.push({
     name: "Claude Code MCP",
     ok: true,
-    // Non-blocking: installazione opzionale
+    // Non-blocking: optional installation
     message: claudeMcpOk ? "kiro-memory registered in ~/.mcp.json" : "Not configured (optional: run kiro-memory install --claude-code)"
   });
-  const cursorDir = join3(homedir3(), ".cursor");
-  const cursorHooksPath = join3(cursorDir, "hooks.json");
+  const cursorDir = join5(homedir4(), ".cursor");
+  const cursorHooksPath = join5(cursorDir, "hooks.json");
   let cursorHooksOk = false;
-  if (existsSync4(cursorHooksPath)) {
+  if (existsSync6(cursorHooksPath)) {
     try {
-      const cursorHooks = JSON.parse(readFileSync2(cursorHooksPath, "utf8"));
+      const cursorHooks = JSON.parse(readFileSync4(cursorHooksPath, "utf8"));
       cursorHooksOk = !!(cursorHooks.hooks?.sessionStart || cursorHooks.hooks?.afterFileEdit);
       if (cursorHooksOk) {
         const allHooks = JSON.stringify(cursorHooks.hooks);
@@ -3437,11 +5031,11 @@ async function runDoctor() {
     } catch {
     }
   }
-  const cursorMcpPath = join3(cursorDir, "mcp.json");
+  const cursorMcpPath = join5(cursorDir, "mcp.json");
   let cursorMcpOk = false;
-  if (existsSync4(cursorMcpPath)) {
+  if (existsSync6(cursorMcpPath)) {
     try {
-      const cursorMcp = JSON.parse(readFileSync2(cursorMcpPath, "utf8"));
+      const cursorMcp = JSON.parse(readFileSync4(cursorMcpPath, "utf8"));
       cursorMcpOk = !!cursorMcp.mcpServers?.["kiro-memory"];
     } catch {
     }
@@ -3449,20 +5043,20 @@ async function runDoctor() {
   checks.push({
     name: "Cursor hooks",
     ok: true,
-    // Non-blocking: installazione opzionale
+    // Non-blocking: optional installation
     message: cursorHooksOk ? "Configured in ~/.cursor/hooks.json" : "Not configured (optional: run kiro-memory install --cursor)"
   });
   checks.push({
     name: "Cursor MCP",
     ok: true,
-    // Non-blocking: installazione opzionale
+    // Non-blocking: optional installation
     message: cursorMcpOk ? "kiro-memory registered in ~/.cursor/mcp.json" : "Not configured (optional: run kiro-memory install --cursor)"
   });
-  const windsurfMcpPath = join3(homedir3(), ".codeium", "windsurf", "mcp_config.json");
+  const windsurfMcpPath = join5(homedir4(), ".codeium", "windsurf", "mcp_config.json");
   let windsurfMcpOk = false;
-  if (existsSync4(windsurfMcpPath)) {
+  if (existsSync6(windsurfMcpPath)) {
     try {
-      const windsurfMcp = JSON.parse(readFileSync2(windsurfMcpPath, "utf8"));
+      const windsurfMcp = JSON.parse(readFileSync4(windsurfMcpPath, "utf8"));
       windsurfMcpOk = !!windsurfMcp.mcpServers?.["kiro-memory"];
     } catch {
     }
@@ -3470,21 +5064,21 @@ async function runDoctor() {
   checks.push({
     name: "Windsurf MCP",
     ok: true,
-    // Non-blocking: installazione opzionale
+    // Non-blocking: optional installation
     message: windsurfMcpOk ? "kiro-memory registered in ~/.codeium/windsurf/mcp_config.json" : "Not configured (optional: run kiro-memory install --windsurf)"
   });
   const clinePlatform = process.platform;
   let clineSettingsBase;
   if (clinePlatform === "darwin") {
-    clineSettingsBase = join3(homedir3(), "Library", "Application Support", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings");
+    clineSettingsBase = join5(homedir4(), "Library", "Application Support", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings");
   } else {
-    clineSettingsBase = join3(homedir3(), ".config", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings");
+    clineSettingsBase = join5(homedir4(), ".config", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings");
   }
-  const clineMcpPath = join3(clineSettingsBase, "cline_mcp_settings.json");
+  const clineMcpPath = join5(clineSettingsBase, "cline_mcp_settings.json");
   let clineMcpOk = false;
-  if (existsSync4(clineMcpPath)) {
+  if (existsSync6(clineMcpPath)) {
     try {
-      const clineMcp = JSON.parse(readFileSync2(clineMcpPath, "utf8"));
+      const clineMcp = JSON.parse(readFileSync4(clineMcpPath, "utf8"));
       clineMcpOk = !!clineMcp.mcpServers?.["kiro-memory"];
     } catch {
     }
@@ -3492,7 +5086,7 @@ async function runDoctor() {
   checks.push({
     name: "Cline MCP",
     ok: true,
-    // Non-blocking: installazione opzionale
+    // Non-blocking: optional installation
     message: clineMcpOk ? `kiro-memory registered in cline_mcp_settings.json` : "Not configured (optional: run kiro-memory install --cline)"
   });
   let workerOk = false;
@@ -3535,9 +5129,42 @@ async function main() {
     return;
   }
   if (command === "doctor") {
+    if (args.includes("--fix")) {
+      await runDoctorFix();
+      return;
+    }
     await runDoctor();
     return;
   }
+  if (command === "export") {
+    const sdk2 = createKiroMemory();
+    try {
+      await exportObservations(sdk2, args.slice(1));
+    } finally {
+      sdk2.close();
+    }
+    return;
+  }
+  if (command === "import") {
+    await importObservations(args.slice(1));
+    return;
+  }
+  if (command === "stats") {
+    await showStats();
+    return;
+  }
+  if (command === "config") {
+    await handleConfig(args.slice(1));
+    return;
+  }
+  if (command === "backup") {
+    await handleBackup(args.slice(1));
+    return;
+  }
+  if (command === "plugins") {
+    await handlePlugins(args.slice(1));
+    return;
+  }
   const sdk = createKiroMemory();
   try {
     switch (command) {
@@ -3546,7 +5173,11 @@ async function main() {
         await showContext(sdk);
         break;
       case "search":
-        await searchContext(sdk, args[1]);
+        if (args.includes("--interactive") || args.includes("-i")) {
+          await searchInteractive(sdk, args.slice(1));
+        } else {
+          await searchContext(sdk, args[1]);
+        }
         break;
       case "observations":
       case "obs":
@@ -3899,7 +5530,7 @@ async function generateReportCli(sdk, cliArgs) {
       output = formatReportText(data);
   }
   if (outputArg) {
-    writeFileSync(outputArg, output, "utf8");
+    writeFileSync3(outputArg, output, "utf8");
     console.log(`
   Report saved to: ${outputArg}
 `);
@@ -3943,6 +5574,612 @@ async function resumeSession(sdk, sessionId) {
   }
   console.log("");
 }
+async function searchInteractive(sdk, cliArgs) {
+  const projectArg = cliArgs.find((a, i) => cliArgs[i - 1] === "--project") || cliArgs.find((a) => a.startsWith("--project="))?.split("=").slice(1).join("=");
+  const isInteractive = cliArgs.includes("--interactive") || cliArgs.includes("-i");
+  if (!isInteractive || !process.stdin.isTTY) {
+    const queryArg = cliArgs.find((a) => !a.startsWith("-") && a !== "search");
+    if (!queryArg) {
+      console.error("Errore: fornisci un termine di ricerca o usa --interactive con un TTY");
+      process.exit(1);
+    }
+    const results = projectArg ? await sdk.searchAdvanced(queryArg, { project: projectArg }) : await sdk.search(queryArg);
+    const obs = results.observations.slice(0, 20);
+    if (obs.length === 0) {
+      console.log("\nNessun risultato trovato.\n");
+      return;
+    }
+    console.log(`
+Risultati per: "${queryArg}"
+`);
+    obs.forEach((o, i) => {
+      const date = new Date(o.created_at).toLocaleDateString("it-IT");
+      console.log(`  ${i + 1}. [${o.type}] ${o.title} \u2014 ${o.project} (${date})`);
+    });
+    console.log("");
+    return;
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const prompt = (question) => new Promise((resolve) => rl.question(question, (answer) => resolve(answer.trim())));
+  const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+  const cyan = (s) => useColor ? `\x1B[36m${s}\x1B[0m` : s;
+  const bold = (s) => useColor ? `\x1B[1m${s}\x1B[0m` : s;
+  const dim = (s) => useColor ? `\x1B[2m${s}\x1B[0m` : s;
+  console.log(`
+${cyan("=== Kiro Memory \u2014 Ricerca Interattiva ===")}`);
+  if (projectArg) console.log(dim(`  Filtro progetto: ${projectArg}`));
+  console.log(dim('  Premi Ctrl+C o digita "exit" per uscire.\n'));
+  while (true) {
+    let query;
+    try {
+      query = await prompt(cyan("> "));
+    } catch {
+      break;
+    }
+    if (!query || query.toLowerCase() === "exit" || query.toLowerCase() === "quit") break;
+    const results = projectArg ? await sdk.searchAdvanced(query, { project: projectArg }) : await sdk.search(query);
+    const obs = results.observations.slice(0, 20);
+    if (obs.length === 0) {
+      console.log(dim("\n  Nessun risultato trovato.\n"));
+      continue;
+    }
+    console.log(`
+  ${bold(`${obs.length} risultato/i:`)}
+`);
+    obs.forEach((o, i) => {
+      const date = new Date(o.created_at).toLocaleDateString("it-IT");
+      console.log(`    ${bold(`${i + 1}.`)} [${o.type}] ${o.title}`);
+      console.log(dim(`       ${o.project} \u2014 ${date}`));
+    });
+    console.log("");
+    const selRaw = await prompt(`  Numero per dettagli (Invio per saltare): `);
+    const selIdx = parseInt(selRaw) - 1;
+    if (!isNaN(selIdx) && selIdx >= 0 && selIdx < obs.length) {
+      const o = obs[selIdx];
+      console.log("");
+      console.log(`  ${bold("Titolo:")}     ${o.title}`);
+      console.log(`  ${bold("Tipo:")}       ${o.type}`);
+      console.log(`  ${bold("Progetto:")}   ${o.project}`);
+      console.log(`  ${bold("Data:")}       ${new Date(o.created_at).toLocaleString("it-IT")}`);
+      if (o.text) {
+        console.log(`  ${bold("Contenuto:")}`);
+        console.log(`    ${o.text.substring(0, 500)}${o.text.length > 500 ? "..." : ""}`);
+      }
+      if (o.narrative) {
+        console.log(`  ${bold("Narrativa:")}`);
+        console.log(`    ${o.narrative.substring(0, 300)}${o.narrative.length > 300 ? "..." : ""}`);
+      }
+      console.log("");
+    }
+  }
+  rl.close();
+  console.log("\n  Uscita dalla modalit\xE0 interattiva.\n");
+}
+async function exportObservations(sdk, cliArgs) {
+  const formatArg = cliArgs.find((a) => a.startsWith("--format="))?.split("=").slice(1).join("=") || cliArgs.find((a, i) => cliArgs[i - 1] === "--format");
+  const projectArg = cliArgs.find((a) => a.startsWith("--project="))?.split("=").slice(1).join("=") || cliArgs.find((a, i) => cliArgs[i - 1] === "--project");
+  const outputArg = cliArgs.find((a) => a.startsWith("-o="))?.split("=").slice(1).join("=") || cliArgs.find((a) => a.startsWith("--output="))?.split("=").slice(1).join("=") || cliArgs.find((a, i) => (cliArgs[i - 1] === "--output" || cliArgs[i - 1] === "-o") && !a.startsWith("-"));
+  const fromArg = cliArgs.find((a) => a.startsWith("--from="))?.split("=").slice(1).join("=") || cliArgs.find((a, i) => cliArgs[i - 1] === "--from" && !a.startsWith("-"));
+  const toArg = cliArgs.find((a) => a.startsWith("--to="))?.split("=").slice(1).join("=") || cliArgs.find((a, i) => cliArgs[i - 1] === "--to" && !a.startsWith("-"));
+  const typeArg = cliArgs.find((a) => a.startsWith("--type="))?.split("=").slice(1).join("=") || cliArgs.find((a, i) => cliArgs[i - 1] === "--type" && !a.startsWith("-"));
+  const validFormats = ["jsonl", "json", "md"];
+  const format = validFormats.includes(formatArg) ? formatArg : "jsonl";
+  if (format === "json" || format === "md") {
+    if (!projectArg) {
+      console.error("Errore: --project <nome> \xE8 obbligatorio per il formato json/md");
+      process.exit(1);
+    }
+    const kmDb2 = new KiroMemoryDatabase();
+    let observations;
+    try {
+      observations = getObservationsByProject(kmDb2.db, projectArg, 1e4);
+    } finally {
+      kmDb2.close();
+    }
+    if (observations.length === 0) {
+      console.error(`Nessuna observation trovata per il progetto "${projectArg}"`);
+      process.exit(1);
+    }
+    const output = generateExportOutput(observations, format);
+    if (outputArg) {
+      writeFileSync3(outputArg, output, "utf8");
+      console.error(`
+  Esportate ${observations.length} observations in: ${outputArg}
+`);
+    } else {
+      process.stdout.write(output + "\n");
+    }
+    return;
+  }
+  const { generateMetaRecord: generateMetaRecord2, exportObservationsStreaming: exportObservationsStreaming2, exportSummariesStreaming: exportSummariesStreaming2, exportPromptsStreaming: exportPromptsStreaming2 } = await Promise.resolve().then(() => (init_ImportExport(), ImportExport_exports));
+  const filters = {};
+  if (projectArg) filters.project = projectArg;
+  if (typeArg) filters.type = typeArg;
+  if (fromArg) filters.from = fromArg;
+  if (toArg) filters.to = toArg;
+  const kmDb = new KiroMemoryDatabase();
+  try {
+    if (outputArg) {
+      const { createWriteStream } = await import("fs");
+      const stream = createWriteStream(outputArg, { encoding: "utf8" });
+      let obsCount = 0;
+      let sumCount = 0;
+      let promptCount = 0;
+      stream.write(generateMetaRecord2(kmDb.db, filters) + "\n");
+      obsCount = exportObservationsStreaming2(kmDb.db, filters, (line) => {
+        stream.write(line + "\n");
+      });
+      sumCount = exportSummariesStreaming2(kmDb.db, filters, (line) => {
+        stream.write(line + "\n");
+      });
+      promptCount = exportPromptsStreaming2(kmDb.db, filters, (line) => {
+        stream.write(line + "\n");
+      });
+      await new Promise((resolve, reject) => {
+        stream.end((err) => err ? reject(err) : resolve());
+      });
+      console.error(`
+  Export JSONL completato:`);
+      console.error(`    Observations: ${obsCount}`);
+      console.error(`    Summaries:    ${sumCount}`);
+      console.error(`    Prompts:      ${promptCount}`);
+      console.error(`    File:         ${outputArg}
+`);
+    } else {
+      process.stdout.write(generateMetaRecord2(kmDb.db, filters) + "\n");
+      exportObservationsStreaming2(kmDb.db, filters, (line) => process.stdout.write(line + "\n"));
+      exportSummariesStreaming2(kmDb.db, filters, (line) => process.stdout.write(line + "\n"));
+      exportPromptsStreaming2(kmDb.db, filters, (line) => process.stdout.write(line + "\n"));
+    }
+  } finally {
+    kmDb.close();
+  }
+}
+async function importObservations(cliArgs) {
+  const filePath = cliArgs.find((a) => !a.startsWith("-"));
+  const dryRun = cliArgs.includes("--dry-run");
+  if (!filePath) {
+    console.error("Errore: specifica il percorso del file JSONL\n  kiro-memory import <file.jsonl> [--dry-run]");
+    process.exit(1);
+  }
+  if (!existsSync6(filePath)) {
+    console.error(`Errore: file non trovato: ${filePath}`);
+    process.exit(1);
+  }
+  let content;
+  try {
+    content = readFileSync4(filePath, "utf8");
+  } catch (err) {
+    console.error(`Errore lettura file: ${err.message}`);
+    process.exit(1);
+  }
+  if (dryRun) {
+    console.log(`
+  [DRY RUN] Analisi di "${filePath}"...
+`);
+  } else {
+    console.log(`
+  Importazione di "${filePath}"...
+`);
+  }
+  const { importJsonl: importJsonl2 } = await Promise.resolve().then(() => (init_ImportExport(), ImportExport_exports));
+  const { formatImportResult: formatImportResult2 } = await Promise.resolve().then(() => (init_cli_utils(), cli_utils_exports));
+  const kmDb = new KiroMemoryDatabase();
+  let result;
+  try {
+    result = importJsonl2(kmDb.db, content, dryRun);
+  } finally {
+    kmDb.close();
+  }
+  const output = formatImportResult2({
+    imported: result.imported,
+    skipped: result.skipped,
+    errors: result.errors,
+    total: result.total,
+    dryRun,
+    errorDetails: result.errorDetails
+  });
+  console.log(output);
+  if (result.imported === 0 && result.errors > 0 && result.skipped === 0) {
+    process.exit(1);
+  }
+}
+async function runDoctorFix() {
+  console.log("\n=== Kiro Memory \u2014 Riparazione Database ===\n");
+  const kmDb = new KiroMemoryDatabase();
+  const db = kmDb.db;
+  const messages = [];
+  try {
+    process.stdout.write("  [1/3] Ricostruzione indice FTS5... ");
+    const ftsOk = rebuildFtsIndex(db);
+    if (ftsOk) {
+      console.log("\x1B[32m\u2713\x1B[0m");
+      messages.push("Indice FTS5 ricostruito");
+    } else {
+      console.log("\x1B[33m~\x1B[0m (FTS non disponibile o gia' integro)");
+    }
+    process.stdout.write("  [2/3] Rimozione embeddings orfani... ");
+    const removed = removeOrphanedEmbeddings(db);
+    console.log(`\x1B[32m\u2713\x1B[0m (${removed} rimossi)`);
+    if (removed > 0) messages.push(`${removed} embedding/s orfani rimossi`);
+    process.stdout.write("  [3/3] VACUUM database...             ");
+    const vacuumOk = vacuumDatabase(db);
+    if (vacuumOk) {
+      console.log("\x1B[32m\u2713\x1B[0m");
+      messages.push("VACUUM completato");
+    } else {
+      console.log("\x1B[31m\u2717\x1B[0m");
+    }
+  } finally {
+    kmDb.close();
+  }
+  if (messages.length > 0) {
+    console.log("\n  Operazioni completate:");
+    for (const msg of messages) {
+      console.log(`    \x1B[32m\u2713\x1B[0m ${msg}`);
+    }
+  }
+  console.log("");
+}
+async function showStats() {
+  const kmDb = new KiroMemoryDatabase();
+  const db = kmDb.db;
+  try {
+    const obsRow = db.query(
+      "SELECT COUNT(*) as total FROM observations"
+    ).get();
+    const sessRow = db.query(
+      "SELECT COUNT(*) as total FROM sessions"
+    ).get();
+    const projRow = db.query(
+      "SELECT COUNT(DISTINCT project) as cnt FROM observations"
+    ).get();
+    const topProject = db.query(
+      `SELECT project, COUNT(*) as cnt
+       FROM observations
+       GROUP BY project
+       ORDER BY cnt DESC
+       LIMIT 1`
+    ).get();
+    let embCoverage = 0;
+    try {
+      const embStats = db.query(
+        `SELECT
+           (SELECT COUNT(*) FROM observations) as total,
+           COUNT(DISTINCT observation_id) as embedded
+         FROM observation_embeddings`
+      ).get();
+      if (embStats && embStats.total > 0) {
+        embCoverage = Math.round(embStats.embedded / embStats.total * 100);
+      }
+    } catch {
+    }
+    const dbSize = getDbFileSize(DB_PATH);
+    const stats = {
+      totalObservations: obsRow?.total || 0,
+      totalSessions: sessRow?.total || 0,
+      totalProjects: projRow?.cnt || 0,
+      dbSizeBytes: dbSize,
+      mostActiveProject: topProject?.project || null,
+      embeddingCoverage: embCoverage
+    };
+    console.log(formatStatsOutput(stats));
+  } finally {
+    kmDb.close();
+  }
+}
+async function handleConfig(subArgs) {
+  const subcommand = subArgs[0];
+  const configPath = getConfigPath();
+  switch (subcommand) {
+    case "list": {
+      const config = listConfig(configPath);
+      console.log("\n=== Configurazione Kiro Memory ===\n");
+      console.log(`  File: ${configPath}
+`);
+      for (const [key, value] of Object.entries(config)) {
+        const displayValue = value === null ? "(non impostato)" : String(value);
+        console.log(`  ${key.padEnd(35)} ${displayValue}`);
+      }
+      console.log("");
+      break;
+    }
+    case "get": {
+      const key = subArgs[1];
+      if (!key) {
+        console.error("Errore: specifica una chiave\n  kiro-memory config get <chiave>");
+        process.exit(1);
+      }
+      const val = getConfigValue(key, configPath);
+      if (val === null) {
+        console.log(`
+  "${key}" non impostato (nessun valore di default)
+`);
+      } else {
+        console.log(`
+  ${key} = ${val}
+`);
+      }
+      break;
+    }
+    case "set": {
+      const key = subArgs[1];
+      const rawValue = subArgs[2];
+      if (!key) {
+        console.error("Errore: specifica chiave e valore\n  kiro-memory config set <chiave> <valore>");
+        process.exit(1);
+      }
+      if (rawValue === void 0) {
+        console.error(`Errore: valore mancante per "${key}"
+  kiro-memory config set ${key} <valore>`);
+        process.exit(1);
+      }
+      const saved = setConfigValue(key, rawValue, configPath);
+      console.log(`
+  Impostato: ${key} = ${saved}
+`);
+      break;
+    }
+    default:
+      console.log("\nUtilizzo: kiro-memory config <subcommand>\n");
+      console.log("Subcommands:");
+      console.log("  list                         Mostra tutte le impostazioni");
+      console.log("  get <chiave>                 Legge un valore");
+      console.log("  set <chiave> <valore>        Imposta un valore\n");
+      console.log("Esempio:");
+      console.log("  kiro-memory config list");
+      console.log("  kiro-memory config get worker.port");
+      console.log("  kiro-memory config set log.level DEBUG\n");
+  }
+}
+async function handleBackup(subArgs) {
+  const subCommand = subArgs[0];
+  if (!subCommand || subCommand === "help") {
+    console.log(`
+Uso: kiro-memory backup <sottocomando>
+
+Sottocomandi:
+  create              Crea un backup manuale del database
+  list                Elenca i backup disponibili con metadata
+  restore <file>      Ripristina il database da un file backup
+`);
+    return;
+  }
+  if (subCommand === "create") {
+    const maxKeep = Number(getConfigValue("backup.maxKeep")) || 7;
+    const db = new KiroMemoryDatabase(DB_PATH, true);
+    try {
+      const entry = createBackup(DB_PATH, BACKUPS_DIR, db.db);
+      const deleted = rotateBackups(BACKUPS_DIR, maxKeep);
+      console.log(`
+=== Kiro Memory \u2014 Backup Creato ===
+`);
+      console.log(`  File:        ${entry.metadata.filename}`);
+      console.log(`  Timestamp:   ${entry.metadata.timestamp}`);
+      console.log(`  Schema v.:   ${entry.metadata.schemaVersion}`);
+      console.log(`  Obs.:        ${entry.metadata.stats.observations}`);
+      console.log(`  Sessioni:    ${entry.metadata.stats.sessions}`);
+      console.log(`  Dimensione:  ${(entry.metadata.stats.dbSizeBytes / 1024).toFixed(1)} KB`);
+      if (deleted > 0) {
+        console.log(`  Rotazione:   ${deleted} backup rimossi (max ${maxKeep} mantenuti)`);
+      }
+      console.log(`
+  Directory:  ${BACKUPS_DIR}
+`);
+    } finally {
+      db.close();
+    }
+    return;
+  }
+  if (subCommand === "list") {
+    const entries = listBackups(BACKUPS_DIR);
+    if (entries.length === 0) {
+      console.log("\n  Nessun backup trovato in: " + BACKUPS_DIR + "\n");
+      return;
+    }
+    console.log(`
+=== Kiro Memory \u2014 Backup Disponibili ===
+`);
+    console.log(`  Directory: ${BACKUPS_DIR}
+`);
+    for (let i = 0; i < entries.length; i++) {
+      const e = entries[i];
+      const size = (e.metadata.stats.dbSizeBytes / 1024).toFixed(1);
+      const date = new Date(e.metadata.timestampEpoch).toLocaleString("it-IT");
+      console.log(`  ${i + 1}. ${e.metadata.filename}`);
+      console.log(`     Data:      ${date}`);
+      console.log(`     Schema:    v${e.metadata.schemaVersion}`);
+      console.log(`     Obs.:      ${e.metadata.stats.observations} | Sessioni: ${e.metadata.stats.sessions}`);
+      console.log(`     Dimensione: ${size} KB`);
+      console.log("");
+    }
+    return;
+  }
+  if (subCommand === "restore") {
+    const file = subArgs[1];
+    if (!file) {
+      console.error("\n  Errore: specifica il nome del file backup da ripristinare.");
+      console.error("  Esempio: kiro-memory backup restore backup-2026-02-27-150000.db\n");
+      process.exit(1);
+    }
+    const backupPattern = /^backup-\d{4}-\d{2}-\d{2}-\d{6}(-\d{3})?\.db$/;
+    if (file.includes("/") || file.includes("..") || !backupPattern.test(file)) {
+      console.error(`
+  Errore: nome file non valido: ${file}`);
+      console.error('  Il file deve essere nel formato "backup-YYYY-MM-DD-HHmmss[-mmm].db"\n');
+      process.exit(1);
+    }
+    const entries = listBackups(BACKUPS_DIR);
+    const found = entries.find((e) => e.metadata.filename === file);
+    if (!found) {
+      console.error(`
+  Errore: backup non trovato: ${file}`);
+      console.error(`  Usa "kiro-memory backup list" per vedere i backup disponibili.
+`);
+      process.exit(1);
+    }
+    const date = new Date(found.metadata.timestampEpoch).toLocaleString("it-IT");
+    console.log(`
+  ATTENZIONE: questa operazione sovrascrive il database corrente!`);
+    console.log(`  Backup da ripristinare: ${file}`);
+    console.log(`  Data backup:            ${date}`);
+    console.log(`  Obs. nel backup:        ${found.metadata.stats.observations}`);
+    console.log("");
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const confirmed = await new Promise((resolve) => {
+      rl.question('  Confermi il ripristino? (digita "si" per confermare): ', (answer) => {
+        rl.close();
+        resolve(answer.trim().toLowerCase() === "si");
+      });
+    });
+    if (!confirmed) {
+      console.log("\n  Ripristino annullato.\n");
+      return;
+    }
+    restoreBackup(found.filePath, DB_PATH);
+    console.log(`
+  Database ripristinato da: ${file}`);
+    console.log("  Riavvia il worker per applicare le modifiche.\n");
+    return;
+  }
+  console.error(`
+  Sottocomando backup non riconosciuto: ${subCommand}`);
+  console.error("  Usa: create | list | restore\n");
+  process.exit(1);
+}
+async function handlePlugins(subArgs) {
+  const subCommand = subArgs[0];
+  const port = process.env.KIRO_MEMORY_WORKER_PORT || process.env.CONTEXTKIT_WORKER_PORT || "3001";
+  const baseUrl = `http://127.0.0.1:${port}`;
+  async function apiGet(path) {
+    return new Promise((resolve, reject) => {
+      const req = http.get(`${baseUrl}${path}`, (res) => {
+        let body = "";
+        res.on("data", (chunk) => {
+          body += chunk;
+        });
+        res.on("end", () => {
+          try {
+            resolve({ status: res.statusCode, data: JSON.parse(body) });
+          } catch {
+            reject(new Error(`Risposta non JSON: ${body}`));
+          }
+        });
+      });
+      req.on("error", reject);
+      req.setTimeout(5e3, () => {
+        req.destroy(new Error("Timeout"));
+      });
+    });
+  }
+  async function apiPost(path) {
+    return new Promise((resolve, reject) => {
+      const options = {
+        hostname: "127.0.0.1",
+        port: parseInt(port, 10),
+        path,
+        method: "POST",
+        headers: { "Content-Type": "application/json", "Content-Length": 0 }
+      };
+      const req = http.request(options, (res) => {
+        let body = "";
+        res.on("data", (chunk) => {
+          body += chunk;
+        });
+        res.on("end", () => {
+          try {
+            resolve({ status: res.statusCode, data: JSON.parse(body) });
+          } catch {
+            reject(new Error(`Risposta non JSON: ${body}`));
+          }
+        });
+      });
+      req.on("error", reject);
+      req.setTimeout(1e4, () => {
+        req.destroy(new Error("Timeout"));
+      });
+      req.end();
+    });
+  }
+  if (!subCommand || subCommand === "list") {
+    try {
+      const result = await apiGet("/api/plugins");
+      const { plugins } = result.data;
+      console.log("\n=== Kiro Memory \u2014 Plugin ===\n");
+      if (!plugins || plugins.length === 0) {
+        console.log("  Nessun plugin registrato.\n");
+        return;
+      }
+      for (const p of plugins) {
+        const stateColor = p.state === "active" ? "\x1B[32m" : p.state === "error" ? "\x1B[31m" : "\x1B[33m";
+        console.log(`  ${p.name}@${p.version}`);
+        console.log(`    Stato:    ${stateColor}${p.state}\x1B[0m`);
+        if (p.description) console.log(`    Desc.:    ${p.description}`);
+        if (p.error) console.log(`    Errore:   \x1B[31m${p.error}\x1B[0m`);
+        console.log("");
+      }
+    } catch {
+      console.error("\n  Errore: impossibile contattare il worker. Avvialo con: kiro-memory worker start\n");
+      process.exit(1);
+    }
+    return;
+  }
+  if (subCommand === "enable") {
+    const name = subArgs[1];
+    if (!name) {
+      console.error("\n  Errore: specifica il nome del plugin.\n  Esempio: kiro-memory plugins enable mio-plugin\n");
+      process.exit(1);
+    }
+    try {
+      const result = await apiPost(`/api/plugins/${encodeURIComponent(name)}/enable`);
+      if (result.status === 200) {
+        console.log(`
+  Plugin "${name}" abilitato con successo.`);
+        if (result.data.plugin?.state === "error") {
+          console.log(`  Attenzione: stato corrente = error: ${result.data.plugin.error}`);
+        }
+        console.log("");
+      } else {
+        console.error(`
+  Errore: ${result.data.error}
+`);
+        process.exit(1);
+      }
+    } catch {
+      console.error("\n  Errore: impossibile contattare il worker.\n");
+      process.exit(1);
+    }
+    return;
+  }
+  if (subCommand === "disable") {
+    const name = subArgs[1];
+    if (!name) {
+      console.error("\n  Errore: specifica il nome del plugin.\n  Esempio: kiro-memory plugins disable mio-plugin\n");
+      process.exit(1);
+    }
+    try {
+      const result = await apiPost(`/api/plugins/${encodeURIComponent(name)}/disable`);
+      if (result.status === 200) {
+        console.log(`
+  Plugin "${name}" disabilitato.
+`);
+      } else {
+        console.error(`
+  Errore: ${result.data.error}
+`);
+        process.exit(1);
+      }
+    } catch {
+      console.error("\n  Errore: impossibile contattare il worker.\n");
+      process.exit(1);
+    }
+    return;
+  }
+  console.error(`
+  Sottocomando plugins non riconosciuto: ${subCommand}`);
+  console.error("  Usa: list | enable <nome> | disable <nome>\n");
+  process.exit(1);
+}
 function showHelp() {
   console.log(`Usage: kiro-memory <command> [options]
 
@@ -3953,6 +6190,7 @@ Setup:
   install --windsurf        Install MCP server for Windsurf IDE
   install --cline           Install MCP server for Cline (VS Code)
   doctor                    Run environment diagnostics (checks Node, build tools, WSL, etc.)
+  doctor --fix              Auto-repair: rebuild FTS5, remove orphaned embeddings, VACUUM
 
 Commands:
   context, ctx              Show current project context
@@ -3961,8 +6199,18 @@ Commands:
     --period=weekly|monthly   Time period (default: weekly)
     --format=text|md|json     Output format (default: text)
     --output=<file>           Write to file instead of stdout
+  stats                     Quick database overview (totals, size, active project, embeddings)
   search <query>            Search across all context (keyword FTS5)
+  search --interactive      Interactive REPL search with result selection
+    --project <name>          Filter results by project
   semantic-search <query>   Hybrid search: vector + keyword (semantic)
+  export --project <name>   Export observations to JSONL/JSON/Markdown
+    --format=jsonl|json|md    Output format (default: jsonl)
+    --output=<file>           Write to file instead of stdout
+  import <file>             Import observations from JSONL file (deduplication by content_hash)
+  config list               Show all configuration settings
+  config get <key>          Show a single configuration value
+  config set <key> <value>  Set a configuration value
   observations [limit]      Show recent observations (default: 10)
   summaries [limit]         Show recent summaries (default: 5)
   add-observation <title> <content>   Add a new observation
@@ -3977,18 +6225,36 @@ Commands:
   decay stats               Show decay statistics (stale, never accessed, etc.)
   decay detect-stale        Detect and mark stale observations
   decay consolidate [--dry-run]  Consolidate duplicate observations
+  backup create             Crea un backup manuale del database
+  backup list               Elenca tutti i backup disponibili con metadata
+  backup restore <file>     Ripristina il database da un backup (con conferma)
+  plugins list              Elenca tutti i plugin registrati con stato
+  plugins enable <nome>     Abilita un plugin registrato
+  plugins disable <nome>    Disabilita un plugin attivo
   help                      Show this help message
 
 Examples:
   kiro-memory install
   kiro-memory doctor
+  kiro-memory doctor --fix
+  kiro-memory stats
   kiro-memory context
   kiro-memory resume
   kiro-memory resume 42
   kiro-memory report
   kiro-memory report --period=monthly --format=md --output=report.md
   kiro-memory search "authentication"
+  kiro-memory search --interactive --project myapp
   kiro-memory semantic-search "how did I fix the auth bug"
+  kiro-memory export --project myapp --format jsonl --output backup.jsonl
+  kiro-memory export --project myapp --format md > notes.md
+  kiro-memory import backup.jsonl
+  kiro-memory backup create
+  kiro-memory backup list
+  kiro-memory backup restore backup-2026-02-27-150000.db
+  kiro-memory config list
+  kiro-memory config get worker.port
+  kiro-memory config set log.level DEBUG
   kiro-memory add-knowledge constraint "No any in TypeScript" "Never use any type" --severity=hard
   kiro-memory add-knowledge decision "PostgreSQL over MongoDB" "Chosen for ACID" --alternatives=MongoDB,DynamoDB
   kiro-memory embeddings stats