kiro-memory 1.6.0 → 1.7.1

package/plugin/dist/cli/contextkit.js

@@ -1,11 +1,753 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';const require = createRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/utils/logger.ts
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var LogLevel, DEFAULT_DATA_DIR, Logger, logger;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+      LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+      LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+      LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+      LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+      LogLevel2[LogLevel2["SILENT"] = 4] = "SILENT";
+      return LogLevel2;
+    })(LogLevel || {});
+    DEFAULT_DATA_DIR = join(homedir(), ".contextkit");
+    Logger = class {
+      level = null;
+      useColor;
+      logFilePath = null;
+      logFileInitialized = false;
+      constructor() {
+        this.useColor = process.stdout.isTTY ?? false;
+      }
+      /**
+       * Initialize log file path and ensure directory exists (lazy initialization)
+       */
+      ensureLogFileInitialized() {
+        if (this.logFileInitialized) return;
+        this.logFileInitialized = true;
+        try {
+          const logsDir = join(DEFAULT_DATA_DIR, "logs");
+          if (!existsSync(logsDir)) {
+            mkdirSync(logsDir, { recursive: true });
+          }
+          const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+          this.logFilePath = join(logsDir, `kiro-memory-${date}.log`);
+        } catch (error) {
+          console.error("[LOGGER] Failed to initialize log file:", error);
+          this.logFilePath = null;
+        }
+      }
+      /**
+       * Lazy-load log level from settings file
+       */
+      getLevel() {
+        if (this.level === null) {
+          try {
+            const settingsPath = join(DEFAULT_DATA_DIR, "settings.json");
+            if (existsSync(settingsPath)) {
+              const settingsData = readFileSync(settingsPath, "utf-8");
+              const settings = JSON.parse(settingsData);
+              const envLevel = (settings.KIRO_MEMORY_LOG_LEVEL || settings.CONTEXTKIT_LOG_LEVEL || "INFO").toUpperCase();
+              this.level = LogLevel[envLevel] ?? 1 /* INFO */;
+            } else {
+              this.level = 1 /* INFO */;
+            }
+          } catch (error) {
+            this.level = 1 /* INFO */;
+          }
+        }
+        return this.level;
+      }
+      /**
+       * Create correlation ID for tracking an observation through the pipeline
+       */
+      correlationId(sessionId, observationNum) {
+        return `obs-${sessionId}-${observationNum}`;
+      }
+      /**
+       * Create session correlation ID
+       */
+      sessionId(sessionId) {
+        return `session-${sessionId}`;
+      }
+      /**
+       * Format data for logging - create compact summaries instead of full dumps
+       */
+      formatData(data) {
+        if (data === null || data === void 0) return "";
+        if (typeof data === "string") return data;
+        if (typeof data === "number") return data.toString();
+        if (typeof data === "boolean") return data.toString();
+        if (typeof data === "object") {
+          if (data instanceof Error) {
+            return this.getLevel() === 0 /* DEBUG */ ? `${data.message}
+${data.stack}` : data.message;
+          }
+          if (Array.isArray(data)) {
+            return `[${data.length} items]`;
+          }
+          const keys = Object.keys(data);
+          if (keys.length === 0) return "{}";
+          if (keys.length <= 3) {
+            return JSON.stringify(data);
+          }
+          return `{${keys.length} keys: ${keys.slice(0, 3).join(", ")}...}`;
+        }
+        return String(data);
+      }
+      /**
+       * Format timestamp in local timezone (YYYY-MM-DD HH:MM:SS.mmm)
+       */
+      formatTimestamp(date) {
+        const year = date.getFullYear();
+        const month = String(date.getMonth() + 1).padStart(2, "0");
+        const day = String(date.getDate()).padStart(2, "0");
+        const hours = String(date.getHours()).padStart(2, "0");
+        const minutes = String(date.getMinutes()).padStart(2, "0");
+        const seconds = String(date.getSeconds()).padStart(2, "0");
+        const ms = String(date.getMilliseconds()).padStart(3, "0");
+        return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${ms}`;
+      }
+      /**
+       * Core logging method
+       */
+      log(level, component, message, context, data) {
+        if (level < this.getLevel()) return;
+        this.ensureLogFileInitialized();
+        const timestamp = this.formatTimestamp(/* @__PURE__ */ new Date());
+        const levelStr = LogLevel[level].padEnd(5);
+        const componentStr = component.padEnd(6);
+        let correlationStr = "";
+        if (context?.correlationId) {
+          correlationStr = `[${context.correlationId}] `;
+        } else if (context?.sessionId) {
+          correlationStr = `[session-${context.sessionId}] `;
+        }
+        let dataStr = "";
+        if (data !== void 0 && data !== null) {
+          if (data instanceof Error) {
+            dataStr = this.getLevel() === 0 /* DEBUG */ ? `
+${data.message}
+${data.stack}` : ` ${data.message}`;
+          } else if (this.getLevel() === 0 /* DEBUG */ && typeof data === "object") {
+            dataStr = "\n" + JSON.stringify(data, null, 2);
+          } else {
+            dataStr = " " + this.formatData(data);
+          }
+        }
+        let contextStr = "";
+        if (context) {
+          const { sessionId, memorySessionId, correlationId, ...rest } = context;
+          if (Object.keys(rest).length > 0) {
+            const pairs = Object.entries(rest).map(([k, v]) => `${k}=${v}`);
+            contextStr = ` {${pairs.join(", ")}}`;
+          }
+        }
+        const logLine = `[${timestamp}] [${levelStr}] [${componentStr}] ${correlationStr}${message}${contextStr}${dataStr}`;
+        if (this.logFilePath) {
+          try {
+            appendFileSync(this.logFilePath, logLine + "\n", "utf8");
+          } catch (error) {
+            process.stderr.write(`[LOGGER] Failed to write to log file: ${error}
+`);
+          }
+        } else {
+          process.stderr.write(logLine + "\n");
+        }
+      }
+      // Public logging methods
+      debug(component, message, context, data) {
+        this.log(0 /* DEBUG */, component, message, context, data);
+      }
+      info(component, message, context, data) {
+        this.log(1 /* INFO */, component, message, context, data);
+      }
+      warn(component, message, context, data) {
+        this.log(2 /* WARN */, component, message, context, data);
+      }
+      error(component, message, context, data) {
+        this.log(3 /* ERROR */, component, message, context, data);
+      }
+      /**
+       * Log data flow: input → processing
+       */
+      dataIn(component, message, context, data) {
+        this.info(component, `\u2192 ${message}`, context, data);
+      }
+      /**
+       * Log data flow: processing → output
+       */
+      dataOut(component, message, context, data) {
+        this.info(component, `\u2190 ${message}`, context, data);
+      }
+      /**
+       * Log successful completion
+       */
+      success(component, message, context, data) {
+        this.info(component, `\u2713 ${message}`, context, data);
+      }
+      /**
+       * Log failure
+       */
+      failure(component, message, context, data) {
+        this.error(component, `\u2717 ${message}`, context, data);
+      }
+      /**
+       * Log timing information
+       */
+      timing(component, message, durationMs, context) {
+        this.info(component, `\u23F1 ${message}`, context, { duration: `${durationMs}ms` });
+      }
+      /**
+       * Happy Path Error - logs when the expected "happy path" fails but we have a fallback
+       */
+      happyPathError(component, message, context, data, fallback = "") {
+        const stack = new Error().stack || "";
+        const stackLines = stack.split("\n");
+        const callerLine = stackLines[2] || "";
+        const callerMatch = callerLine.match(/at\s+(?:.*\s+)?\(?([^:]+):(\d+):(\d+)\)?/);
+        const location = callerMatch ? `${callerMatch[1].split("/").pop()}:${callerMatch[2]}` : "unknown";
+        const enhancedContext = {
+          ...context,
+          location
+        };
+        this.warn(component, `[HAPPY-PATH] ${message}`, enhancedContext, data);
+        return fallback;
+      }
+    };
+    logger = new Logger();
+  }
+});
+
+// src/services/sqlite/Observations.ts
+var Observations_exports = {};
+__export(Observations_exports, {
+  consolidateObservations: () => consolidateObservations,
+  createObservation: () => createObservation,
+  deleteObservation: () => deleteObservation,
+  getObservationsByProject: () => getObservationsByProject,
+  getObservationsBySession: () => getObservationsBySession,
+  searchObservations: () => searchObservations,
+  updateLastAccessed: () => updateLastAccessed
+});
+function escapeLikePattern(input) {
+  return input.replace(/[%_\\]/g, "\\$&");
+}
+function createObservation(db, memorySessionId, project, type, title, subtitle, text, narrative, facts, concepts, filesRead, filesModified, promptNumber) {
+  const now = /* @__PURE__ */ new Date();
+  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)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [memorySessionId, project, type, title, subtitle, text, narrative, facts, concepts, filesRead, filesModified, promptNumber, now.toISOString(), now.getTime()]
+  );
+  return Number(result.lastInsertRowid);
+}
+function getObservationsBySession(db, memorySessionId) {
+  const query = db.query(
+    "SELECT * FROM observations WHERE memory_session_id = ? ORDER BY prompt_number ASC"
+  );
+  return query.all(memorySessionId);
+}
+function getObservationsByProject(db, project, limit = 100) {
+  const query = db.query(
+    "SELECT * FROM observations WHERE project = ? ORDER BY created_at_epoch 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
+       WHERE title LIKE ? ESCAPE '\\' OR text LIKE ? ESCAPE '\\' OR narrative LIKE ? ESCAPE '\\'
+       ORDER BY created_at_epoch DESC`;
+  const pattern = `%${escapeLikePattern(searchTerm)}%`;
+  const query = db.query(sql);
+  if (project) {
+    return query.all(project, pattern, pattern, pattern);
+  }
+  return query.all(pattern, pattern, pattern);
+}
+function deleteObservation(db, id) {
+  db.run("DELETE FROM observations WHERE id = ?", [id]);
+}
+function updateLastAccessed(db, ids) {
+  if (!Array.isArray(ids) || ids.length === 0) return;
+  const validIds = ids.filter((id) => typeof id === "number" && Number.isInteger(id) && id > 0).slice(0, 500);
+  if (validIds.length === 0) return;
+  const now = Date.now();
+  const placeholders = validIds.map(() => "?").join(",");
+  db.run(
+    `UPDATE observations SET last_accessed_epoch = ? WHERE id IN (${placeholders})`,
+    [now, ...validIds]
+  );
+}
+function consolidateObservations(db, project, options = {}) {
+  const minGroupSize = options.minGroupSize || 3;
+  const groups = db.query(`
+    SELECT type, files_modified, COUNT(*) as cnt, GROUP_CONCAT(id) as ids
+    FROM observations
+    WHERE project = ? AND files_modified IS NOT NULL AND files_modified != ''
+    GROUP BY type, files_modified
+    HAVING cnt >= ?
+    ORDER BY cnt DESC
+  `).all(project, minGroupSize);
+  if (groups.length === 0) return { merged: 0, removed: 0 };
+  let totalMerged = 0;
+  let totalRemoved = 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`
+    ).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();
+    if (keeper.text) uniqueTexts.add(keeper.text);
+    for (const obs of others) {
+      if (obs.text && !uniqueTexts.has(obs.text)) {
+        uniqueTexts.add(obs.text);
+      }
+    }
+    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]
+    );
+    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;
+  }
+  return { merged: totalMerged, removed: totalRemoved };
+}
+var init_Observations = __esm({
+  "src/services/sqlite/Observations.ts"() {
+    "use strict";
+  }
+});
+
+// src/services/sqlite/Search.ts
+var Search_exports = {};
+__export(Search_exports, {
+  getObservationsByIds: () => getObservationsByIds,
+  getProjectStats: () => getProjectStats,
+  getStaleObservations: () => getStaleObservations,
+  getTimeline: () => getTimeline,
+  markObservationsStale: () => markObservationsStale,
+  searchObservationsFTS: () => searchObservationsFTS,
+  searchObservationsFTSWithRank: () => searchObservationsFTSWithRank,
+  searchObservationsLIKE: () => searchObservationsLIKE,
+  searchSummariesFiltered: () => searchSummariesFiltered
+});
+import { existsSync as existsSync3, statSync } from "fs";
+function escapeLikePattern3(input) {
+  return input.replace(/[%_\\]/g, "\\$&");
+}
+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}"`);
+  return terms.join(" ");
+}
+function searchObservationsFTS(db, query, filters = {}) {
+  const limit = filters.limit || 50;
+  try {
+    const safeQuery = sanitizeFTS5Query(query);
+    if (!safeQuery) return searchObservationsLIKE(db, query, filters);
+    let sql = `
+      SELECT o.* FROM observations o
+      JOIN observations_fts fts ON o.id = fts.rowid
+      WHERE observations_fts MATCH ?
+    `;
+    const params = [safeQuery];
+    if (filters.project) {
+      sql += " AND o.project = ?";
+      params.push(filters.project);
+    }
+    if (filters.type) {
+      sql += " AND o.type = ?";
+      params.push(filters.type);
+    }
+    if (filters.dateStart) {
+      sql += " AND o.created_at_epoch >= ?";
+      params.push(filters.dateStart);
+    }
+    if (filters.dateEnd) {
+      sql += " AND o.created_at_epoch <= ?";
+      params.push(filters.dateEnd);
+    }
+    sql += " ORDER BY rank LIMIT ?";
+    params.push(limit);
+    const stmt = db.query(sql);
+    return stmt.all(...params);
+  } catch {
+    return searchObservationsLIKE(db, query, filters);
+  }
+}
+function searchObservationsFTSWithRank(db, query, filters = {}) {
+  const limit = filters.limit || 50;
+  try {
+    const safeQuery = sanitizeFTS5Query(query);
+    if (!safeQuery) return [];
+    let sql = `
+      SELECT o.*, rank as fts5_rank FROM observations o
+      JOIN observations_fts fts ON o.id = fts.rowid
+      WHERE observations_fts MATCH ?
+    `;
+    const params = [safeQuery];
+    if (filters.project) {
+      sql += " AND o.project = ?";
+      params.push(filters.project);
+    }
+    if (filters.type) {
+      sql += " AND o.type = ?";
+      params.push(filters.type);
+    }
+    if (filters.dateStart) {
+      sql += " AND o.created_at_epoch >= ?";
+      params.push(filters.dateStart);
+    }
+    if (filters.dateEnd) {
+      sql += " AND o.created_at_epoch <= ?";
+      params.push(filters.dateEnd);
+    }
+    sql += " ORDER BY rank LIMIT ?";
+    params.push(limit);
+    const stmt = db.query(sql);
+    return stmt.all(...params);
+  } catch {
+    return [];
+  }
+}
+function searchObservationsLIKE(db, query, filters = {}) {
+  const limit = filters.limit || 50;
+  const pattern = `%${escapeLikePattern3(query)}%`;
+  let sql = `
+    SELECT * FROM observations
+    WHERE (title LIKE ? ESCAPE '\\' OR text LIKE ? ESCAPE '\\' OR narrative LIKE ? ESCAPE '\\' OR concepts LIKE ? ESCAPE '\\')
+  `;
+  const params = [pattern, pattern, pattern, pattern];
+  if (filters.project) {
+    sql += " AND project = ?";
+    params.push(filters.project);
+  }
+  if (filters.type) {
+    sql += " AND type = ?";
+    params.push(filters.type);
+  }
+  if (filters.dateStart) {
+    sql += " AND created_at_epoch >= ?";
+    params.push(filters.dateStart);
+  }
+  if (filters.dateEnd) {
+    sql += " AND created_at_epoch <= ?";
+    params.push(filters.dateEnd);
+  }
+  sql += " ORDER BY created_at_epoch DESC LIMIT ?";
+  params.push(limit);
+  const stmt = db.query(sql);
+  return stmt.all(...params);
+}
+function searchSummariesFiltered(db, query, filters = {}) {
+  const limit = filters.limit || 20;
+  const pattern = `%${escapeLikePattern3(query)}%`;
+  let sql = `
+    SELECT * FROM summaries
+    WHERE (request LIKE ? ESCAPE '\\' OR learned LIKE ? ESCAPE '\\' OR completed LIKE ? ESCAPE '\\' OR notes LIKE ? ESCAPE '\\' OR next_steps LIKE ? ESCAPE '\\')
+  `;
+  const params = [pattern, pattern, pattern, pattern, pattern];
+  if (filters.project) {
+    sql += " AND project = ?";
+    params.push(filters.project);
+  }
+  if (filters.dateStart) {
+    sql += " AND created_at_epoch >= ?";
+    params.push(filters.dateStart);
+  }
+  if (filters.dateEnd) {
+    sql += " AND created_at_epoch <= ?";
+    params.push(filters.dateEnd);
+  }
+  sql += " ORDER BY created_at_epoch DESC LIMIT ?";
+  params.push(limit);
+  const stmt = db.query(sql);
+  return stmt.all(...params);
+}
+function getObservationsByIds(db, ids) {
+  if (!Array.isArray(ids) || ids.length === 0) return [];
+  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 stmt = db.query(sql);
+  return stmt.all(...validIds);
+}
+function getTimeline(db, anchorId, depthBefore = 5, depthAfter = 5) {
+  const anchorStmt = db.query("SELECT created_at_epoch FROM observations WHERE id = ?");
+  const anchor = anchorStmt.get(anchorId);
+  if (!anchor) return [];
+  const anchorEpoch = anchor.created_at_epoch;
+  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
+    LIMIT ?
+  `);
+  const before = beforeStmt.all(anchorEpoch, 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 = ?
+  `);
+  const self = selfStmt.all(anchorId);
+  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
+    LIMIT ?
+  `);
+  const after = afterStmt.all(anchorEpoch, 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 = ?");
+  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
+  };
+}
+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
+    LIMIT 500
+  `).all(project);
+  const staleObs = [];
+  for (const obs of rows) {
+    if (!obs.files_modified) continue;
+    const files = obs.files_modified.split(",").map((f) => f.trim()).filter(Boolean);
+    let isStale = false;
+    for (const filepath of files) {
+      try {
+        if (!existsSync3(filepath)) continue;
+        const stat = statSync(filepath);
+        if (stat.mtimeMs > obs.created_at_epoch) {
+          isStale = true;
+          break;
+        }
+      } catch {
+      }
+    }
+    if (isStale) {
+      staleObs.push(obs);
+    }
+  }
+  return staleObs;
+}
+function markObservationsStale(db, ids, stale) {
+  if (!Array.isArray(ids) || ids.length === 0) return;
+  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(",");
+  db.run(
+    `UPDATE observations SET is_stale = ? WHERE id IN (${placeholders})`,
+    [stale ? 1 : 0, ...validIds]
+  );
+}
+var init_Search = __esm({
+  "src/services/sqlite/Search.ts"() {
+    "use strict";
+  }
+});
+
+// src/services/search/EmbeddingService.ts
+var EmbeddingService_exports = {};
+__export(EmbeddingService_exports, {
+  EmbeddingService: () => EmbeddingService,
+  getEmbeddingService: () => getEmbeddingService
+});
+function getEmbeddingService() {
+  if (!embeddingService) {
+    embeddingService = new EmbeddingService();
+  }
+  return embeddingService;
+}
+var EmbeddingService, embeddingService;
+var init_EmbeddingService = __esm({
+  "src/services/search/EmbeddingService.ts"() {
+    "use strict";
+    init_logger();
+    EmbeddingService = class {
+      provider = null;
+      model = null;
+      initialized = false;
+      initializing = null;
+      /**
+       * Inizializza il servizio di embedding.
+       * Tenta fastembed, poi @huggingface/transformers, poi fallback a null.
+       */
+      async initialize() {
+        if (this.initialized) return this.provider !== null;
+        if (this.initializing) return this.initializing;
+        this.initializing = this._doInitialize();
+        const result = await this.initializing;
+        this.initializing = null;
+        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;
+          }
+        } 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", {
+              quantized: true
+            });
+            this.provider = "transformers";
+            this.initialized = true;
+            logger.info("EMBEDDING", "Inizializzato con @huggingface/transformers (all-MiniLM-L6-v2)");
+            return true;
+          }
+        } catch (error) {
+          logger.debug("EMBEDDING", `@huggingface/transformers non disponibile: ${error}`);
+        }
+        this.provider = null;
+        this.initialized = true;
+        logger.warn("EMBEDDING", "Nessun provider embedding disponibile, ricerca semantica disabilitata");
+        return false;
+      }
+      /**
+       * Genera embedding per un singolo testo.
+       * Ritorna Float32Array con 384 dimensioni, o null se non disponibile.
+       */
+      async embed(text) {
+        if (!this.initialized) await this.initialize();
+        if (!this.provider || !this.model) return null;
+        try {
+          const truncated = text.substring(0, 2e3);
+          if (this.provider === "fastembed") {
+            return await this._embedFastembed(truncated);
+          } else if (this.provider === "transformers") {
+            return await this._embedTransformers(truncated);
+          }
+        } catch (error) {
+          logger.error("EMBEDDING", `Errore generazione embedding: ${error}`);
+        }
+        return null;
+      }
+      /**
+       * Genera embeddings in batch.
+       */
+      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);
+          }
+        }
+        return results;
+      }
+      /**
+       * Verifica se il servizio è disponibile.
+       */
+      isAvailable() {
+        return this.initialized && this.provider !== null;
+      }
+      /**
+       * Nome del provider attivo.
+       */
+      getProvider() {
+        return this.provider;
+      }
+      /**
+       * Dimensioni del vettore embedding.
+       */
+      getDimensions() {
+        return 384;
+      }
+      // --- Provider specifici ---
+      async _embedFastembed(text) {
+        const embeddings = this.model.embed([text], 1);
+        for await (const batch of embeddings) {
+          if (batch && batch.length > 0) {
+            const vec = batch[0];
+            return vec instanceof Float32Array ? vec : new Float32Array(vec);
+          }
+        }
+        return null;
+      }
+      async _embedTransformers(text) {
+        const output = await this.model(text, {
+          pooling: "mean",
+          normalize: true
+        });
+        if (output?.data) {
+          return output.data instanceof Float32Array ? output.data : new Float32Array(output.data);
+        }
+        return null;
+      }
+    };
+    embeddingService = null;
+  }
+});
 
 // src/shims/bun-sqlite.ts
 import BetterSqlite3 from "better-sqlite3";
@@ -78,228 +820,8 @@ var BunQueryCompat = class {
 import { join as join2, dirname, basename } from "path";
 import { homedir as homedir2 } from "os";
 import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+init_logger();
 import { fileURLToPath } from "url";
-
-// src/utils/logger.ts
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
-  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
-  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
-  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
-  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
-  LogLevel2[LogLevel2["SILENT"] = 4] = "SILENT";
-  return LogLevel2;
-})(LogLevel || {});
-var DEFAULT_DATA_DIR = join(homedir(), ".contextkit");
-var Logger = class {
-  level = null;
-  useColor;
-  logFilePath = null;
-  logFileInitialized = false;
-  constructor() {
-    this.useColor = process.stdout.isTTY ?? false;
-  }
-  /**
-   * Initialize log file path and ensure directory exists (lazy initialization)
-   */
-  ensureLogFileInitialized() {
-    if (this.logFileInitialized) return;
-    this.logFileInitialized = true;
-    try {
-      const logsDir = join(DEFAULT_DATA_DIR, "logs");
-      if (!existsSync(logsDir)) {
-        mkdirSync(logsDir, { recursive: true });
-      }
-      const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-      this.logFilePath = join(logsDir, `kiro-memory-${date}.log`);
-    } catch (error) {
-      console.error("[LOGGER] Failed to initialize log file:", error);
-      this.logFilePath = null;
-    }
-  }
-  /**
-   * Lazy-load log level from settings file
-   */
-  getLevel() {
-    if (this.level === null) {
-      try {
-        const settingsPath = join(DEFAULT_DATA_DIR, "settings.json");
-        if (existsSync(settingsPath)) {
-          const settingsData = readFileSync(settingsPath, "utf-8");
-          const settings = JSON.parse(settingsData);
-          const envLevel = (settings.KIRO_MEMORY_LOG_LEVEL || settings.CONTEXTKIT_LOG_LEVEL || "INFO").toUpperCase();
-          this.level = LogLevel[envLevel] ?? 1 /* INFO */;
-        } else {
-          this.level = 1 /* INFO */;
-        }
-      } catch (error) {
-        this.level = 1 /* INFO */;
-      }
-    }
-    return this.level;
-  }
-  /**
-   * Create correlation ID for tracking an observation through the pipeline
-   */
-  correlationId(sessionId, observationNum) {
-    return `obs-${sessionId}-${observationNum}`;
-  }
-  /**
-   * Create session correlation ID
-   */
-  sessionId(sessionId) {
-    return `session-${sessionId}`;
-  }
-  /**
-   * Format data for logging - create compact summaries instead of full dumps
-   */
-  formatData(data) {
-    if (data === null || data === void 0) return "";
-    if (typeof data === "string") return data;
-    if (typeof data === "number") return data.toString();
-    if (typeof data === "boolean") return data.toString();
-    if (typeof data === "object") {
-      if (data instanceof Error) {
-        return this.getLevel() === 0 /* DEBUG */ ? `${data.message}
-${data.stack}` : data.message;
-      }
-      if (Array.isArray(data)) {
-        return `[${data.length} items]`;
-      }
-      const keys = Object.keys(data);
-      if (keys.length === 0) return "{}";
-      if (keys.length <= 3) {
-        return JSON.stringify(data);
-      }
-      return `{${keys.length} keys: ${keys.slice(0, 3).join(", ")}...}`;
-    }
-    return String(data);
-  }
-  /**
-   * Format timestamp in local timezone (YYYY-MM-DD HH:MM:SS.mmm)
-   */
-  formatTimestamp(date) {
-    const year = date.getFullYear();
-    const month = String(date.getMonth() + 1).padStart(2, "0");
-    const day = String(date.getDate()).padStart(2, "0");
-    const hours = String(date.getHours()).padStart(2, "0");
-    const minutes = String(date.getMinutes()).padStart(2, "0");
-    const seconds = String(date.getSeconds()).padStart(2, "0");
-    const ms = String(date.getMilliseconds()).padStart(3, "0");
-    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${ms}`;
-  }
-  /**
-   * Core logging method
-   */
-  log(level, component, message, context, data) {
-    if (level < this.getLevel()) return;
-    this.ensureLogFileInitialized();
-    const timestamp = this.formatTimestamp(/* @__PURE__ */ new Date());
-    const levelStr = LogLevel[level].padEnd(5);
-    const componentStr = component.padEnd(6);
-    let correlationStr = "";
-    if (context?.correlationId) {
-      correlationStr = `[${context.correlationId}] `;
-    } else if (context?.sessionId) {
-      correlationStr = `[session-${context.sessionId}] `;
-    }
-    let dataStr = "";
-    if (data !== void 0 && data !== null) {
-      if (data instanceof Error) {
-        dataStr = this.getLevel() === 0 /* DEBUG */ ? `
-${data.message}
-${data.stack}` : ` ${data.message}`;
-      } else if (this.getLevel() === 0 /* DEBUG */ && typeof data === "object") {
-        dataStr = "\n" + JSON.stringify(data, null, 2);
-      } else {
-        dataStr = " " + this.formatData(data);
-      }
-    }
-    let contextStr = "";
-    if (context) {
-      const { sessionId, memorySessionId, correlationId, ...rest } = context;
-      if (Object.keys(rest).length > 0) {
-        const pairs = Object.entries(rest).map(([k, v]) => `${k}=${v}`);
-        contextStr = ` {${pairs.join(", ")}}`;
-      }
-    }
-    const logLine = `[${timestamp}] [${levelStr}] [${componentStr}] ${correlationStr}${message}${contextStr}${dataStr}`;
-    if (this.logFilePath) {
-      try {
-        appendFileSync(this.logFilePath, logLine + "\n", "utf8");
-      } catch (error) {
-        process.stderr.write(`[LOGGER] Failed to write to log file: ${error}
-`);
-      }
-    } else {
-      process.stderr.write(logLine + "\n");
-    }
-  }
-  // Public logging methods
-  debug(component, message, context, data) {
-    this.log(0 /* DEBUG */, component, message, context, data);
-  }
-  info(component, message, context, data) {
-    this.log(1 /* INFO */, component, message, context, data);
-  }
-  warn(component, message, context, data) {
-    this.log(2 /* WARN */, component, message, context, data);
-  }
-  error(component, message, context, data) {
-    this.log(3 /* ERROR */, component, message, context, data);
-  }
-  /**
-   * Log data flow: input → processing
-   */
-  dataIn(component, message, context, data) {
-    this.info(component, `\u2192 ${message}`, context, data);
-  }
-  /**
-   * Log data flow: processing → output
-   */
-  dataOut(component, message, context, data) {
-    this.info(component, `\u2190 ${message}`, context, data);
-  }
-  /**
-   * Log successful completion
-   */
-  success(component, message, context, data) {
-    this.info(component, `\u2713 ${message}`, context, data);
-  }
-  /**
-   * Log failure
-   */
-  failure(component, message, context, data) {
-    this.error(component, `\u2717 ${message}`, context, data);
-  }
-  /**
-   * Log timing information
-   */
-  timing(component, message, durationMs, context) {
-    this.info(component, `\u23F1 ${message}`, context, { duration: `${durationMs}ms` });
-  }
-  /**
-   * Happy Path Error - logs when the expected "happy path" fails but we have a fallback
-   */
-  happyPathError(component, message, context, data, fallback = "") {
-    const stack = new Error().stack || "";
-    const stackLines = stack.split("\n");
-    const callerLine = stackLines[2] || "";
-    const callerMatch = callerLine.match(/at\s+(?:.*\s+)?\(?([^:]+):(\d+):(\d+)\)?/);
-    const location = callerMatch ? `${callerMatch[1].split("/").pop()}:${callerMatch[2]}` : "unknown";
-    const enhancedContext = {
-      ...context,
-      location
-    };
-    this.warn(component, `[HAPPY-PATH] ${message}`, enhancedContext, data);
-    return fallback;
-  }
-};
-var logger = new Logger();
-
-// src/shared/paths.ts
 function getDirname() {
   if (typeof __dirname !== "undefined") {
     return __dirname;
@@ -329,6 +851,7 @@ function ensureDir(dirPath) {
 }
 
 // src/services/sqlite/Database.ts
+init_logger();
 var SQLITE_MMAP_SIZE_BYTES = 256 * 1024 * 1024;
 var SQLITE_CACHE_SIZE_PAGES = 1e4;
 var KiroMemoryDatabase = class {
@@ -534,6 +1057,55 @@ var MigrationRunner = class {
           `);
           db.run("CREATE UNIQUE INDEX IF NOT EXISTS idx_project_aliases_name ON project_aliases(project_name)");
         }
+      },
+      {
+        version: 4,
+        up: (db) => {
+          db.run(`
+            CREATE TABLE IF NOT EXISTS observation_embeddings (
+              observation_id INTEGER PRIMARY KEY,
+              embedding BLOB NOT NULL,
+              model TEXT NOT NULL,
+              dimensions INTEGER NOT NULL,
+              created_at TEXT NOT NULL,
+              FOREIGN KEY (observation_id) REFERENCES observations(id) ON DELETE CASCADE
+            )
+          `);
+          db.run("CREATE INDEX IF NOT EXISTS idx_embeddings_model ON observation_embeddings(model)");
+        }
+      },
+      {
+        version: 5,
+        up: (db) => {
+          db.run("ALTER TABLE observations ADD COLUMN last_accessed_epoch INTEGER");
+          db.run("ALTER TABLE observations ADD COLUMN is_stale INTEGER DEFAULT 0");
+          db.run("CREATE INDEX IF NOT EXISTS idx_observations_last_accessed ON observations(last_accessed_epoch)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_observations_stale ON observations(is_stale)");
+        }
+      },
+      {
+        version: 6,
+        up: (db) => {
+          db.run(`
+            CREATE TABLE IF NOT EXISTS checkpoints (
+              id INTEGER PRIMARY KEY AUTOINCREMENT,
+              session_id INTEGER NOT NULL,
+              project TEXT NOT NULL,
+              task TEXT NOT NULL,
+              progress TEXT,
+              next_steps TEXT,
+              open_questions TEXT,
+              relevant_files TEXT,
+              context_snapshot TEXT,
+              created_at TEXT NOT NULL,
+              created_at_epoch INTEGER NOT NULL,
+              FOREIGN KEY (session_id) REFERENCES sessions(id)
+            )
+          `);
+          db.run("CREATE INDEX IF NOT EXISTS idx_checkpoints_session ON checkpoints(session_id)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_checkpoints_project ON checkpoints(project)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_checkpoints_epoch ON checkpoints(created_at_epoch)");
+        }
       }
     ];
   }
@@ -563,38 +1135,13 @@ function completeSession(db, id) {
   );
 }
 
-// src/services/sqlite/Observations.ts
-function createObservation(db, memorySessionId, project, type, title, subtitle, text, narrative, facts, concepts, filesRead, filesModified, promptNumber) {
-  const now = /* @__PURE__ */ new Date();
-  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)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-    [memorySessionId, project, type, title, subtitle, text, narrative, facts, concepts, filesRead, filesModified, promptNumber, now.toISOString(), now.getTime()]
-  );
-  return Number(result.lastInsertRowid);
-}
-function getObservationsByProject(db, project, limit = 100) {
-  const query = db.query(
-    "SELECT * FROM observations WHERE project = ? ORDER BY created_at_epoch DESC LIMIT ?"
-  );
-  return query.all(project, limit);
-}
-function searchObservations(db, searchTerm, project) {
-  const sql = project ? `SELECT * FROM observations 
-       WHERE project = ? AND (title LIKE ? OR text LIKE ? OR narrative LIKE ?)
-       ORDER BY created_at_epoch DESC` : `SELECT * FROM observations 
-       WHERE title LIKE ? OR text LIKE ? OR narrative LIKE ?
-       ORDER BY created_at_epoch DESC`;
-  const pattern = `%${searchTerm}%`;
-  const query = db.query(sql);
-  if (project) {
-    return query.all(project, pattern, pattern, pattern);
-  }
-  return query.all(pattern, pattern, pattern);
-}
+// src/services/sqlite/index.ts
+init_Observations();
 
 // src/services/sqlite/Summaries.ts
+function escapeLikePattern2(input) {
+  return input.replace(/[%_\\]/g, "\\$&");
+}
 function createSummary(db, sessionId, project, request, investigated, learned, completed, nextSteps, notes) {
   const now = /* @__PURE__ */ new Date();
   const result = db.run(
@@ -612,12 +1159,12 @@ function getSummariesByProject(db, project, limit = 50) {
   return query.all(project, limit);
 }
 function searchSummaries(db, searchTerm, project) {
-  const sql = project ? `SELECT * FROM summaries 
-       WHERE project = ? AND (request LIKE ? OR learned LIKE ? OR completed LIKE ? OR notes LIKE ?)
-       ORDER BY created_at_epoch DESC` : `SELECT * FROM summaries 
-       WHERE request LIKE ? OR learned LIKE ? OR completed LIKE ? OR notes LIKE ?
+  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
+       WHERE request LIKE ? ESCAPE '\\' OR learned LIKE ? ESCAPE '\\' OR completed LIKE ? ESCAPE '\\' OR notes LIKE ? ESCAPE '\\'
        ORDER BY created_at_epoch DESC`;
-  const pattern = `%${searchTerm}%`;
+  const pattern = `%${escapeLikePattern2(searchTerm)}%`;
   const query = db.query(sql);
   if (project) {
     return query.all(project, pattern, pattern, pattern, pattern);
@@ -643,136 +1190,513 @@ function getPromptsByProject(db, project, limit = 100) {
   return query.all(project, limit);
 }
 
-// src/services/sqlite/Search.ts
-function sanitizeFTS5Query(query) {
-  const terms = query.replace(/[""]/g, "").split(/\s+/).filter((t) => t.length > 0).map((t) => `"${t}"`);
-  return terms.join(" ");
+// src/services/sqlite/Checkpoints.ts
+function createCheckpoint(db, sessionId, project, data) {
+  const now = /* @__PURE__ */ new Date();
+  const result = db.run(
+    `INSERT INTO checkpoints (session_id, project, task, progress, next_steps, open_questions, relevant_files, context_snapshot, created_at, created_at_epoch)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [
+      sessionId,
+      project,
+      data.task,
+      data.progress || null,
+      data.nextSteps || null,
+      data.openQuestions || null,
+      data.relevantFiles || null,
+      data.contextSnapshot || null,
+      now.toISOString(),
+      now.getTime()
+    ]
+  );
+  return Number(result.lastInsertRowid);
 }
-function searchObservationsFTS(db, query, filters = {}) {
-  const limit = filters.limit || 50;
-  try {
-    const safeQuery = sanitizeFTS5Query(query);
-    if (!safeQuery) return searchObservationsLIKE(db, query, filters);
-    let sql = `
-      SELECT o.* FROM observations o
-      JOIN observations_fts fts ON o.id = fts.rowid
-      WHERE observations_fts MATCH ?
-    `;
-    const params = [safeQuery];
-    if (filters.project) {
-      sql += " AND o.project = ?";
-      params.push(filters.project);
-    }
-    if (filters.type) {
-      sql += " AND o.type = ?";
-      params.push(filters.type);
+function getLatestCheckpoint(db, sessionId) {
+  const query = db.query(
+    "SELECT * FROM checkpoints WHERE session_id = ? ORDER BY created_at_epoch 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"
+  );
+  return query.get(project);
+}
+
+// src/services/sqlite/Reports.ts
+function getReportData(db, project, startEpoch, endEpoch) {
+  const startDate = new Date(startEpoch);
+  const endDate = new Date(endEpoch);
+  const days = Math.ceil((endEpoch - startEpoch) / (24 * 60 * 60 * 1e3));
+  const label = days <= 7 ? "Weekly" : days <= 31 ? "Monthly" : "Custom";
+  const countInRange = (table, epochCol = "created_at_epoch") => {
+    const sql = project ? `SELECT COUNT(*) as count FROM ${table} WHERE project = ? AND ${epochCol} >= ? AND ${epochCol} <= ?` : `SELECT COUNT(*) as count FROM ${table} WHERE ${epochCol} >= ? AND ${epochCol} <= ?`;
+    const stmt = db.query(sql);
+    const row = project ? stmt.get(project, startEpoch, endEpoch) : stmt.get(startEpoch, endEpoch);
+    return row?.count || 0;
+  };
+  const observations = countInRange("observations");
+  const summaries = countInRange("summaries");
+  const prompts = countInRange("prompts");
+  const sessions = countInRange("sessions", "started_at_epoch");
+  const timelineSql = project ? `SELECT DATE(datetime(created_at_epoch / 1000, 'unixepoch')) as day, COUNT(*) as count
+       FROM observations
+       WHERE project = ? AND created_at_epoch >= ? AND created_at_epoch <= ?
+       GROUP BY day ORDER BY day ASC` : `SELECT DATE(datetime(created_at_epoch / 1000, 'unixepoch')) as day, COUNT(*) as count
+       FROM observations
+       WHERE created_at_epoch >= ? AND created_at_epoch <= ?
+       GROUP BY day ORDER BY day ASC`;
+  const timelineStmt = db.query(timelineSql);
+  const timeline = project ? timelineStmt.all(project, startEpoch, endEpoch) : timelineStmt.all(startEpoch, endEpoch);
+  const typeSql = project ? `SELECT type, COUNT(*) as count FROM observations
+       WHERE project = ? AND created_at_epoch >= ? AND created_at_epoch <= ?
+       GROUP BY type ORDER BY count DESC` : `SELECT type, COUNT(*) as count FROM observations
+       WHERE created_at_epoch >= ? AND created_at_epoch <= ?
+       GROUP BY type ORDER BY count DESC`;
+  const typeStmt = db.query(typeSql);
+  const typeDistribution = project ? typeStmt.all(project, startEpoch, endEpoch) : typeStmt.all(startEpoch, endEpoch);
+  const sessionTotalSql = project ? `SELECT COUNT(*) as count FROM sessions WHERE project = ? AND started_at_epoch >= ? AND started_at_epoch <= ?` : `SELECT COUNT(*) as count FROM sessions WHERE started_at_epoch >= ? AND started_at_epoch <= ?`;
+  const sessionTotal = (project ? db.query(sessionTotalSql).get(project, startEpoch, endEpoch)?.count : db.query(sessionTotalSql).get(startEpoch, endEpoch)?.count) || 0;
+  const sessionCompletedSql = project ? `SELECT COUNT(*) as count FROM sessions WHERE project = ? AND started_at_epoch >= ? AND started_at_epoch <= ? AND status = 'completed'` : `SELECT COUNT(*) as count FROM sessions WHERE started_at_epoch >= ? AND started_at_epoch <= ? AND status = 'completed'`;
+  const sessionCompleted = (project ? db.query(sessionCompletedSql).get(project, startEpoch, endEpoch)?.count : db.query(sessionCompletedSql).get(startEpoch, endEpoch)?.count) || 0;
+  const sessionAvgSql = project ? `SELECT AVG((completed_at_epoch - started_at_epoch) / 1000.0 / 60.0) as avg_min
+       FROM sessions
+       WHERE project = ? AND started_at_epoch >= ? AND started_at_epoch <= ?
+         AND status = 'completed' AND completed_at_epoch IS NOT NULL AND completed_at_epoch > started_at_epoch` : `SELECT AVG((completed_at_epoch - started_at_epoch) / 1000.0 / 60.0) as avg_min
+       FROM sessions
+       WHERE started_at_epoch >= ? AND started_at_epoch <= ?
+         AND status = 'completed' AND completed_at_epoch IS NOT NULL AND completed_at_epoch > started_at_epoch`;
+  const avgRow = project ? db.query(sessionAvgSql).get(project, startEpoch, endEpoch) : db.query(sessionAvgSql).get(startEpoch, endEpoch);
+  const avgDurationMinutes = Math.round((avgRow?.avg_min || 0) * 10) / 10;
+  const knowledgeSql = project ? `SELECT COUNT(*) as count FROM observations
+       WHERE project = ? AND created_at_epoch >= ? AND created_at_epoch <= ?
+         AND type IN ('constraint', 'decision', 'heuristic', 'rejected')` : `SELECT COUNT(*) as count FROM observations
+       WHERE created_at_epoch >= ? AND created_at_epoch <= ?
+         AND type IN ('constraint', 'decision', 'heuristic', 'rejected')`;
+  const knowledgeCount = (project ? db.query(knowledgeSql).get(project, startEpoch, endEpoch)?.count : db.query(knowledgeSql).get(startEpoch, endEpoch)?.count) || 0;
+  const staleSql = project ? `SELECT COUNT(*) as count FROM observations
+       WHERE project = ? AND created_at_epoch >= ? AND created_at_epoch <= ? AND is_stale = 1` : `SELECT COUNT(*) as count FROM observations
+       WHERE created_at_epoch >= ? AND created_at_epoch <= ? AND is_stale = 1`;
+  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
+       WHERE created_at_epoch >= ? AND created_at_epoch <= ?
+       ORDER BY created_at_epoch DESC`;
+  const summaryRows = project ? db.query(summarySql).all(project, startEpoch, endEpoch) : db.query(summarySql).all(startEpoch, endEpoch);
+  const topLearnings = [];
+  const completedTasks = [];
+  const nextStepsArr = [];
+  for (const row of summaryRows) {
+    if (row.learned) {
+      const parts = row.learned.split("; ").filter(Boolean);
+      topLearnings.push(...parts);
     }
-    if (filters.dateStart) {
-      sql += " AND o.created_at_epoch >= ?";
-      params.push(filters.dateStart);
+    if (row.completed) {
+      const parts = row.completed.split("; ").filter(Boolean);
+      completedTasks.push(...parts);
     }
-    if (filters.dateEnd) {
-      sql += " AND o.created_at_epoch <= ?";
-      params.push(filters.dateEnd);
+    if (row.next_steps) {
+      const parts = row.next_steps.split("; ").filter(Boolean);
+      nextStepsArr.push(...parts);
     }
-    sql += " ORDER BY rank LIMIT ?";
-    params.push(limit);
-    const stmt = db.query(sql);
-    return stmt.all(...params);
-  } catch {
-    return searchObservationsLIKE(db, query, filters);
   }
+  const filesSql = project ? `SELECT files_modified FROM observations
+       WHERE project = ? AND created_at_epoch >= ? AND created_at_epoch <= ?
+         AND files_modified IS NOT NULL AND files_modified != ''` : `SELECT files_modified FROM observations
+       WHERE created_at_epoch >= ? AND created_at_epoch <= ?
+         AND files_modified IS NOT NULL AND files_modified != ''`;
+  const fileRows = project ? db.query(filesSql).all(project, startEpoch, endEpoch) : db.query(filesSql).all(startEpoch, endEpoch);
+  const fileCounts = /* @__PURE__ */ new Map();
+  for (const row of fileRows) {
+    const files = row.files_modified.split(",").map((f) => f.trim()).filter(Boolean);
+    for (const file of files) {
+      fileCounts.set(file, (fileCounts.get(file) || 0) + 1);
+    }
+  }
+  const fileHotspots = Array.from(fileCounts.entries()).map(([file, count]) => ({ file, count })).sort((a, b) => b.count - a.count).slice(0, 15);
+  return {
+    period: {
+      start: startDate.toISOString().split("T")[0],
+      end: endDate.toISOString().split("T")[0],
+      days,
+      label
+    },
+    overview: {
+      observations,
+      summaries,
+      sessions,
+      prompts,
+      knowledgeCount,
+      staleCount
+    },
+    timeline,
+    typeDistribution,
+    sessionStats: {
+      total: sessionTotal,
+      completed: sessionCompleted,
+      avgDurationMinutes
+    },
+    topLearnings: [...new Set(topLearnings)].slice(0, 10),
+    completedTasks: [...new Set(completedTasks)].slice(0, 10),
+    nextSteps: [...new Set(nextStepsArr)].slice(0, 10),
+    fileHotspots
+  };
 }
-function searchObservationsLIKE(db, query, filters = {}) {
-  const limit = filters.limit || 50;
-  const pattern = `%${query}%`;
-  let sql = `
-    SELECT * FROM observations
-    WHERE (title LIKE ? OR text LIKE ? OR narrative LIKE ? OR concepts LIKE ?)
-  `;
-  const params = [pattern, pattern, pattern, pattern];
-  if (filters.project) {
-    sql += " AND project = ?";
-    params.push(filters.project);
+
+// src/services/sqlite/index.ts
+init_Search();
+
+// src/sdk/index.ts
+init_Observations();
+init_Search();
+
+// src/services/search/HybridSearch.ts
+init_EmbeddingService();
+
+// src/services/search/VectorSearch.ts
+init_EmbeddingService();
+init_logger();
+function cosineSimilarity(a, b) {
+  if (a.length !== 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);
+  if (denominator === 0) return 0;
+  return dotProduct / denominator;
+}
+function float32ToBuffer(arr) {
+  return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function bufferToFloat32(buf) {
+  const arrayBuffer = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+  return new Float32Array(arrayBuffer);
+}
+var VectorSearch = class {
+  /**
+   * Ricerca semantica: calcola cosine similarity tra query e tutti gli embeddings.
+   */
+  async search(db, queryEmbedding, options = {}) {
+    const limit = options.limit || 10;
+    const threshold = options.threshold || 0.3;
+    try {
+      let 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
+      `;
+      const params = [];
+      if (options.project) {
+        sql += " WHERE o.project = ?";
+        params.push(options.project);
+      }
+      const rows = db.query(sql).all(...params);
+      const scored = [];
+      for (const row of rows) {
+        const embedding = bufferToFloat32(row.embedding);
+        const similarity = cosineSimilarity(queryEmbedding, embedding);
+        if (similarity >= threshold) {
+          scored.push({
+            id: row.observation_id,
+            observationId: row.observation_id,
+            similarity,
+            title: row.title,
+            text: row.text,
+            type: row.type,
+            project: row.project,
+            created_at: row.created_at,
+            created_at_epoch: row.created_at_epoch
+          });
+        }
+      }
+      scored.sort((a, b) => b.similarity - a.similarity);
+      return scored.slice(0, limit);
+    } catch (error) {
+      logger.error("VECTOR", `Errore ricerca vettoriale: ${error}`);
+      return [];
+    }
   }
-  if (filters.type) {
-    sql += " AND type = ?";
-    params.push(filters.type);
+  /**
+   * Salva embedding per un'osservazione.
+   */
+  async storeEmbedding(db, observationId, embedding, model) {
+    try {
+      const blob = float32ToBuffer(embedding);
+      db.query(`
+        INSERT OR REPLACE INTO observation_embeddings
+          (observation_id, embedding, model, dimensions, created_at)
+        VALUES (?, ?, ?, ?, ?)
+      `).run(
+        observationId,
+        blob,
+        model,
+        embedding.length,
+        (/* @__PURE__ */ new Date()).toISOString()
+      );
+      logger.debug("VECTOR", `Embedding salvato per osservazione ${observationId}`);
+    } catch (error) {
+      logger.error("VECTOR", `Errore salvataggio embedding: ${error}`);
+    }
   }
-  if (filters.dateStart) {
-    sql += " AND created_at_epoch >= ?";
-    params.push(filters.dateStart);
+  /**
+   * Genera embeddings per osservazioni che non li hanno ancora.
+   */
+  async backfillEmbeddings(db, batchSize = 50) {
+    const embeddingService2 = getEmbeddingService();
+    if (!await embeddingService2.initialize()) {
+      logger.warn("VECTOR", "Embedding service non disponibile, backfill saltato");
+      return 0;
+    }
+    const rows = db.query(`
+      SELECT o.id, o.title, o.text, o.narrative, o.concepts
+      FROM observations o
+      LEFT JOIN observation_embeddings e ON e.observation_id = o.id
+      WHERE e.observation_id IS NULL
+      ORDER BY o.created_at_epoch DESC
+      LIMIT ?
+    `).all(batchSize);
+    if (rows.length === 0) return 0;
+    let count = 0;
+    const model = embeddingService2.getProvider() || "unknown";
+    for (const row of rows) {
+      const parts = [row.title];
+      if (row.text) parts.push(row.text);
+      if (row.narrative) parts.push(row.narrative);
+      if (row.concepts) parts.push(row.concepts);
+      const fullText = parts.join(" ").substring(0, 2e3);
+      const embedding = await embeddingService2.embed(fullText);
+      if (embedding) {
+        await this.storeEmbedding(db, row.id, embedding, model);
+        count++;
+      }
+    }
+    logger.info("VECTOR", `Backfill completato: ${count}/${rows.length} embeddings generati`);
+    return count;
   }
-  if (filters.dateEnd) {
-    sql += " AND created_at_epoch <= ?";
-    params.push(filters.dateEnd);
+  /**
+   * Statistiche sugli embeddings.
+   */
+  getStats(db) {
+    try {
+      const totalRow = db.query("SELECT COUNT(*) as count FROM observations").get();
+      const embeddedRow = db.query("SELECT COUNT(*) as count FROM observation_embeddings").get();
+      const total = totalRow?.count || 0;
+      const embedded = embeddedRow?.count || 0;
+      const percentage = total > 0 ? Math.round(embedded / total * 100) : 0;
+      return { total, embedded, percentage };
+    } catch {
+      return { total: 0, embedded: 0, percentage: 0 };
+    }
   }
-  sql += " ORDER BY created_at_epoch DESC LIMIT ?";
-  params.push(limit);
-  const stmt = db.query(sql);
-  return stmt.all(...params);
+};
+var vectorSearch = null;
+function getVectorSearch() {
+  if (!vectorSearch) {
+    vectorSearch = new VectorSearch();
+  }
+  return vectorSearch;
 }
-function searchSummariesFiltered(db, query, filters = {}) {
-  const limit = filters.limit || 20;
-  const pattern = `%${query}%`;
-  let sql = `
-    SELECT * FROM summaries
-    WHERE (request LIKE ? OR learned LIKE ? OR completed LIKE ? OR notes LIKE ? OR next_steps LIKE ?)
-  `;
-  const params = [pattern, pattern, pattern, pattern, pattern];
-  if (filters.project) {
-    sql += " AND project = ?";
-    params.push(filters.project);
+
+// src/services/search/ScoringEngine.ts
+var SEARCH_WEIGHTS = {
+  semantic: 0.4,
+  fts5: 0.3,
+  recency: 0.2,
+  projectMatch: 0.1
+};
+var CONTEXT_WEIGHTS = {
+  semantic: 0,
+  fts5: 0,
+  recency: 0.7,
+  projectMatch: 0.3
+};
+function recencyScore(createdAtEpoch, halfLifeHours = 168) {
+  if (!createdAtEpoch || createdAtEpoch <= 0) return 0;
+  const nowMs = Date.now();
+  const ageMs = nowMs - createdAtEpoch;
+  if (ageMs <= 0) return 1;
+  const ageHours = ageMs / (1e3 * 60 * 60);
+  return Math.exp(-ageHours * Math.LN2 / halfLifeHours);
+}
+function normalizeFTS5Rank(rank, allRanks) {
+  if (allRanks.length === 0) return 0;
+  if (allRanks.length === 1) return 1;
+  const minRank = Math.min(...allRanks);
+  const maxRank = Math.max(...allRanks);
+  if (minRank === maxRank) return 1;
+  return (maxRank - rank) / (maxRank - minRank);
+}
+function projectMatchScore(itemProject, targetProject) {
+  if (!itemProject || !targetProject) return 0;
+  return itemProject.toLowerCase() === targetProject.toLowerCase() ? 1 : 0;
+}
+function computeCompositeScore(signals, weights) {
+  return signals.semantic * weights.semantic + signals.fts5 * weights.fts5 + signals.recency * weights.recency + signals.projectMatch * weights.projectMatch;
+}
+var KNOWLEDGE_TYPE_BOOST = {
+  constraint: 1.3,
+  decision: 1.25,
+  heuristic: 1.15,
+  rejected: 1.1
+};
+function knowledgeTypeBoost(type) {
+  return KNOWLEDGE_TYPE_BOOST[type] ?? 1;
+}
+
+// src/services/search/HybridSearch.ts
+init_logger();
+var HybridSearch = class {
+  embeddingInitialized = false;
+  /**
+   * Inizializza il servizio di embedding (lazy, non bloccante)
+   */
+  async initialize() {
+    try {
+      const embeddingService2 = getEmbeddingService();
+      await embeddingService2.initialize();
+      this.embeddingInitialized = embeddingService2.isAvailable();
+      logger.info("SEARCH", `HybridSearch inizializzato (embedding: ${this.embeddingInitialized ? "attivo" : "disattivato"})`);
+    } catch (error) {
+      logger.warn("SEARCH", "Inizializzazione embedding fallita, uso solo FTS5", {}, error);
+      this.embeddingInitialized = false;
+    }
   }
-  if (filters.dateStart) {
-    sql += " AND created_at_epoch >= ?";
-    params.push(filters.dateStart);
+  /**
+   * Ricerca ibrida con scoring a 4 segnali
+   */
+  async search(db, query, options = {}) {
+    const limit = options.limit || 10;
+    const weights = options.weights || SEARCH_WEIGHTS;
+    const targetProject = options.project || "";
+    const rawItems = /* @__PURE__ */ new Map();
+    if (this.embeddingInitialized) {
+      try {
+        const embeddingService2 = getEmbeddingService();
+        const queryEmbedding = await embeddingService2.embed(query);
+        if (queryEmbedding) {
+          const vectorSearch2 = getVectorSearch();
+          const vectorResults = await vectorSearch2.search(db, queryEmbedding, {
+            project: options.project,
+            limit: limit * 2,
+            // Prendiamo piu risultati per il ranking
+            threshold: 0.3
+          });
+          for (const hit of vectorResults) {
+            rawItems.set(String(hit.observationId), {
+              id: String(hit.observationId),
+              title: hit.title,
+              content: hit.text || "",
+              type: hit.type,
+              project: hit.project,
+              created_at: hit.created_at,
+              created_at_epoch: hit.created_at_epoch,
+              semanticScore: hit.similarity,
+              fts5Rank: null,
+              source: "vector"
+            });
+          }
+          logger.debug("SEARCH", `Vector search: ${vectorResults.length} risultati`);
+        }
+      } catch (error) {
+        logger.warn("SEARCH", "Ricerca vettoriale fallita, uso solo keyword", {}, error);
+      }
+    }
+    try {
+      const { searchObservationsFTSWithRank: searchObservationsFTSWithRank2 } = await Promise.resolve().then(() => (init_Search(), Search_exports));
+      const keywordResults = searchObservationsFTSWithRank2(db, query, {
+        project: options.project,
+        limit: limit * 2
+      });
+      for (const obs of keywordResults) {
+        const id = String(obs.id);
+        const existing = rawItems.get(id);
+        if (existing) {
+          existing.fts5Rank = obs.fts5_rank;
+          existing.source = "vector";
+        } else {
+          rawItems.set(id, {
+            id,
+            title: obs.title,
+            content: obs.text || obs.narrative || "",
+            type: obs.type,
+            project: obs.project,
+            created_at: obs.created_at,
+            created_at_epoch: obs.created_at_epoch,
+            semanticScore: 0,
+            fts5Rank: obs.fts5_rank,
+            source: "keyword"
+          });
+        }
+      }
+      logger.debug("SEARCH", `Keyword search: ${keywordResults.length} risultati`);
+    } catch (error) {
+      logger.error("SEARCH", "Ricerca keyword fallita", {}, error);
+    }
+    if (rawItems.size === 0) return [];
+    const allFTS5Ranks = Array.from(rawItems.values()).filter((item) => item.fts5Rank !== null).map((item) => item.fts5Rank);
+    const scored = [];
+    for (const item of rawItems.values()) {
+      const signals = {
+        semantic: item.semanticScore,
+        fts5: item.fts5Rank !== null ? normalizeFTS5Rank(item.fts5Rank, allFTS5Ranks) : 0,
+        recency: recencyScore(item.created_at_epoch),
+        projectMatch: targetProject ? projectMatchScore(item.project, targetProject) : 0
+      };
+      const score = computeCompositeScore(signals, weights);
+      const isHybrid = item.semanticScore > 0 && item.fts5Rank !== null;
+      const hybridBoost = isHybrid ? 1.15 : 1;
+      const finalScore = Math.min(1, score * hybridBoost * knowledgeTypeBoost(item.type));
+      scored.push({
+        id: item.id,
+        title: item.title,
+        content: item.content,
+        type: item.type,
+        project: item.project,
+        created_at: item.created_at,
+        created_at_epoch: item.created_at_epoch,
+        score: finalScore,
+        source: isHybrid ? "hybrid" : item.source,
+        signals
+      });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    const finalResults = scored.slice(0, limit);
+    if (finalResults.length > 0) {
+      try {
+        const { updateLastAccessed: updateLastAccessed3 } = await Promise.resolve().then(() => (init_Observations(), Observations_exports));
+        const ids = finalResults.map((r) => parseInt(r.id, 10)).filter((id) => id > 0);
+        if (ids.length > 0) {
+          updateLastAccessed3(db, ids);
+        }
+      } catch {
+      }
+    }
+    return finalResults;
   }
-  if (filters.dateEnd) {
-    sql += " AND created_at_epoch <= ?";
-    params.push(filters.dateEnd);
+};
+var hybridSearch = null;
+function getHybridSearch() {
+  if (!hybridSearch) {
+    hybridSearch = new HybridSearch();
   }
-  sql += " ORDER BY created_at_epoch DESC LIMIT ?";
-  params.push(limit);
-  const stmt = db.query(sql);
-  return stmt.all(...params);
-}
-function getObservationsByIds(db, ids) {
-  if (ids.length === 0) return [];
-  const placeholders = ids.map(() => "?").join(",");
-  const sql = `SELECT * FROM observations WHERE id IN (${placeholders}) ORDER BY created_at_epoch DESC`;
-  const stmt = db.query(sql);
-  return stmt.all(...ids);
-}
-function getTimeline(db, anchorId, depthBefore = 5, depthAfter = 5) {
-  const anchorStmt = db.query("SELECT created_at_epoch FROM observations WHERE id = ?");
-  const anchor = anchorStmt.get(anchorId);
-  if (!anchor) return [];
-  const anchorEpoch = anchor.created_at_epoch;
-  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
-    LIMIT ?
-  `);
-  const before = beforeStmt.all(anchorEpoch, 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 = ?
-  `);
-  const self = selfStmt.all(anchorId);
-  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
-    LIMIT ?
-  `);
-  const after = afterStmt.all(anchorEpoch, depthAfter);
-  return [...before, ...self, ...after];
+  return hybridSearch;
 }
 
+// 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;
@@ -805,11 +1729,62 @@ var KiroMemorySDK = class {
       recentPrompts: getPromptsByProject(this.db.db, this.project, 10)
     };
   }
+  /**
+   * Valida input per storeObservation
+   */
+  validateObservationInput(data) {
+    if (!data.type || typeof data.type !== "string" || data.type.length > 100) {
+      throw new Error("type \xE8 obbligatorio (stringa, max 100 caratteri)");
+    }
+    if (!data.title || typeof data.title !== "string" || data.title.length > 500) {
+      throw new Error("title \xE8 obbligatorio (stringa, max 500 caratteri)");
+    }
+    if (!data.content || typeof data.content !== "string" || data.content.length > 1e5) {
+      throw new Error("content \xE8 obbligatorio (stringa, max 100KB)");
+    }
+  }
+  /**
+   * Valida input per 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)`);
+      }
+    }
+  }
+  /**
+   * Genera e salva embedding per un'osservazione (fire-and-forget, non blocca)
+   */
+  async generateEmbeddingAsync(observationId, title, content, concepts) {
+    try {
+      const embeddingService2 = getEmbeddingService();
+      if (!embeddingService2.isAvailable()) return;
+      const parts = [title, content];
+      if (concepts?.length) parts.push(concepts.join(", "));
+      const fullText = parts.join(" ").substring(0, 2e3);
+      const embedding = await embeddingService2.embed(fullText);
+      if (embedding) {
+        const vectorSearch2 = getVectorSearch();
+        await vectorSearch2.storeEmbedding(
+          this.db.db,
+          observationId,
+          embedding,
+          embeddingService2.getProvider() || "unknown"
+        );
+      }
+    } catch (error) {
+      logger.debug("SDK", `Embedding generation fallita per obs ${observationId}: ${error}`);
+    }
+  }
   /**
    * Store a new observation
    */
   async storeObservation(data) {
-    return createObservation(
+    this.validateObservationInput(data);
+    const observationId = createObservation(
       this.db.db,
       "sdk-" + Date.now(),
       this.project,
@@ -830,11 +1805,76 @@ var KiroMemorySDK = class {
       0
       // prompt_number
     );
+    this.generateEmbeddingAsync(observationId, data.title, data.content, data.concepts).catch(() => {
+    });
+    return observationId;
+  }
+  /**
+   * Salva conoscenza strutturata (constraint, decision, heuristic, rejected).
+   * Usa il campo `type` per il knowledgeType e `facts` per i metadati JSON.
+   */
+  async storeKnowledge(data) {
+    if (!KNOWLEDGE_TYPES.includes(data.knowledgeType)) {
+      throw new Error(`knowledgeType non valido: ${data.knowledgeType}. Valori ammessi: ${KNOWLEDGE_TYPES.join(", ")}`);
+    }
+    this.validateObservationInput({ type: data.knowledgeType, title: data.title, content: data.content });
+    const metadata = (() => {
+      switch (data.knowledgeType) {
+        case "constraint":
+          return {
+            knowledgeType: "constraint",
+            severity: data.metadata?.severity || "soft",
+            reason: data.metadata?.reason
+          };
+        case "decision":
+          return {
+            knowledgeType: "decision",
+            alternatives: data.metadata?.alternatives,
+            reason: data.metadata?.reason
+          };
+        case "heuristic":
+          return {
+            knowledgeType: "heuristic",
+            context: data.metadata?.context,
+            confidence: data.metadata?.confidence
+          };
+        case "rejected":
+          return {
+            knowledgeType: "rejected",
+            reason: data.metadata?.reason || "",
+            alternatives: data.metadata?.alternatives
+          };
+      }
+    })();
+    const observationId = createObservation(
+      this.db.db,
+      "sdk-" + Date.now(),
+      data.project || this.project,
+      data.knowledgeType,
+      // type = knowledgeType
+      data.title,
+      null,
+      // subtitle
+      data.content,
+      null,
+      // narrative
+      JSON.stringify(metadata),
+      // facts = metadati JSON
+      data.concepts?.join(", ") || null,
+      data.files?.join(", ") || null,
+      data.files?.join(", ") || null,
+      0
+      // prompt_number
+    );
+    this.generateEmbeddingAsync(observationId, data.title, data.content, data.concepts).catch(() => {
+    });
+    return observationId;
   }
   /**
    * Store a session summary
    */
   async storeSummary(data) {
+    this.validateSummaryInput(data);
     return createSummary(
       this.db.db,
       "sdk-" + Date.now(),
@@ -910,25 +1950,246 @@ var KiroMemorySDK = class {
         completed_at_epoch: null
       };
     }
-    return session;
+    return session;
+  }
+  /**
+   * Store a user prompt
+   */
+  async storePrompt(contentSessionId, promptNumber, text) {
+    return createPrompt(this.db.db, contentSessionId, this.project, promptNumber, text);
+  }
+  /**
+   * Complete a session
+   */
+  async completeSession(sessionId) {
+    completeSession(this.db.db, sessionId);
+  }
+  /**
+   * Getter for current project name
+   */
+  getProject() {
+    return this.project;
+  }
+  /**
+   * Ricerca ibrida: vector search + keyword FTS5
+   * Richiede inizializzazione HybridSearch (embedding service)
+   */
+  async hybridSearch(query, options = {}) {
+    const hybridSearch2 = getHybridSearch();
+    return hybridSearch2.search(this.db.db, query, {
+      project: this.project,
+      limit: options.limit || 10
+    });
+  }
+  /**
+   * Ricerca solo semantica (vector search)
+   * Ritorna risultati basati su similarità coseno con gli embeddings
+   */
+  async semanticSearch(query, options = {}) {
+    const embeddingService2 = getEmbeddingService();
+    if (!embeddingService2.isAvailable()) {
+      await embeddingService2.initialize();
+    }
+    if (!embeddingService2.isAvailable()) return [];
+    const queryEmbedding = await embeddingService2.embed(query);
+    if (!queryEmbedding) return [];
+    const vectorSearch2 = getVectorSearch();
+    const results = await vectorSearch2.search(this.db.db, queryEmbedding, {
+      project: this.project,
+      limit: options.limit || 10,
+      threshold: options.threshold || 0.3
+    });
+    return results.map((r) => ({
+      id: String(r.observationId),
+      title: r.title,
+      content: r.text || "",
+      type: r.type,
+      project: r.project,
+      created_at: r.created_at,
+      created_at_epoch: r.created_at_epoch,
+      score: r.similarity,
+      source: "vector",
+      signals: {
+        semantic: r.similarity,
+        fts5: 0,
+        recency: recencyScore(r.created_at_epoch),
+        projectMatch: projectMatchScore(r.project, this.project)
+      }
+    }));
+  }
+  /**
+   * Genera embeddings per osservazioni che non li hanno ancora
+   */
+  async backfillEmbeddings(batchSize = 50) {
+    const vectorSearch2 = getVectorSearch();
+    return vectorSearch2.backfillEmbeddings(this.db.db, batchSize);
+  }
+  /**
+   * Statistiche sugli embeddings nel database
+   */
+  getEmbeddingStats() {
+    const vectorSearch2 = getVectorSearch();
+    return vectorSearch2.getStats(this.db.db);
+  }
+  /**
+   * Inizializza il servizio di embedding (lazy, chiamare prima di hybridSearch)
+   */
+  async initializeEmbeddings() {
+    const hybridSearch2 = getHybridSearch();
+    await hybridSearch2.initialize();
+    return getEmbeddingService().isAvailable();
+  }
+  /**
+   * Contesto smart con ranking a 4 segnali e budget token.
+   *
+   * Se query presente: usa HybridSearch con SEARCH_WEIGHTS.
+   * Se senza query: ranking per recency + project match (CONTEXT_WEIGHTS).
+   */
+  async getSmartContext(options = {}) {
+    const tokenBudget = options.tokenBudget || parseInt(process.env.KIRO_MEMORY_CONTEXT_TOKENS || "0", 10) || 2e3;
+    const summaries = getSummariesByProject(this.db.db, this.project, 5);
+    let items;
+    if (options.query) {
+      const hybridSearch2 = getHybridSearch();
+      const results = await hybridSearch2.search(this.db.db, options.query, {
+        project: this.project,
+        limit: 30
+      });
+      items = results.map((r) => ({
+        id: parseInt(r.id, 10) || 0,
+        title: r.title,
+        content: r.content,
+        type: r.type,
+        project: r.project,
+        created_at: r.created_at,
+        created_at_epoch: r.created_at_epoch,
+        score: r.score,
+        signals: r.signals
+      }));
+    } else {
+      const observations = getObservationsByProject(this.db.db, this.project, 30);
+      items = observations.map((obs) => {
+        const signals = {
+          semantic: 0,
+          fts5: 0,
+          recency: recencyScore(obs.created_at_epoch),
+          projectMatch: projectMatchScore(obs.project, this.project)
+        };
+        const baseScore = computeCompositeScore(signals, CONTEXT_WEIGHTS);
+        const boostedScore = Math.min(1, baseScore * knowledgeTypeBoost(obs.type));
+        return {
+          id: obs.id,
+          title: obs.title,
+          content: obs.text || obs.narrative || "",
+          type: obs.type,
+          project: obs.project,
+          created_at: obs.created_at,
+          created_at_epoch: obs.created_at_epoch,
+          score: boostedScore,
+          signals
+        };
+      });
+      items.sort((a, b) => b.score - a.score);
+    }
+    let tokensUsed = 0;
+    for (const item of items) {
+      tokensUsed += Math.ceil((item.title.length + item.content.length) / 4);
+      if (tokensUsed > tokenBudget) break;
+    }
+    return {
+      project: this.project,
+      items,
+      summaries,
+      tokenBudget,
+      tokensUsed: Math.min(tokensUsed, tokenBudget)
+    };
+  }
+  /**
+   * Rileva osservazioni stale (file modificati dopo la creazione) e le marca nel DB.
+   * Ritorna il numero di osservazioni marcate come stale.
+   */
+  async detectStaleObservations() {
+    const staleObs = getStaleObservations(this.db.db, this.project);
+    if (staleObs.length > 0) {
+      const ids = staleObs.map((o) => o.id);
+      markObservationsStale(this.db.db, ids, true);
+    }
+    return staleObs.length;
   }
   /**
-   * Store a user prompt
+   * Consolida osservazioni duplicate sullo stesso file e tipo.
+   * Raggruppa per (project, type, files_modified), mantiene la piu recente.
    */
-  async storePrompt(contentSessionId, promptNumber, text) {
-    return createPrompt(this.db.db, contentSessionId, this.project, promptNumber, text);
+  async consolidateObservations(options = {}) {
+    return consolidateObservations(this.db.db, this.project, options);
   }
   /**
-   * Complete a session
+   * Statistiche decay: totale, stale, mai accedute, accedute di recente.
    */
-  async completeSession(sessionId) {
-    completeSession(this.db.db, sessionId);
+  async getDecayStats() {
+    const total = this.db.db.query(
+      "SELECT COUNT(*) as count FROM observations WHERE project = ?"
+    ).get(this.project)?.count || 0;
+    const stale = this.db.db.query(
+      "SELECT COUNT(*) as count FROM observations WHERE project = ? AND is_stale = 1"
+    ).get(this.project)?.count || 0;
+    const neverAccessed = this.db.db.query(
+      "SELECT COUNT(*) as count FROM observations WHERE project = ? AND last_accessed_epoch IS NULL"
+    ).get(this.project)?.count || 0;
+    const recentThreshold = Date.now() - 48 * 60 * 60 * 1e3;
+    const recentlyAccessed = this.db.db.query(
+      "SELECT COUNT(*) as count FROM observations WHERE project = ? AND last_accessed_epoch > ?"
+    ).get(this.project, recentThreshold)?.count || 0;
+    return { total, stale, neverAccessed, recentlyAccessed };
   }
   /**
-   * Getter for current project name
+   * Crea un checkpoint strutturato per resume sessione.
+   * Salva automaticamente un context_snapshot con le ultime 10 osservazioni.
    */
-  getProject() {
-    return this.project;
+  async createCheckpoint(sessionId, data) {
+    const recentObs = getObservationsByProject(this.db.db, this.project, 10);
+    const contextSnapshot = JSON.stringify(
+      recentObs.map((o) => ({ id: o.id, type: o.type, title: o.title, text: o.text?.substring(0, 200) }))
+    );
+    return createCheckpoint(this.db.db, sessionId, this.project, {
+      task: data.task,
+      progress: data.progress,
+      nextSteps: data.nextSteps,
+      openQuestions: data.openQuestions,
+      relevantFiles: data.relevantFiles?.join(", "),
+      contextSnapshot
+    });
+  }
+  /**
+   * Recupera l'ultimo checkpoint di una sessione specifica.
+   */
+  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.
+   */
+  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.
+   */
+  async generateReport(options) {
+    const now = /* @__PURE__ */ new Date();
+    let startEpoch;
+    let endEpoch = now.getTime();
+    if (options?.startDate && options?.endDate) {
+      startEpoch = options.startDate.getTime();
+      endEpoch = options.endDate.getTime();
+    } else {
+      const period = options?.period || "weekly";
+      const daysBack = period === "monthly" ? 30 : 7;
+      startEpoch = endEpoch - daysBack * 24 * 60 * 60 * 1e3;
+    }
+    return getReportData(this.db.db, this.project, startEpoch, endEpoch);
   }
   /**
    * Getter for direct database access (for API routes)
@@ -947,9 +2208,172 @@ function createKiroMemory(config) {
   return new KiroMemorySDK(config);
 }
 
+// src/services/report-formatter.ts
+function formatReportText(data) {
+  const lines = [];
+  lines.push("");
+  lines.push(`  \x1B[36m\u2550\u2550\u2550 Kiro Memory Report \u2014 ${data.period.label} \u2550\u2550\u2550\x1B[0m`);
+  lines.push(`  \x1B[2m${data.period.start} \u2192 ${data.period.end} (${data.period.days} days)\x1B[0m`);
+  lines.push("");
+  lines.push(`  \x1B[1mOverview\x1B[0m`);
+  lines.push(`    Observations:  ${data.overview.observations}`);
+  lines.push(`    Summaries:     ${data.overview.summaries}`);
+  lines.push(`    Sessions:      ${data.overview.sessions}`);
+  lines.push(`    Prompts:       ${data.overview.prompts}`);
+  lines.push(`    Knowledge:     ${data.overview.knowledgeCount}`);
+  if (data.overview.staleCount > 0) {
+    lines.push(`    Stale:         ${data.overview.staleCount}`);
+  }
+  lines.push("");
+  if (data.sessionStats.total > 0) {
+    const completionPct = data.sessionStats.total > 0 ? Math.round(data.sessionStats.completed / data.sessionStats.total * 100) : 0;
+    lines.push(`  \x1B[1mSessions\x1B[0m`);
+    lines.push(`    Total: ${data.sessionStats.total} | Completed: ${data.sessionStats.completed} (${completionPct}%)`);
+    if (data.sessionStats.avgDurationMinutes > 0) {
+      lines.push(`    Avg duration: ${data.sessionStats.avgDurationMinutes} min`);
+    }
+    lines.push("");
+  }
+  if (data.timeline.length > 0) {
+    lines.push(`  \x1B[1mTimeline\x1B[0m`);
+    const maxCount = Math.max(...data.timeline.map((t) => t.count));
+    const maxBarLen = 30;
+    for (const entry of data.timeline) {
+      const barLen = maxCount > 0 ? Math.round(entry.count / maxCount * maxBarLen) : 0;
+      const bar = "\x1B[32m" + "\u2593".repeat(barLen) + "\x1B[0m";
+      const dayShort = entry.day.substring(5);
+      lines.push(`    ${dayShort}  ${bar} ${entry.count}`);
+    }
+    lines.push("");
+  }
+  if (data.typeDistribution.length > 0) {
+    lines.push(`  \x1B[1mBy Type\x1B[0m`);
+    for (const entry of data.typeDistribution) {
+      lines.push(`    ${entry.type.padEnd(16)} ${entry.count}`);
+    }
+    lines.push("");
+  }
+  if (data.topLearnings.length > 0) {
+    lines.push(`  \x1B[1mKey Learnings\x1B[0m`);
+    for (const learning of data.topLearnings) {
+      lines.push(`    - ${learning}`);
+    }
+    lines.push("");
+  }
+  if (data.completedTasks.length > 0) {
+    lines.push(`  \x1B[1mCompleted\x1B[0m`);
+    for (const task of data.completedTasks) {
+      lines.push(`    - ${task}`);
+    }
+    lines.push("");
+  }
+  if (data.nextSteps.length > 0) {
+    lines.push(`  \x1B[1mNext Steps\x1B[0m`);
+    for (const step of data.nextSteps) {
+      lines.push(`    - ${step}`);
+    }
+    lines.push("");
+  }
+  if (data.fileHotspots.length > 0) {
+    lines.push(`  \x1B[1mFile Hotspots\x1B[0m`);
+    for (const entry of data.fileHotspots.slice(0, 10)) {
+      lines.push(`    ${entry.file} (${entry.count}x)`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatReportMarkdown(data) {
+  const lines = [];
+  lines.push(`# Kiro Memory Report \u2014 ${data.period.label}`);
+  lines.push("");
+  lines.push(`**Period**: ${data.period.start} \u2192 ${data.period.end} (${data.period.days} days)`);
+  lines.push("");
+  lines.push("## Overview");
+  lines.push("");
+  lines.push("| Metric | Count |");
+  lines.push("|--------|------:|");
+  lines.push(`| Observations | ${data.overview.observations} |`);
+  lines.push(`| Summaries | ${data.overview.summaries} |`);
+  lines.push(`| Sessions | ${data.overview.sessions} |`);
+  lines.push(`| Prompts | ${data.overview.prompts} |`);
+  lines.push(`| Knowledge items | ${data.overview.knowledgeCount} |`);
+  if (data.overview.staleCount > 0) {
+    lines.push(`| Stale observations | ${data.overview.staleCount} |`);
+  }
+  lines.push("");
+  if (data.sessionStats.total > 0) {
+    const completionPct = Math.round(data.sessionStats.completed / data.sessionStats.total * 100);
+    lines.push("## Sessions");
+    lines.push("");
+    lines.push(`- **Total**: ${data.sessionStats.total}`);
+    lines.push(`- **Completed**: ${data.sessionStats.completed} (${completionPct}%)`);
+    if (data.sessionStats.avgDurationMinutes > 0) {
+      lines.push(`- **Avg duration**: ${data.sessionStats.avgDurationMinutes} min`);
+    }
+    lines.push("");
+  }
+  if (data.timeline.length > 0) {
+    lines.push("## Activity Timeline");
+    lines.push("");
+    lines.push("| Date | Observations |");
+    lines.push("|------|------------:|");
+    for (const entry of data.timeline) {
+      lines.push(`| ${entry.day} | ${entry.count} |`);
+    }
+    lines.push("");
+  }
+  if (data.typeDistribution.length > 0) {
+    lines.push("## Observation Types");
+    lines.push("");
+    for (const entry of data.typeDistribution) {
+      lines.push(`- **${entry.type}**: ${entry.count}`);
+    }
+    lines.push("");
+  }
+  if (data.topLearnings.length > 0) {
+    lines.push("## Key Learnings");
+    lines.push("");
+    for (const learning of data.topLearnings) {
+      lines.push(`- ${learning}`);
+    }
+    lines.push("");
+  }
+  if (data.completedTasks.length > 0) {
+    lines.push("## Completed");
+    lines.push("");
+    for (const task of data.completedTasks) {
+      lines.push(`- ${task}`);
+    }
+    lines.push("");
+  }
+  if (data.nextSteps.length > 0) {
+    lines.push("## Next Steps");
+    lines.push("");
+    for (const step of data.nextSteps) {
+      lines.push(`- ${step}`);
+    }
+    lines.push("");
+  }
+  if (data.fileHotspots.length > 0) {
+    lines.push("## File Hotspots");
+    lines.push("");
+    lines.push("| File | Modifications |");
+    lines.push("|------|-------------:|");
+    for (const entry of data.fileHotspots.slice(0, 10)) {
+      lines.push(`| \`${entry.file}\` | ${entry.count} |`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatReportJson(data) {
+  return JSON.stringify(data, null, 2);
+}
+
 // src/cli/contextkit.ts
 import { execSync } from "child_process";
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync, appendFileSync as appendFileSync2 } from "fs";
+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 { fileURLToPath as fileURLToPath2 } from "url";
@@ -1010,7 +2434,7 @@ function isWSL() {
   try {
     const rel = release().toLowerCase();
     if (rel.includes("microsoft") || rel.includes("wsl")) return true;
-    if (existsSync3("/proc/version")) {
+    if (existsSync4("/proc/version")) {
       const proc = readFileSync2("/proc/version", "utf8").toLowerCase();
       return proc.includes("microsoft") || proc.includes("wsl");
     }
@@ -1184,10 +2608,11 @@ async function tryAutoFix(failedChecks) {
     try {
       const npmGlobalDir = join3(homedir3(), ".npm-global");
       mkdirSync3(npmGlobalDir, { recursive: true });
-      execSync(`npm config set prefix "${npmGlobalDir}"`, { stdio: "ignore" });
+      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 (existsSync3(rcFile)) {
+      if (existsSync4(rcFile)) {
         const content = readFileSync2(rcFile, "utf8");
         alreadyInRc = content.includes(".npm-global/bin");
       }
@@ -1210,7 +2635,7 @@ ${exportLine}
     console.log("\n  Fixing npm binary (installing nvm + Node.js 22)...");
     const nvmDir = join3(homedir3(), ".nvm");
     try {
-      if (existsSync3(nvmDir)) {
+      if (existsSync4(nvmDir)) {
         console.log(`  nvm already installed at ${nvmDir}`);
       } else {
         console.log("  Downloading nvm...");
@@ -1255,139 +2680,477 @@ ${exportLine}
   if (sqliteCheck) {
     console.log("\n  Rebuilding better-sqlite3...");
     try {
-      const globalDir = execSync("npm prefix -g", { encoding: "utf8" }).trim();
-      const sqlitePkg = join3(globalDir, "lib", "node_modules", "kiro-memory");
-      if (existsSync3(sqlitePkg)) {
-        execSync(`cd "${sqlitePkg}" && npm rebuild better-sqlite3`, {
-          stdio: "inherit",
-          timeout: 6e4
-        });
-      } else {
-        execSync("npm rebuild better-sqlite3", { stdio: "inherit", timeout: 6e4 });
-      }
-      console.log(`  \x1B[32m\u2713\x1B[0m better-sqlite3 rebuilt`);
-      anyFixed = true;
-    } catch (err) {
-      console.log(`  \x1B[31m\u2717\x1B[0m Could not rebuild: ${err.message}`);
-      console.log("  Try: npm install -g kiro-memory --build-from-source");
+      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)) {
+        spawnRebuild("npm", ["rebuild", "better-sqlite3"], {
+          cwd: sqlitePkg,
+          stdio: "inherit",
+          timeout: 6e4
+        });
+      } else {
+        spawnRebuild("npm", ["rebuild", "better-sqlite3"], { stdio: "inherit", timeout: 6e4 });
+      }
+      console.log(`  \x1B[32m\u2713\x1B[0m better-sqlite3 rebuilt`);
+      anyFixed = true;
+    } catch (err) {
+      console.log(`  \x1B[31m\u2717\x1B[0m Could not rebuild: ${err.message}`);
+      console.log("  Try: npm install -g kiro-memory --build-from-source");
+    }
+  }
+  console.log("");
+  return { fixed: anyFixed, needsRestart };
+}
+async function installKiro() {
+  console.log("\n=== Kiro Memory - Installation ===\n");
+  console.log("[1/4] Running environment checks...");
+  let checks = runEnvironmentChecks();
+  let { hasErrors } = printChecks(checks);
+  if (hasErrors) {
+    const { fixed, needsRestart } = await tryAutoFix(checks);
+    if (needsRestart) {
+      console.log("  \x1B[33m\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\x1B[0m");
+      console.log("  \x1B[33m\u2502\x1B[0m  Node.js was installed via nvm. To activate it:         \x1B[33m\u2502\x1B[0m");
+      console.log("  \x1B[33m\u2502\x1B[0m                                                         \x1B[33m\u2502\x1B[0m");
+      console.log("  \x1B[33m\u2502\x1B[0m  1. Close and reopen your terminal                      \x1B[33m\u2502\x1B[0m");
+      console.log("  \x1B[33m\u2502\x1B[0m  2. Run: \x1B[1mnpm install -g kiro-memory\x1B[0m                     \x1B[33m\u2502\x1B[0m");
+      console.log("  \x1B[33m\u2502\x1B[0m  3. Run: \x1B[1mkiro-memory install\x1B[0m                            \x1B[33m\u2502\x1B[0m");
+      console.log("  \x1B[33m\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\x1B[0m\n");
+      process.exit(0);
+    }
+    if (fixed) {
+      console.log("  Re-running checks...\n");
+      checks = runEnvironmentChecks();
+      ({ hasErrors } = printChecks(checks));
+    }
+    if (hasErrors) {
+      console.log("\x1B[31mInstallation aborted.\x1B[0m Fix the remaining issues and retry.");
+      console.log("After fixing, run: kiro-memory install\n");
+      process.exit(1);
+    }
+  }
+  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");
+  console.log("[2/4] Installing Kiro configuration...\n");
+  for (const dir of [agentsDir, settingsDir, steeringDir, dataDir]) {
+    mkdirSync3(dir, { recursive: true });
+  }
+  const agentConfig = AGENT_TEMPLATE.replace(/__DIST_DIR__/g, distDir);
+  const agentDestPath = join3(agentsDir, "kiro-memory.json");
+  writeFileSync(agentDestPath, agentConfig, "utf8");
+  console.log(`  \u2192 Agent config: ${agentDestPath}`);
+  const mcpFilePath = join3(settingsDir, "mcp.json");
+  let mcpConfig = { mcpServers: {} };
+  if (existsSync4(mcpFilePath)) {
+    try {
+      mcpConfig = JSON.parse(readFileSync2(mcpFilePath, "utf8"));
+      if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
+    } catch {
+    }
+  }
+  mcpConfig.mcpServers["kiro-memory"] = {
+    command: "node",
+    args: [join3(distDir, "servers", "mcp-server.js")]
+  };
+  writeFileSync(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");
+  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");
+    aliasAlreadySet = rcContent.includes("alias kiro=") && rcContent.includes("kiro-memory");
+  }
+  if (aliasAlreadySet) {
+    console.log(`  \x1B[32m\u2713\x1B[0m Alias already configured in ${rcFile}`);
+  } else {
+    console.log("  \x1B[36m\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\x1B[0m");
+    console.log("  \x1B[36m\u2502\x1B[0m  Without an alias, you must type every time:            \x1B[36m\u2502\x1B[0m");
+    console.log("  \x1B[36m\u2502\x1B[0m    \x1B[2mkiro-cli --agent kiro-memory\x1B[0m                          \x1B[36m\u2502\x1B[0m");
+    console.log("  \x1B[36m\u2502\x1B[0m                                                         \x1B[36m\u2502\x1B[0m");
+    console.log("  \x1B[36m\u2502\x1B[0m  With the alias, just type:                              \x1B[36m\u2502\x1B[0m");
+    console.log("  \x1B[36m\u2502\x1B[0m    \x1B[1m\x1B[32mkiro\x1B[0m                                                 \x1B[36m\u2502\x1B[0m");
+    console.log("  \x1B[36m\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\x1B[0m");
+    console.log("");
+    const answer = await askUser(`  Add alias to ${rcFile}? [Y/n] `);
+    if (answer === "" || answer === "y" || answer === "yes") {
+      try {
+        appendFileSync2(rcFile, `
+# Kiro Memory \u2014 persistent memory alias
+${aliasLine}
+`);
+        console.log(`
+  \x1B[32m\u2713\x1B[0m Alias added to ${rcFile}`);
+        console.log(`  \x1B[33m\u2192\x1B[0m Run \x1B[1msource ${rcFile}\x1B[0m or open a new terminal to activate it.`);
+      } catch (err) {
+        console.log(`
+  \x1B[31m\u2717\x1B[0m Could not write to ${rcFile}: ${err.message}`);
+        console.log(`  \x1B[33m\u2192\x1B[0m Add manually: ${aliasLine}`);
+      }
+    } else {
+      console.log(`
+  Skipped. You can add it manually later:`);
+      console.log(`    echo '${aliasLine}' >> ${rcFile}`);
+    }
+  }
+  console.log("\n[4/4] Done!\n");
+  console.log("  \x1B[32m\u2550\u2550\u2550 Installation complete! \u2550\u2550\u2550\x1B[0m\n");
+  console.log("  Start Kiro with memory:");
+  if (aliasAlreadySet) {
+    console.log("    \x1B[1mkiro\x1B[0m");
+  } else {
+    console.log("    \x1B[1mkiro-cli --agent kiro-memory\x1B[0m");
+  }
+  console.log("");
+  console.log("  The worker starts automatically when a Kiro session begins.");
+  console.log(`  Web dashboard: \x1B[4mhttp://localhost:3001\x1B[0m
+`);
+}
+var CLAUDE_CODE_STEERING = `# Kiro Memory - Persistent Cross-Session Memory
+
+You have access to Kiro Memory, a persistent cross-session memory system that remembers context across sessions.
+
+## Available MCP Tools
+
+### kiro-memory/search
+Search previous session memory. Use when:
+- The user mentions past work or previous sessions
+- You need context on previous decisions
+- You want to check if a problem was already addressed
+
+### kiro-memory/get_context
+Retrieve recent context for the current project. Use at the start of complex tasks.
+
+### kiro-memory/timeline
+Show chronological context around an observation. Use to understand sequences of events.
+
+### kiro-memory/get_observations
+Retrieve full details of specific observations by ID. Use after search to drill down.
+
+## Behavior
+
+- Previous session context is automatically injected at startup via hooks
+- Your actions (files written, commands run, searches) are tracked automatically
+- A summary is generated at the end of each session
+- No manual saving needed: the system is fully automatic
+`;
+async function installClaudeCode() {
+  console.log("\n=== Kiro Memory - Claude Code Installation ===\n");
+  console.log("[1/3] Running environment checks...");
+  const checks = runEnvironmentChecks();
+  const { hasErrors } = printChecks(checks);
+  if (hasErrors) {
+    const { fixed, needsRestart } = await tryAutoFix(checks);
+    if (needsRestart) {
+      console.log("  \x1B[33mRestart your terminal and re-run: kiro-memory install --claude-code\x1B[0m\n");
+      process.exit(0);
+    }
+    if (fixed) {
+      console.log("  Re-running checks...\n");
+      const reChecks = runEnvironmentChecks();
+      const reResult = printChecks(reChecks);
+      if (reResult.hasErrors) {
+        console.log("\x1B[31mInstallation aborted.\x1B[0m Fix the remaining issues and retry.\n");
+        process.exit(1);
+      }
+    } else if (hasErrors) {
+      console.log("\x1B[31mInstallation aborted.\x1B[0m Fix the issues and retry.\n");
+      process.exit(1);
+    }
+  }
+  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");
+  console.log("[2/3] Installing Claude Code configuration...\n");
+  mkdirSync3(claudeDir, { recursive: true });
+  mkdirSync3(dataDir, { recursive: true });
+  const settingsPath = join3(claudeDir, "settings.json");
+  let settings = {};
+  if (existsSync4(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync2(settingsPath, "utf8"));
+    } catch {
+    }
+  }
+  const hookMap = {
+    "SessionStart": { script: "hooks/agentSpawn.js", timeout: 10 },
+    "UserPromptSubmit": { script: "hooks/userPromptSubmit.js", timeout: 5 },
+    "PostToolUse": { script: "hooks/postToolUse.js", timeout: 5 },
+    "Stop": { script: "hooks/stop.js", timeout: 10 }
+  };
+  for (const [event, config] of Object.entries(hookMap)) {
+    const hookEntry = {
+      matcher: "",
+      hooks: [{
+        type: "command",
+        command: `node ${join3(distDir, config.script)}`,
+        timeout: config.timeout
+      }]
+    };
+    if (!settings[event]) {
+      settings[event] = [hookEntry];
+    } else if (Array.isArray(settings[event])) {
+      settings[event] = settings[event].filter(
+        (h) => !h.hooks?.some(
+          (hk) => hk.command?.includes("kiro-memory") || hk.command?.includes("contextkit")
+        )
+      );
+      settings[event].push(hookEntry);
+    }
+  }
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf8");
+  console.log(`  \u2192 Hooks config: ${settingsPath}`);
+  const mcpPath = join3(homedir3(), ".mcp.json");
+  let mcpConfig = {};
+  if (existsSync4(mcpPath)) {
+    try {
+      mcpConfig = JSON.parse(readFileSync2(mcpPath, "utf8"));
+    } catch {
+    }
+  }
+  if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
+  mcpConfig.mcpServers["kiro-memory"] = {
+    command: "node",
+    args: [join3(distDir, "servers", "mcp-server.js")]
+  };
+  writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf8");
+  console.log(`  \u2192 MCP config:   ${mcpPath}`);
+  const steeringPath = join3(claudeDir, "CLAUDE.md");
+  let existingSteering = "";
+  if (existsSync4(steeringPath)) {
+    existingSteering = readFileSync2(steeringPath, "utf8");
+  }
+  if (!existingSteering.includes("Kiro Memory")) {
+    const separator = existingSteering.length > 0 ? "\n\n---\n\n" : "";
+    writeFileSync(steeringPath, existingSteering + separator + CLAUDE_CODE_STEERING, "utf8");
+    console.log(`  \u2192 Steering:     ${steeringPath}`);
+  } else {
+    console.log(`  \u2192 Steering:     ${steeringPath} (already configured)`);
+  }
+  console.log(`  \u2192 Data dir:     ${dataDir}`);
+  console.log("\n[3/3] Done!\n");
+  console.log("  \x1B[32m\u2550\u2550\u2550 Claude Code integration complete! \u2550\u2550\u2550\x1B[0m\n");
+  console.log("  Memory hooks are now active for Claude Code.");
+  console.log("  Start a new Claude Code session to begin tracking context.\n");
+  console.log("  The worker starts automatically on first session.");
+  console.log(`  Web dashboard: \x1B[4mhttp://localhost:3001\x1B[0m
+`);
+}
+async function installCursor() {
+  console.log("\n=== Kiro Memory - Cursor Installation ===\n");
+  console.log("[1/3] Running environment checks...");
+  const checks = runEnvironmentChecks();
+  const { hasErrors } = printChecks(checks);
+  if (hasErrors) {
+    const { fixed, needsRestart } = await tryAutoFix(checks);
+    if (needsRestart) {
+      console.log("  \x1B[33mRestart your terminal and re-run: kiro-memory install --cursor\x1B[0m\n");
+      process.exit(0);
+    }
+    if (fixed) {
+      console.log("  Re-running checks...\n");
+      const reChecks = runEnvironmentChecks();
+      const reResult = printChecks(reChecks);
+      if (reResult.hasErrors) {
+        console.log("\x1B[31mInstallation aborted.\x1B[0m Fix the remaining issues and retry.\n");
+        process.exit(1);
+      }
+    } else if (hasErrors) {
+      console.log("\x1B[31mInstallation aborted.\x1B[0m Fix the issues and retry.\n");
+      process.exit(1);
+    }
+  }
+  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");
+  console.log("[2/3] Installing Cursor configuration...\n");
+  mkdirSync3(cursorDir, { recursive: true });
+  mkdirSync3(dataDir, { recursive: true });
+  const hooksPath = join3(cursorDir, "hooks.json");
+  let hooksConfig = { version: 1, hooks: {} };
+  if (existsSync4(hooksPath)) {
+    try {
+      hooksConfig = JSON.parse(readFileSync2(hooksPath, "utf8"));
+      if (!hooksConfig.hooks) hooksConfig.hooks = {};
+      if (!hooksConfig.version) hooksConfig.version = 1;
+    } catch {
+    }
+  }
+  const cursorHookMap = {
+    "sessionStart": "hooks/agentSpawn.js",
+    "beforeSubmitPrompt": "hooks/userPromptSubmit.js",
+    "afterFileEdit": "hooks/postToolUse.js",
+    "afterShellExecution": "hooks/postToolUse.js",
+    "afterMCPExecution": "hooks/postToolUse.js",
+    "stop": "hooks/stop.js"
+  };
+  for (const [event, script] of Object.entries(cursorHookMap)) {
+    const hookEntry = {
+      command: `node ${join3(distDir, script)}`
+    };
+    if (!hooksConfig.hooks[event]) {
+      hooksConfig.hooks[event] = [hookEntry];
+    } else if (Array.isArray(hooksConfig.hooks[event])) {
+      hooksConfig.hooks[event] = hooksConfig.hooks[event].filter(
+        (h) => !h.command?.includes("kiro-memory") && !h.command?.includes("contextkit")
+      );
+      hooksConfig.hooks[event].push(hookEntry);
+    }
+  }
+  writeFileSync(hooksPath, JSON.stringify(hooksConfig, null, 2), "utf8");
+  console.log(`  \u2192 Hooks config: ${hooksPath}`);
+  const mcpPath = join3(cursorDir, "mcp.json");
+  let mcpConfig = {};
+  if (existsSync4(mcpPath)) {
+    try {
+      mcpConfig = JSON.parse(readFileSync2(mcpPath, "utf8"));
+    } catch {
     }
   }
-  console.log("");
-  return { fixed: anyFixed, needsRestart };
+  if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
+  mcpConfig.mcpServers["kiro-memory"] = {
+    command: "node",
+    args: [join3(distDir, "servers", "mcp-server.js")]
+  };
+  writeFileSync(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");
+  console.log("  \x1B[32m\u2550\u2550\u2550 Cursor integration complete! \u2550\u2550\u2550\x1B[0m\n");
+  console.log("  Memory hooks are now active for Cursor IDE.");
+  console.log("  Start a new Cursor Agent session to begin tracking context.\n");
+  console.log("  The worker starts automatically on first session.");
+  console.log(`  Web dashboard: \x1B[4mhttp://localhost:3001\x1B[0m
+`);
 }
-async function installKiro() {
-  console.log("\n=== Kiro Memory - Installation ===\n");
-  console.log("[1/4] Running environment checks...");
-  let checks = runEnvironmentChecks();
-  let { hasErrors } = printChecks(checks);
+async function installWindsurf() {
+  console.log("\n=== Kiro Memory - Windsurf Installation ===\n");
+  console.log("[1/3] Running environment checks...");
+  const checks = runEnvironmentChecks();
+  const { hasErrors } = printChecks(checks);
   if (hasErrors) {
     const { fixed, needsRestart } = await tryAutoFix(checks);
     if (needsRestart) {
-      console.log("  \x1B[33m\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\x1B[0m");
-      console.log("  \x1B[33m\u2502\x1B[0m  Node.js was installed via nvm. To activate it:         \x1B[33m\u2502\x1B[0m");
-      console.log("  \x1B[33m\u2502\x1B[0m                                                         \x1B[33m\u2502\x1B[0m");
-      console.log("  \x1B[33m\u2502\x1B[0m  1. Close and reopen your terminal                      \x1B[33m\u2502\x1B[0m");
-      console.log("  \x1B[33m\u2502\x1B[0m  2. Run: \x1B[1mnpm install -g kiro-memory\x1B[0m                     \x1B[33m\u2502\x1B[0m");
-      console.log("  \x1B[33m\u2502\x1B[0m  3. Run: \x1B[1mkiro-memory install\x1B[0m                            \x1B[33m\u2502\x1B[0m");
-      console.log("  \x1B[33m\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\x1B[0m\n");
+      console.log("  \x1B[33mRestart your terminal and re-run: kiro-memory install --windsurf\x1B[0m\n");
       process.exit(0);
     }
     if (fixed) {
       console.log("  Re-running checks...\n");
-      checks = runEnvironmentChecks();
-      ({ hasErrors } = printChecks(checks));
-    }
-    if (hasErrors) {
-      console.log("\x1B[31mInstallation aborted.\x1B[0m Fix the remaining issues and retry.");
-      console.log("After fixing, run: kiro-memory install\n");
+      const reChecks = runEnvironmentChecks();
+      const reResult = printChecks(reChecks);
+      if (reResult.hasErrors) {
+        console.log("\x1B[31mInstallation aborted.\x1B[0m Fix the remaining issues and retry.\n");
+        process.exit(1);
+      }
+    } else if (hasErrors) {
+      console.log("\x1B[31mInstallation aborted.\x1B[0m Fix the issues and retry.\n");
       process.exit(1);
     }
   }
   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");
-  console.log("[2/4] Installing Kiro configuration...\n");
-  for (const dir of [agentsDir, settingsDir, steeringDir, dataDir]) {
-    mkdirSync3(dir, { recursive: true });
-  }
-  const agentConfig = AGENT_TEMPLATE.replace(/__DIST_DIR__/g, distDir);
-  const agentDestPath = join3(agentsDir, "kiro-memory.json");
-  writeFileSync(agentDestPath, agentConfig, "utf8");
-  console.log(`  \u2192 Agent config: ${agentDestPath}`);
-  const mcpFilePath = join3(settingsDir, "mcp.json");
-  let mcpConfig = { mcpServers: {} };
-  if (existsSync3(mcpFilePath)) {
+  const dataDir = process.env.KIRO_MEMORY_DATA_DIR || process.env.CONTEXTKIT_DATA_DIR || join3(homedir3(), ".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");
+  let mcpConfig = {};
+  if (existsSync4(mcpPath)) {
     try {
-      mcpConfig = JSON.parse(readFileSync2(mcpFilePath, "utf8"));
-      if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
+      mcpConfig = JSON.parse(readFileSync2(mcpPath, "utf8"));
     } catch {
     }
   }
+  if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
   mcpConfig.mcpServers["kiro-memory"] = {
     command: "node",
     args: [join3(distDir, "servers", "mcp-server.js")]
   };
-  writeFileSync(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");
-  console.log(`  \u2192 Steering:     ${steeringDestPath}`);
+  writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf8");
+  console.log(`  \u2192 MCP config:   ${mcpPath}`);
   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 (existsSync3(rcFile)) {
-    const rcContent = readFileSync2(rcFile, "utf8");
-    aliasAlreadySet = rcContent.includes("alias kiro=") && rcContent.includes("kiro-memory");
-  }
-  if (aliasAlreadySet) {
-    console.log(`  \x1B[32m\u2713\x1B[0m Alias already configured in ${rcFile}`);
-  } else {
-    console.log("  \x1B[36m\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\x1B[0m");
-    console.log("  \x1B[36m\u2502\x1B[0m  Without an alias, you must type every time:            \x1B[36m\u2502\x1B[0m");
-    console.log("  \x1B[36m\u2502\x1B[0m    \x1B[2mkiro-cli --agent kiro-memory\x1B[0m                          \x1B[36m\u2502\x1B[0m");
-    console.log("  \x1B[36m\u2502\x1B[0m                                                         \x1B[36m\u2502\x1B[0m");
-    console.log("  \x1B[36m\u2502\x1B[0m  With the alias, just type:                              \x1B[36m\u2502\x1B[0m");
-    console.log("  \x1B[36m\u2502\x1B[0m    \x1B[1m\x1B[32mkiro\x1B[0m                                                 \x1B[36m\u2502\x1B[0m");
-    console.log("  \x1B[36m\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\x1B[0m");
-    console.log("");
-    const answer = await askUser(`  Add alias to ${rcFile}? [Y/n] `);
-    if (answer === "" || answer === "y" || answer === "yes") {
-      try {
-        appendFileSync2(rcFile, `
-# Kiro Memory \u2014 persistent memory alias
-${aliasLine}
+  console.log("\n[3/3] Done!\n");
+  console.log("  \x1B[32m\u2550\u2550\u2550 Windsurf integration complete! \u2550\u2550\u2550\x1B[0m\n");
+  console.log("  Kiro Memory MCP server is now registered for Windsurf.");
+  console.log("  Restart Windsurf to activate the MCP server.\n");
+  console.log("  The worker starts automatically on first use.");
+  console.log(`  Web dashboard: \x1B[4mhttp://localhost:3001\x1B[0m
 `);
-        console.log(`
-  \x1B[32m\u2713\x1B[0m Alias added to ${rcFile}`);
-        console.log(`  \x1B[33m\u2192\x1B[0m Run \x1B[1msource ${rcFile}\x1B[0m or open a new terminal to activate it.`);
-      } catch (err) {
-        console.log(`
-  \x1B[31m\u2717\x1B[0m Could not write to ${rcFile}: ${err.message}`);
-        console.log(`  \x1B[33m\u2192\x1B[0m Add manually: ${aliasLine}`);
+  console.log("  \x1B[2mTip: Add a .windsurfrules file to your project with instructions");
+  console.log("  to use the kiro-memory MCP tools for persistent context.\x1B[0m\n");
+}
+async function installCline() {
+  console.log("\n=== Kiro Memory - Cline Installation ===\n");
+  console.log("[1/3] Running environment checks...");
+  const checks = runEnvironmentChecks();
+  const { hasErrors } = printChecks(checks);
+  if (hasErrors) {
+    const { fixed, needsRestart } = await tryAutoFix(checks);
+    if (needsRestart) {
+      console.log("  \x1B[33mRestart your terminal and re-run: kiro-memory install --cline\x1B[0m\n");
+      process.exit(0);
+    }
+    if (fixed) {
+      console.log("  Re-running checks...\n");
+      const reChecks = runEnvironmentChecks();
+      const reResult = printChecks(reChecks);
+      if (reResult.hasErrors) {
+        console.log("\x1B[31mInstallation aborted.\x1B[0m Fix the remaining issues and retry.\n");
+        process.exit(1);
       }
-    } else {
-      console.log(`
-  Skipped. You can add it manually later:`);
-      console.log(`    echo '${aliasLine}' >> ${rcFile}`);
+    } else if (hasErrors) {
+      console.log("\x1B[31mInstallation aborted.\x1B[0m Fix the issues and retry.\n");
+      process.exit(1);
     }
   }
-  console.log("\n[4/4] Done!\n");
-  console.log("  \x1B[32m\u2550\u2550\u2550 Installation complete! \u2550\u2550\u2550\x1B[0m\n");
-  console.log("  Start Kiro with memory:");
-  if (aliasAlreadySet) {
-    console.log("    \x1B[1mkiro\x1B[0m");
+  const distDir = DIST_DIR;
+  const dataDir = process.env.KIRO_MEMORY_DATA_DIR || process.env.CONTEXTKIT_DATA_DIR || join3(homedir3(), ".kiro-memory");
+  console.log("[2/3] Installing Cline configuration...\n");
+  mkdirSync3(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");
   } else {
-    console.log("    \x1B[1mkiro-cli --agent kiro-memory\x1B[0m");
+    clineSettingsDir = join3(homedir3(), ".config", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings");
   }
-  console.log("");
-  console.log("  The worker starts automatically when a Kiro session begins.");
+  mkdirSync3(clineSettingsDir, { recursive: true });
+  const mcpPath = join3(clineSettingsDir, "cline_mcp_settings.json");
+  let mcpConfig = {};
+  if (existsSync4(mcpPath)) {
+    try {
+      mcpConfig = JSON.parse(readFileSync2(mcpPath, "utf8"));
+    } catch {
+    }
+  }
+  if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
+  mcpConfig.mcpServers["kiro-memory"] = {
+    command: "node",
+    args: [join3(distDir, "servers", "mcp-server.js")]
+  };
+  writeFileSync(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");
+  console.log("  \x1B[32m\u2550\u2550\u2550 Cline integration complete! \u2550\u2550\u2550\x1B[0m\n");
+  console.log("  Kiro Memory MCP server is now registered for Cline.");
+  console.log("  Restart VS Code to activate the MCP server in Cline.\n");
+  console.log("  The worker starts automatically on first use.");
   console.log(`  Web dashboard: \x1B[4mhttp://localhost:3001\x1B[0m
 `);
+  console.log("  \x1B[2mTip: Add a .clinerules file to your project with instructions");
+  console.log("  to use the kiro-memory MCP tools for persistent context.\x1B[0m\n");
 }
 async function runDoctor() {
   console.log("\n=== Kiro Memory - Diagnostics ===");
@@ -1398,12 +3161,12 @@ async function runDoctor() {
   const dataDir = process.env.KIRO_MEMORY_DATA_DIR || process.env.CONTEXTKIT_DATA_DIR || join3(homedir3(), ".contextkit");
   checks.push({
     name: "Kiro agent config",
-    ok: existsSync3(agentPath),
-    message: existsSync3(agentPath) ? agentPath : "Not found",
-    fix: !existsSync3(agentPath) ? "Run: kiro-memory install" : void 0
+    ok: existsSync4(agentPath),
+    message: existsSync4(agentPath) ? agentPath : "Not found",
+    fix: !existsSync4(agentPath) ? "Run: kiro-memory install" : void 0
   });
   let mcpOk = false;
-  if (existsSync3(mcpPath)) {
+  if (existsSync4(mcpPath)) {
     try {
       const mcp = JSON.parse(readFileSync2(mcpPath, "utf8"));
       mcpOk = !!mcp.mcpServers?.["kiro-memory"] || !!mcp.mcpServers?.contextkit;
@@ -1418,8 +3181,115 @@ async function runDoctor() {
   });
   checks.push({
     name: "Data directory",
-    ok: existsSync3(dataDir),
-    message: existsSync3(dataDir) ? dataDir : "Not created (will be created on first use)"
+    ok: existsSync4(dataDir),
+    message: existsSync4(dataDir) ? dataDir : "Not created (will be created on first use)"
+  });
+  const claudeDir = join3(homedir3(), ".claude");
+  const claudeSettingsPath = join3(claudeDir, "settings.json");
+  let claudeHooksOk = false;
+  if (existsSync4(claudeSettingsPath)) {
+    try {
+      const claudeSettings = JSON.parse(readFileSync2(claudeSettingsPath, "utf8"));
+      claudeHooksOk = !!(claudeSettings?.SessionStart || claudeSettings?.PostToolUse);
+      if (claudeHooksOk) {
+        const allSettings = JSON.stringify(claudeSettings);
+        claudeHooksOk = allSettings.includes("kiro-memory") || allSettings.includes("agentSpawn");
+      }
+    } catch {
+    }
+  }
+  const claudeMcpPath = join3(homedir3(), ".mcp.json");
+  let claudeMcpOk = false;
+  if (existsSync4(claudeMcpPath)) {
+    try {
+      const claudeMcp = JSON.parse(readFileSync2(claudeMcpPath, "utf8"));
+      claudeMcpOk = !!claudeMcp.mcpServers?.["kiro-memory"];
+    } catch {
+    }
+  }
+  checks.push({
+    name: "Claude Code hooks",
+    ok: true,
+    // Non-blocking: installazione opzionale
+    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
+    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");
+  let cursorHooksOk = false;
+  if (existsSync4(cursorHooksPath)) {
+    try {
+      const cursorHooks = JSON.parse(readFileSync2(cursorHooksPath, "utf8"));
+      cursorHooksOk = !!(cursorHooks.hooks?.sessionStart || cursorHooks.hooks?.afterFileEdit);
+      if (cursorHooksOk) {
+        const allHooks = JSON.stringify(cursorHooks.hooks);
+        cursorHooksOk = allHooks.includes("kiro-memory") || allHooks.includes("agentSpawn");
+      }
+    } catch {
+    }
+  }
+  const cursorMcpPath = join3(cursorDir, "mcp.json");
+  let cursorMcpOk = false;
+  if (existsSync4(cursorMcpPath)) {
+    try {
+      const cursorMcp = JSON.parse(readFileSync2(cursorMcpPath, "utf8"));
+      cursorMcpOk = !!cursorMcp.mcpServers?.["kiro-memory"];
+    } catch {
+    }
+  }
+  checks.push({
+    name: "Cursor hooks",
+    ok: true,
+    // Non-blocking: installazione opzionale
+    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
+    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");
+  let windsurfMcpOk = false;
+  if (existsSync4(windsurfMcpPath)) {
+    try {
+      const windsurfMcp = JSON.parse(readFileSync2(windsurfMcpPath, "utf8"));
+      windsurfMcpOk = !!windsurfMcp.mcpServers?.["kiro-memory"];
+    } catch {
+    }
+  }
+  checks.push({
+    name: "Windsurf MCP",
+    ok: true,
+    // Non-blocking: installazione opzionale
+    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");
+  } else {
+    clineSettingsBase = join3(homedir3(), ".config", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings");
+  }
+  const clineMcpPath = join3(clineSettingsBase, "cline_mcp_settings.json");
+  let clineMcpOk = false;
+  if (existsSync4(clineMcpPath)) {
+    try {
+      const clineMcp = JSON.parse(readFileSync2(clineMcpPath, "utf8"));
+      clineMcpOk = !!clineMcp.mcpServers?.["kiro-memory"];
+    } catch {
+    }
+  }
+  checks.push({
+    name: "Cline MCP",
+    ok: true,
+    // Non-blocking: installazione opzionale
+    message: clineMcpOk ? `kiro-memory registered in cline_mcp_settings.json` : "Not configured (optional: run kiro-memory install --cline)"
   });
   let workerOk = false;
   try {
@@ -1447,7 +3317,17 @@ async function runDoctor() {
 }
 async function main() {
   if (command === "install") {
-    await installKiro();
+    if (args.includes("--claude-code")) {
+      await installClaudeCode();
+    } else if (args.includes("--cursor")) {
+      await installCursor();
+    } else if (args.includes("--windsurf")) {
+      await installWindsurf();
+    } else if (args.includes("--cline")) {
+      await installCline();
+    } else {
+      await installKiro();
+    }
     return;
   }
   if (command === "doctor") {
@@ -1480,6 +3360,27 @@ async function main() {
       case "add-sum":
         await addSummary(sdk, args.slice(1).join(" "));
         break;
+      case "add-knowledge":
+      case "add-k":
+        await addKnowledge(sdk, args[1], args[2], args.slice(3).join(" "));
+        break;
+      case "decay":
+        await handleDecay(sdk, args[1]);
+        break;
+      case "embeddings":
+      case "emb":
+        await handleEmbeddings(sdk, args[1]);
+        break;
+      case "semantic-search":
+      case "sem":
+        await semanticSearchCli(sdk, args[1]);
+        break;
+      case "resume":
+        await resumeSession(sdk, args[1] ? parseInt(args[1]) : void 0);
+        break;
+      case "report":
+        await generateReportCli(sdk, args.slice(1));
+        break;
       case "help":
       case "--help":
       case "-h":
@@ -1607,27 +3508,290 @@ async function addSummary(sdk, content) {
   console.log(`\u2705 Summary stored with ID: ${id}
 `);
 }
+async function addKnowledge(sdk, knowledgeType, title, content) {
+  const validTypes = ["constraint", "decision", "heuristic", "rejected"];
+  if (!knowledgeType || !validTypes.includes(knowledgeType)) {
+    console.error(`Error: knowledge type must be one of: ${validTypes.join(", ")}`);
+    process.exit(1);
+  }
+  if (!title) {
+    console.error("Error: title is required");
+    process.exit(1);
+  }
+  if (!content) {
+    console.error("Error: content is required");
+    process.exit(1);
+  }
+  const severity = args.find((a) => a.startsWith("--severity="))?.split("=")[1];
+  const alternativesRaw = args.find((a) => a.startsWith("--alternatives="))?.split("=")[1];
+  const alternatives = alternativesRaw ? alternativesRaw.split(",").map((s) => s.trim()) : void 0;
+  const reason = args.find((a) => a.startsWith("--reason="))?.split("=")[1];
+  const context = args.find((a) => a.startsWith("--context="))?.split("=")[1];
+  const confidence = args.find((a) => a.startsWith("--confidence="))?.split("=")[1];
+  const conceptsRaw = args.find((a) => a.startsWith("--concepts="))?.split("=")[1];
+  const concepts = conceptsRaw ? conceptsRaw.split(",").map((s) => s.trim()) : void 0;
+  const filesRaw = args.find((a) => a.startsWith("--files="))?.split("=")[1];
+  const files = filesRaw ? filesRaw.split(",").map((s) => s.trim()) : void 0;
+  const cleanContent = content.split(" ").filter((w) => !w.startsWith("--")).join(" ");
+  const id = await sdk.storeKnowledge({
+    project: sdk.getProject(),
+    knowledgeType,
+    title,
+    content: cleanContent || content,
+    concepts,
+    files,
+    metadata: { severity, alternatives, reason, context, confidence }
+  });
+  console.log(`
+Knowledge stored successfully.`);
+  console.log(`  ID:   ${id}`);
+  console.log(`  Type: ${knowledgeType}`);
+  console.log(`  Title: ${title}
+`);
+}
+async function handleEmbeddings(sdk, subcommand) {
+  switch (subcommand) {
+    case "stats": {
+      const stats = sdk.getEmbeddingStats();
+      console.log("\nEmbedding Statistics:\n");
+      console.log(`  Total observations:  ${stats.total}`);
+      console.log(`  With embeddings:     ${stats.embedded}`);
+      console.log(`  Coverage:            ${stats.percentage}%`);
+      await sdk.initializeEmbeddings();
+      const { getEmbeddingService: getEmbeddingService2 } = await Promise.resolve().then(() => (init_EmbeddingService(), EmbeddingService_exports));
+      const embService = getEmbeddingService2();
+      console.log(`  Provider:            ${embService.getProvider() || "none"}`);
+      console.log(`  Dimensions:          ${embService.getDimensions()}`);
+      console.log(`  Available:           ${embService.isAvailable() ? "yes" : "no"}`);
+      if (stats.percentage < 100 && stats.total > 0) {
+        console.log(`
+  Run 'kiro-memory embeddings backfill' to generate missing embeddings.`);
+      }
+      console.log("");
+      break;
+    }
+    case "backfill": {
+      const batchSize = parseInt(args[2]) || 50;
+      console.log(`
+Generating embeddings (batch size: ${batchSize})...
+`);
+      const available = await sdk.initializeEmbeddings();
+      if (!available) {
+        console.log("  No embedding provider available.");
+        console.log("  Install fastembed or @huggingface/transformers:");
+        console.log("    npm install fastembed");
+        console.log("    npm install @huggingface/transformers\n");
+        process.exit(1);
+      }
+      const count = await sdk.backfillEmbeddings(batchSize);
+      console.log(`  Generated ${count} embeddings.
+`);
+      const stats = sdk.getEmbeddingStats();
+      console.log(`  Coverage: ${stats.embedded}/${stats.total} (${stats.percentage}%)
+`);
+      break;
+    }
+    default:
+      console.log("\nUsage: kiro-memory embeddings <subcommand>\n");
+      console.log("Subcommands:");
+      console.log("  stats              Show embedding statistics");
+      console.log("  backfill [size]    Generate embeddings for observations without them (default: 50)\n");
+  }
+}
+async function semanticSearchCli(sdk, query) {
+  if (!query) {
+    console.error("Error: Please provide a search query");
+    process.exit(1);
+  }
+  console.log(`
+Semantic search: "${query}"...
+`);
+  await sdk.initializeEmbeddings();
+  const results = await sdk.hybridSearch(query, { limit: 10 });
+  if (results.length === 0) {
+    console.log("No results found.\n");
+    return;
+  }
+  console.log(`Found ${results.length} results:
+`);
+  results.forEach((r, i) => {
+    const scorePercent = Math.round(r.score * 100);
+    console.log(`  ${i + 1}. [${r.source}] ${r.title} (score: ${scorePercent}%)`);
+    if (r.content) {
+      console.log(`     ${r.content.substring(0, 150)}${r.content.length > 150 ? "..." : ""}`);
+    }
+    console.log("");
+  });
+}
+async function handleDecay(sdk, subcommand) {
+  switch (subcommand) {
+    case "stats": {
+      const stats = await sdk.getDecayStats();
+      console.log("\nDecay Statistics:\n");
+      console.log(`  Total observations:    ${stats.total}`);
+      console.log(`  Stale (file changed):  ${stats.stale}`);
+      console.log(`  Never accessed:        ${stats.neverAccessed}`);
+      console.log(`  Recently accessed:     ${stats.recentlyAccessed} (last 48h)`);
+      if (stats.total > 0) {
+        const freshPercent = Math.round((stats.total - stats.stale) / stats.total * 100);
+        console.log(`  Freshness:             ${freshPercent}%`);
+      }
+      console.log("");
+      break;
+    }
+    case "detect-stale": {
+      console.log("\nDetecting stale observations...\n");
+      const count = await sdk.detectStaleObservations();
+      if (count > 0) {
+        console.log(`  Found and marked ${count} stale observation(s).`);
+        console.log(`  These observations reference files that have been modified since they were recorded.
+`);
+      } else {
+        console.log("  No stale observations found. All observations are fresh.\n");
+      }
+      break;
+    }
+    case "consolidate": {
+      const dryRun = args.includes("--dry-run");
+      console.log(`
+${dryRun ? "[DRY RUN] " : ""}Consolidating duplicate observations...
+`);
+      const result = await sdk.consolidateObservations({ dryRun });
+      if (result.merged > 0) {
+        console.log(`  Merged ${result.merged} group(s), removed ${result.removed} duplicate(s).`);
+        if (dryRun) {
+          console.log(`  (Dry run: no changes were made. Remove --dry-run to apply.)`);
+        }
+      } else {
+        console.log("  No duplicate observations found to consolidate.");
+      }
+      console.log("");
+      break;
+    }
+    default:
+      console.log("\nUsage: kiro-memory decay <subcommand>\n");
+      console.log("Subcommands:");
+      console.log("  stats                Show decay statistics (stale, never accessed, etc.)");
+      console.log("  detect-stale         Detect and mark stale observations (files changed)");
+      console.log("  consolidate [--dry-run]  Consolidate duplicate observations\n");
+  }
+}
+async function generateReportCli(sdk, cliArgs) {
+  const periodArg = cliArgs.find((a) => a.startsWith("--period="))?.split("=")[1];
+  const formatArg = cliArgs.find((a) => a.startsWith("--format="))?.split("=")[1];
+  const outputArg = cliArgs.find((a) => a.startsWith("--output="))?.split("=")[1];
+  const period = periodArg === "monthly" ? "monthly" : "weekly";
+  const format = formatArg === "md" || formatArg === "markdown" ? "markdown" : formatArg === "json" ? "json" : "text";
+  const data = await sdk.generateReport({ period });
+  let output;
+  switch (format) {
+    case "markdown":
+      output = formatReportMarkdown(data);
+      break;
+    case "json":
+      output = formatReportJson(data);
+      break;
+    default:
+      output = formatReportText(data);
+  }
+  if (outputArg) {
+    writeFileSync(outputArg, output, "utf8");
+    console.log(`
+  Report saved to: ${outputArg}
+`);
+  } else {
+    console.log(output);
+  }
+}
+async function resumeSession(sdk, sessionId) {
+  const checkpoint = sessionId ? await sdk.getCheckpoint(sessionId) : await sdk.getLatestProjectCheckpoint();
+  if (!checkpoint) {
+    console.log("\n  No checkpoint found.");
+    if (sessionId) {
+      console.log(`  Session ${sessionId} has no checkpoint.`);
+    } else {
+      console.log(`  No recent checkpoints for project "${sdk.getProject()}".`);
+    }
+    console.log("  Checkpoints are created automatically at the end of each session.\n");
+    return;
+  }
+  console.log("");
+  console.log(`  \x1B[36m\u2550\u2550\u2550 Session Checkpoint \u2550\u2550\u2550\x1B[0m`);
+  console.log(`  \x1B[2mProject: ${checkpoint.project} | Session: ${checkpoint.session_id}\x1B[0m`);
+  console.log(`  \x1B[2m${new Date(checkpoint.created_at).toLocaleString()}\x1B[0m`);
+  console.log("");
+  console.log(`  \x1B[1mTask:\x1B[0m ${checkpoint.task}`);
+  if (checkpoint.progress) {
+    console.log(`  \x1B[1mProgress:\x1B[0m ${checkpoint.progress}`);
+  }
+  if (checkpoint.next_steps) {
+    console.log(`  \x1B[1mNext Steps:\x1B[0m ${checkpoint.next_steps}`);
+  }
+  if (checkpoint.open_questions) {
+    console.log(`  \x1B[1mOpen Questions:\x1B[0m ${checkpoint.open_questions}`);
+  }
+  if (checkpoint.relevant_files) {
+    console.log(`  \x1B[1mRelevant Files:\x1B[0m`);
+    const files = checkpoint.relevant_files.split(",").map((f) => f.trim());
+    files.forEach((f) => {
+      console.log(`    - ${f}`);
+    });
+  }
+  console.log("");
+}
 function showHelp() {
   console.log(`Usage: kiro-memory <command> [options]
 
 Setup:
-  install                   Install hooks, MCP server, and agent config into Kiro CLI
+  install                   Install for Kiro CLI (default)
+  install --claude-code     Install hooks and MCP server for Claude Code
+  install --cursor          Install hooks and MCP server for Cursor IDE
+  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.)
 
 Commands:
   context, ctx              Show current project context
-  search <query>            Search across all context
+  resume [session-id]       Resume previous session (shows checkpoint)
+  report [options]          Generate activity report
+    --period=weekly|monthly   Time period (default: weekly)
+    --format=text|md|json     Output format (default: text)
+    --output=<file>           Write to file instead of stdout
+  search <query>            Search across all context (keyword FTS5)
+  semantic-search <query>   Hybrid search: vector + keyword (semantic)
   observations [limit]      Show recent observations (default: 10)
   summaries [limit]         Show recent summaries (default: 5)
   add-observation <title> <content>   Add a new observation
   add-summary <content>     Add a new summary
+  add-knowledge <type> <title> <content>  Store structured knowledge
+    Types: constraint, decision, heuristic, rejected
+    Options: --severity=hard|soft  --alternatives=a,b,c  --reason=...
+             --context=...  --confidence=high|medium|low
+             --concepts=a,b  --files=path1,path2
+  embeddings stats          Show embedding statistics
+  embeddings backfill [n]   Generate embeddings for unprocessed observations
+  decay stats               Show decay statistics (stale, never accessed, etc.)
+  decay detect-stale        Detect and mark stale observations
+  decay consolidate [--dry-run]  Consolidate duplicate observations
   help                      Show this help message
 
 Examples:
   kiro-memory install
   kiro-memory doctor
   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 semantic-search "how did I fix the auth bug"
+  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
+  kiro-memory embeddings backfill 100
+  kiro-memory decay stats
+  kiro-memory decay detect-stale
+  kiro-memory decay consolidate --dry-run
   kiro-memory observations 20
 `);
 }