kiro-memory 1.6.0 → 1.7.1

package/plugin/dist/worker-service.js

@@ -5,9 +5,16 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -1555,6 +1562,363 @@ var require_ip_address = __commonJS({
   }
 });
 
+// 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(db2, memorySessionId, project, type, title, subtitle, text, narrative, facts, concepts, filesRead, filesModified, promptNumber) {
+  const now = /* @__PURE__ */ new Date();
+  const result = db2.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(db2, memorySessionId) {
+  const query = db2.query(
+    "SELECT * FROM observations WHERE memory_session_id = ? ORDER BY prompt_number ASC"
+  );
+  return query.all(memorySessionId);
+}
+function getObservationsByProject(db2, project, limit = 100) {
+  const query = db2.query(
+    "SELECT * FROM observations WHERE project = ? ORDER BY created_at_epoch DESC LIMIT ?"
+  );
+  return query.all(project, limit);
+}
+function searchObservations(db2, 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 = db2.query(sql);
+  if (project) {
+    return query.all(project, pattern, pattern, pattern);
+  }
+  return query.all(pattern, pattern, pattern);
+}
+function deleteObservation(db2, id) {
+  db2.run("DELETE FROM observations WHERE id = ?", [id]);
+}
+function updateLastAccessed(db2, 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(",");
+  db2.run(
+    `UPDATE observations SET last_accessed_epoch = ? WHERE id IN (${placeholders})`,
+    [now, ...validIds]
+  );
+}
+function consolidateObservations(db2, project, options = {}) {
+  const minGroupSize = options.minGroupSize || 3;
+  const groups = db2.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 = db2.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);
+    db2.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(",");
+    db2.run(`DELETE FROM observations WHERE id IN (${removePlaceholders})`, removeIds);
+    db2.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 escapeLikePattern2(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(db2, query, filters = {}) {
+  const limit = filters.limit || 50;
+  try {
+    const safeQuery = sanitizeFTS5Query(query);
+    if (!safeQuery) return searchObservationsLIKE(db2, 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 = db2.query(sql);
+    return stmt.all(...params);
+  } catch {
+    return searchObservationsLIKE(db2, query, filters);
+  }
+}
+function searchObservationsFTSWithRank(db2, 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 = db2.query(sql);
+    return stmt.all(...params);
+  } catch {
+    return [];
+  }
+}
+function searchObservationsLIKE(db2, query, filters = {}) {
+  const limit = filters.limit || 50;
+  const pattern = `%${escapeLikePattern2(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 = db2.query(sql);
+  return stmt.all(...params);
+}
+function searchSummariesFiltered(db2, query, filters = {}) {
+  const limit = filters.limit || 20;
+  const pattern = `%${escapeLikePattern2(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 = db2.query(sql);
+  return stmt.all(...params);
+}
+function getObservationsByIds(db2, 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 = db2.query(sql);
+  return stmt.all(...validIds);
+}
+function getTimeline(db2, anchorId, depthBefore = 5, depthAfter = 5) {
+  const anchorStmt = db2.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 = db2.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 = db2.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 = db2.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(db2, project) {
+  const obsStmt = db2.query("SELECT COUNT(*) as count FROM observations WHERE project = ?");
+  const sumStmt = db2.query("SELECT COUNT(*) as count FROM summaries WHERE project = ?");
+  const sesStmt = db2.query("SELECT COUNT(*) as count FROM sessions WHERE project = ?");
+  const prmStmt = db2.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(db2, project) {
+  const rows = db2.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(db2, 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(",");
+  db2.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/worker-service.ts
 import express from "express";
 import cors from "cors";
@@ -3002,7 +3366,7 @@ var rate_limit_default = rateLimit;
 // src/services/worker-service.ts
 import crypto from "crypto";
 import { join as join3, dirname as dirname2 } from "path";
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync, unlinkSync, chmodSync } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, writeFileSync, unlinkSync, chmodSync } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/shims/bun-sqlite.ts
@@ -3532,31 +3896,65 @@ var MigrationRunner = class {
           `);
           db2.run("CREATE UNIQUE INDEX IF NOT EXISTS idx_project_aliases_name ON project_aliases(project_name)");
         }
+      },
+      {
+        version: 4,
+        up: (db2) => {
+          db2.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
+            )
+          `);
+          db2.run("CREATE INDEX IF NOT EXISTS idx_embeddings_model ON observation_embeddings(model)");
+        }
+      },
+      {
+        version: 5,
+        up: (db2) => {
+          db2.run("ALTER TABLE observations ADD COLUMN last_accessed_epoch INTEGER");
+          db2.run("ALTER TABLE observations ADD COLUMN is_stale INTEGER DEFAULT 0");
+          db2.run("CREATE INDEX IF NOT EXISTS idx_observations_last_accessed ON observations(last_accessed_epoch)");
+          db2.run("CREATE INDEX IF NOT EXISTS idx_observations_stale ON observations(is_stale)");
+        }
+      },
+      {
+        version: 6,
+        up: (db2) => {
+          db2.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)
+            )
+          `);
+          db2.run("CREATE INDEX IF NOT EXISTS idx_checkpoints_session ON checkpoints(session_id)");
+          db2.run("CREATE INDEX IF NOT EXISTS idx_checkpoints_project ON checkpoints(project)");
+          db2.run("CREATE INDEX IF NOT EXISTS idx_checkpoints_epoch ON checkpoints(created_at_epoch)");
+        }
       }
     ];
   }
 };
 
-// src/services/sqlite/Observations.ts
-function createObservation(db2, memorySessionId, project, type, title, subtitle, text, narrative, facts, concepts, filesRead, filesModified, promptNumber) {
-  const now = /* @__PURE__ */ new Date();
-  const result = db2.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(db2, project, limit = 100) {
-  const query = db2.query(
-    "SELECT * FROM observations WHERE project = ? ORDER BY created_at_epoch DESC LIMIT ?"
-  );
-  return query.all(project, limit);
-}
-
-// src/services/sqlite/Summaries.ts
-function createSummary(db2, sessionId, project, request, investigated, learned, completed, nextSteps, notes) {
+// src/services/worker-service.ts
+init_Observations();
+
+// src/services/sqlite/Summaries.ts
+function createSummary(db2, sessionId, project, request, investigated, learned, completed, nextSteps, notes) {
   const now = /* @__PURE__ */ new Date();
   const result = db2.run(
     `INSERT INTO summaries 
@@ -3573,148 +3971,791 @@ function getSummariesByProject(db2, project, limit = 50) {
   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(" ");
-}
-function searchObservationsFTS(db2, query, filters = {}) {
-  const limit = filters.limit || 50;
-  try {
-    const safeQuery = sanitizeFTS5Query(query);
-    if (!safeQuery) return searchObservationsLIKE(db2, 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);
+// src/services/worker-service.ts
+init_Search();
+
+// src/services/search/EmbeddingService.ts
+var 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}`);
     }
-    if (filters.type) {
-      sql += " AND o.type = ?";
-      params.push(filters.type);
+    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}`);
     }
-    if (filters.dateStart) {
-      sql += " AND o.created_at_epoch >= ?";
-      params.push(filters.dateStart);
+    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}`);
     }
-    if (filters.dateEnd) {
-      sql += " AND o.created_at_epoch <= ?";
-      params.push(filters.dateEnd);
+    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);
+      }
     }
-    sql += " ORDER BY rank LIMIT ?";
-    params.push(limit);
-    const stmt = db2.query(sql);
-    return stmt.all(...params);
-  } catch {
-    return searchObservationsLIKE(db2, query, filters);
+    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;
+  }
+};
+var embeddingService = null;
+function getEmbeddingService() {
+  if (!embeddingService) {
+    embeddingService = new EmbeddingService();
+  }
+  return embeddingService;
 }
-function searchObservationsLIKE(db2, 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/search/VectorSearch.ts
+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(db2, 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 = db2.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(db2, observationId, embedding, model) {
+    try {
+      const blob = float32ToBuffer(embedding);
+      db2.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(db2, batchSize = 50) {
+    const embeddingService2 = getEmbeddingService();
+    if (!await embeddingService2.initialize()) {
+      logger.warn("VECTOR", "Embedding service non disponibile, backfill saltato");
+      return 0;
+    }
+    const rows = db2.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(db2, 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(db2) {
+    try {
+      const totalRow = db2.query("SELECT COUNT(*) as count FROM observations").get();
+      const embeddedRow = db2.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 = db2.query(sql);
-  return stmt.all(...params);
+};
+var vectorSearch = null;
+function getVectorSearch() {
+  if (!vectorSearch) {
+    vectorSearch = new VectorSearch();
+  }
+  return vectorSearch;
 }
-function searchSummariesFiltered(db2, 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
+};
+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
+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(db2, 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(db2, 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(db2, 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: updateLastAccessed2 } = 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) {
+          updateLastAccessed2(db2, 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);
+  return hybridSearch;
+}
+
+// src/services/sqlite/Analytics.ts
+function getObservationsTimeline(db2, project, days = 30) {
+  const cutoffEpoch = Date.now() - days * 24 * 60 * 60 * 1e3;
+  const sql = project ? `SELECT DATE(datetime(created_at_epoch / 1000, 'unixepoch')) as day, COUNT(*) as count
+       FROM observations
+       WHERE project = ? 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 >= ?
+       GROUP BY day
+       ORDER BY day ASC`;
   const stmt = db2.query(sql);
-  return stmt.all(...params);
+  const rows = project ? stmt.all(project, cutoffEpoch) : stmt.all(cutoffEpoch);
+  return rows;
 }
-function getObservationsByIds(db2, 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`;
+function getTypeDistribution(db2, project) {
+  const sql = project ? `SELECT type, COUNT(*) as count
+       FROM observations
+       WHERE project = ?
+       GROUP BY type
+       ORDER BY count DESC` : `SELECT type, COUNT(*) as count
+       FROM observations
+       GROUP BY type
+       ORDER BY count DESC`;
   const stmt = db2.query(sql);
-  return stmt.all(...ids);
+  const rows = project ? stmt.all(project) : stmt.all();
+  return rows;
 }
-function getTimeline(db2, anchorId, depthBefore = 5, depthAfter = 5) {
-  const anchorStmt = db2.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 = db2.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 = db2.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 = db2.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 getSessionStats(db2, project) {
+  const totalSql = project ? "SELECT COUNT(*) as count FROM sessions WHERE project = ?" : "SELECT COUNT(*) as count FROM sessions";
+  const totalStmt = db2.query(totalSql);
+  const total = project ? totalStmt.get(project)?.count || 0 : totalStmt.get()?.count || 0;
+  const completedSql = project ? `SELECT COUNT(*) as count FROM sessions WHERE project = ? AND status = 'completed'` : `SELECT COUNT(*) as count FROM sessions WHERE status = 'completed'`;
+  const completedStmt = db2.query(completedSql);
+  const completed = project ? completedStmt.get(project)?.count || 0 : completedStmt.get()?.count || 0;
+  const avgSql = project ? `SELECT AVG((completed_at_epoch - started_at_epoch) / 1000.0 / 60.0) as avg_min
+       FROM sessions
+       WHERE project = ? 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 status = 'completed' AND completed_at_epoch IS NOT NULL AND completed_at_epoch > started_at_epoch`;
+  const avgStmt = db2.query(avgSql);
+  const avgRow = project ? avgStmt.get(project) : avgStmt.get();
+  const avgDurationMinutes = Math.round((avgRow?.avg_min || 0) * 10) / 10;
+  return { total, completed, avgDurationMinutes };
 }
-function getProjectStats(db2, project) {
-  const obsStmt = db2.query("SELECT COUNT(*) as count FROM observations WHERE project = ?");
-  const sumStmt = db2.query("SELECT COUNT(*) as count FROM summaries WHERE project = ?");
-  const sesStmt = db2.query("SELECT COUNT(*) as count FROM sessions WHERE project = ?");
-  const prmStmt = db2.query("SELECT COUNT(*) as count FROM prompts WHERE project = ?");
+function getAnalyticsOverview(db2, project) {
+  const now = Date.now();
+  const todayStart = now - now % (24 * 60 * 60 * 1e3);
+  const weekStart = now - 7 * 24 * 60 * 60 * 1e3;
+  const countQuery = (table) => {
+    const sql = project ? `SELECT COUNT(*) as count FROM ${table} WHERE project = ?` : `SELECT COUNT(*) as count FROM ${table}`;
+    const stmt = db2.query(sql);
+    return project ? stmt.get(project)?.count || 0 : stmt.get()?.count || 0;
+  };
+  const observations = countQuery("observations");
+  const summaries = countQuery("summaries");
+  const sessions = countQuery("sessions");
+  const prompts = countQuery("prompts");
+  const todaySql = project ? "SELECT COUNT(*) as count FROM observations WHERE project = ? AND created_at_epoch >= ?" : "SELECT COUNT(*) as count FROM observations WHERE created_at_epoch >= ?";
+  const todayStmt = db2.query(todaySql);
+  const observationsToday = project ? todayStmt.get(project, todayStart)?.count || 0 : todayStmt.get(todayStart)?.count || 0;
+  const weekSql = project ? "SELECT COUNT(*) as count FROM observations WHERE project = ? AND created_at_epoch >= ?" : "SELECT COUNT(*) as count FROM observations WHERE created_at_epoch >= ?";
+  const weekStmt = db2.query(weekSql);
+  const observationsThisWeek = project ? weekStmt.get(project, weekStart)?.count || 0 : weekStmt.get(weekStart)?.count || 0;
+  const staleSql = project ? "SELECT COUNT(*) as count FROM observations WHERE project = ? AND is_stale = 1" : "SELECT COUNT(*) as count FROM observations WHERE is_stale = 1";
+  const staleStmt = db2.query(staleSql);
+  const staleCount = project ? staleStmt.get(project)?.count || 0 : staleStmt.get()?.count || 0;
+  const knowledgeSql = project ? `SELECT COUNT(*) as count FROM observations WHERE project = ? AND type IN ('constraint', 'decision', 'heuristic', 'rejected')` : `SELECT COUNT(*) as count FROM observations WHERE type IN ('constraint', 'decision', 'heuristic', 'rejected')`;
+  const knowledgeStmt = db2.query(knowledgeSql);
+  const knowledgeCount = project ? knowledgeStmt.get(project)?.count || 0 : knowledgeStmt.get()?.count || 0;
   return {
-    observations: obsStmt.get(project)?.count || 0,
-    summaries: sumStmt.get(project)?.count || 0,
-    sessions: sesStmt.get(project)?.count || 0,
-    prompts: prmStmt.get(project)?.count || 0
+    observations,
+    summaries,
+    sessions,
+    prompts,
+    observationsToday,
+    observationsThisWeek,
+    staleCount,
+    knowledgeCount
+  };
+}
+
+// src/services/sqlite/Checkpoints.ts
+function getLatestCheckpoint(db2, sessionId) {
+  const query = db2.query(
+    "SELECT * FROM checkpoints WHERE session_id = ? ORDER BY created_at_epoch DESC LIMIT 1"
+  );
+  return query.get(sessionId);
+}
+function getLatestCheckpointByProject(db2, project) {
+  const query = db2.query(
+    "SELECT * FROM checkpoints WHERE project = ? ORDER BY created_at_epoch DESC LIMIT 1"
+  );
+  return query.get(project);
+}
+
+// src/services/sqlite/Sessions.ts
+function getActiveSessions(db2) {
+  const query = db2.query("SELECT * FROM sessions WHERE status = 'active' ORDER BY started_at_epoch DESC");
+  return query.all();
+}
+function getSessionsByProject(db2, project, limit = 100) {
+  const query = db2.query("SELECT * FROM sessions WHERE project = ? ORDER BY started_at_epoch DESC LIMIT ?");
+  return query.all(project, limit);
+}
+
+// src/services/sqlite/Reports.ts
+function getReportData(db2, 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 = db2.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 = db2.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 = db2.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 ? db2.query(sessionTotalSql).get(project, startEpoch, endEpoch)?.count : db2.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 ? db2.query(sessionCompletedSql).get(project, startEpoch, endEpoch)?.count : db2.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 ? db2.query(sessionAvgSql).get(project, startEpoch, endEpoch) : db2.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 ? db2.query(knowledgeSql).get(project, startEpoch, endEpoch)?.count : db2.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 ? db2.query(staleSql).get(project, startEpoch, endEpoch)?.count : db2.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 ? db2.query(summarySql).all(project, startEpoch, endEpoch) : db2.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 (row.completed) {
+      const parts = row.completed.split("; ").filter(Boolean);
+      completedTasks.push(...parts);
+    }
+    if (row.next_steps) {
+      const parts = row.next_steps.split("; ").filter(Boolean);
+      nextStepsArr.push(...parts);
+    }
+  }
+  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 ? db2.query(filesSql).all(project, startEpoch, endEpoch) : db2.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
   };
 }
 
+// src/services/report-formatter.ts
+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");
+}
+
+// src/types/worker-types.ts
+var KNOWLEDGE_TYPES = ["constraint", "decision", "heuristic", "rejected"];
+
 // src/services/worker-service.ts
 var __worker_dirname = dirname2(fileURLToPath2(import.meta.url));
 var PORT = process.env.KIRO_MEMORY_WORKER_PORT || process.env.CONTEXTKIT_WORKER_PORT || 3001;
@@ -3722,17 +4763,23 @@ var HOST = process.env.KIRO_MEMORY_WORKER_HOST || process.env.CONTEXTKIT_WORKER_
 var PID_FILE = join3(DATA_DIR, "worker.pid");
 var TOKEN_FILE = join3(DATA_DIR, "worker.token");
 var MAX_SSE_CLIENTS = 50;
-if (!existsSync3(DATA_DIR)) {
+if (!existsSync4(DATA_DIR)) {
   mkdirSync3(DATA_DIR, { recursive: true });
 }
 var WORKER_TOKEN = crypto.randomBytes(32).toString("hex");
 writeFileSync(TOKEN_FILE, WORKER_TOKEN, "utf-8");
 try {
   chmodSync(TOKEN_FILE, 384);
-} catch {
+} catch (err) {
+  if (process.platform !== "win32") {
+    logger.warn("WORKER", `chmod 600 fallito su ${TOKEN_FILE}`, {}, err);
+  }
 }
 var db = new KiroMemoryDatabase();
 logger.info("WORKER", "Database initialized");
+getHybridSearch().initialize().catch((err) => {
+  logger.warn("WORKER", "Inizializzazione embedding fallita, ricerca solo FTS5", {}, err);
+});
 function parseIntSafe(value, defaultVal, min, max) {
   if (!value) return defaultVal;
   const parsed = parseInt(value, 10);
@@ -3740,7 +4787,7 @@ function parseIntSafe(value, defaultVal, min, max) {
   return parsed;
 }
 function isValidProject(project) {
-  return typeof project === "string" && project.length > 0 && project.length <= 200 && /^[\w\-\.\/@ ]+$/.test(project);
+  return typeof project === "string" && project.length > 0 && project.length <= 200 && /^[\w\-\.\/@ ]+$/.test(project) && !project.includes("..");
 }
 function isValidString(val, maxLen) {
   return typeof val === "string" && val.length <= maxLen;
@@ -3750,11 +4797,11 @@ app.use(helmet({
   contentSecurityPolicy: {
     directives: {
       defaultSrc: ["'self'"],
-      scriptSrc: ["'self'", "'unsafe-inline'"],
-      styleSrc: ["'self'", "'unsafe-inline'", "https://cdn.tailwindcss.com"],
+      scriptSrc: ["'self'", "'unsafe-inline'", "'unsafe-eval'", "https://cdn.tailwindcss.com"],
+      styleSrc: ["'self'", "'unsafe-inline'", "https://fonts.googleapis.com", "https://cdn.tailwindcss.com"],
       imgSrc: ["'self'", "data:"],
       connectSrc: ["'self'"],
-      fontSrc: ["'self'", "https://fonts.googleapis.com", "https://fonts.gstatic.com"],
+      fontSrc: ["'self'", "https://fonts.gstatic.com"],
       frameSrc: ["'none'"]
     }
   }
@@ -3849,6 +4896,10 @@ data: ${JSON.stringify({ timestamp: Date.now() })}
 });
 app.get("/api/context/:project", (req, res) => {
   const { project } = req.params;
+  if (!isValidProject(project)) {
+    res.status(400).json({ error: "Invalid project name" });
+    return;
+  }
   try {
     const context = {
       project,
@@ -3900,12 +4951,95 @@ app.post("/api/observations", (req, res) => {
       0
     );
     broadcast("observation-created", { id, project, title });
+    generateEmbeddingForObservation(id, title, content, concepts).catch(() => {
+    });
     res.json({ id, success: true });
   } catch (error) {
     logger.error("WORKER", "Failed to store observation", {}, error);
     res.status(500).json({ error: "Failed to store observation" });
   }
 });
+app.post("/api/knowledge", (req, res) => {
+  const {
+    project,
+    knowledge_type,
+    title,
+    content,
+    concepts,
+    files,
+    severity,
+    alternatives,
+    reason,
+    context: metaContext,
+    confidence
+  } = req.body;
+  if (!isValidProject(project)) {
+    res.status(400).json({ error: 'Invalid or missing "project"' });
+    return;
+  }
+  if (!knowledge_type || !KNOWLEDGE_TYPES.includes(knowledge_type)) {
+    res.status(400).json({ error: `Invalid "knowledge_type". Must be one of: ${KNOWLEDGE_TYPES.join(", ")}` });
+    return;
+  }
+  if (!isValidString(title, 500)) {
+    res.status(400).json({ error: 'Invalid or missing "title" (max 500 chars)' });
+    return;
+  }
+  if (!isValidString(content, 1e5)) {
+    res.status(400).json({ error: 'Invalid or missing "content" (max 100KB)' });
+    return;
+  }
+  if (concepts && !Array.isArray(concepts)) {
+    res.status(400).json({ error: '"concepts" must be an array' });
+    return;
+  }
+  if (files && !Array.isArray(files)) {
+    res.status(400).json({ error: '"files" must be an array' });
+    return;
+  }
+  try {
+    let metadata;
+    switch (knowledge_type) {
+      case "constraint":
+        metadata = { knowledgeType: "constraint", severity: severity === "hard" ? "hard" : "soft", reason };
+        break;
+      case "decision":
+        metadata = { knowledgeType: "decision", alternatives, reason };
+        break;
+      case "heuristic":
+        metadata = { knowledgeType: "heuristic", context: metaContext, confidence: ["high", "medium", "low"].includes(confidence) ? confidence : void 0 };
+        break;
+      case "rejected":
+        metadata = { knowledgeType: "rejected", reason: reason || "", alternatives };
+        break;
+      default:
+        res.status(400).json({ error: "Invalid knowledge_type" });
+        return;
+    }
+    const id = createObservation(
+      db.db,
+      "api-" + Date.now(),
+      project,
+      knowledge_type,
+      title,
+      null,
+      content,
+      null,
+      JSON.stringify(metadata),
+      concepts?.join(", ") || null,
+      files?.join(", ") || null,
+      null,
+      0
+    );
+    broadcast("observation-created", { id, project, title, type: knowledge_type });
+    generateEmbeddingForObservation(id, title, content, concepts).catch(() => {
+    });
+    res.json({ id, success: true, knowledge_type });
+  } catch (error) {
+    logger.error("WORKER", "Failed to store knowledge", {}, error);
+    res.status(500).json({ error: "Failed to store knowledge" });
+  }
+});
 app.post("/api/summaries", (req, res) => {
   const { sessionId, project, request, learned, completed, nextSteps } = req.body;
   if (!isValidProject(project)) {
@@ -4014,6 +5148,10 @@ app.post("/api/observations/batch", (req, res) => {
 });
 app.get("/api/stats/:project", (req, res) => {
   const { project } = req.params;
+  if (!isValidProject(project)) {
+    res.status(400).json({ error: "Invalid project name" });
+    return;
+  }
   try {
     const stats = getProjectStats(db.db, project);
     res.json(stats);
@@ -4022,6 +5160,76 @@ app.get("/api/stats/:project", (req, res) => {
     res.status(500).json({ error: "Stats failed" });
   }
 });
+async function generateEmbeddingForObservation(observationId, title, content, concepts) {
+  try {
+    const embeddingService2 = getEmbeddingService();
+    if (!embeddingService2.isAvailable()) return;
+    const parts = [title];
+    if (content) parts.push(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(
+        db.db,
+        observationId,
+        embedding,
+        embeddingService2.getProvider() || "unknown"
+      );
+    }
+  } catch (error) {
+    logger.debug("WORKER", `Embedding generation fallita per obs ${observationId}: ${error}`);
+  }
+}
+app.get("/api/hybrid-search", async (req, res) => {
+  const { q, project, limit } = req.query;
+  if (!q) {
+    res.status(400).json({ error: 'Query parameter "q" is required' });
+    return;
+  }
+  try {
+    const hybridSearch2 = getHybridSearch();
+    const results = await hybridSearch2.search(db.db, q, {
+      project: project || void 0,
+      limit: parseIntSafe(limit, 10, 1, 100)
+    });
+    res.json({ results, count: results.length });
+  } catch (error) {
+    logger.error("WORKER", "Ricerca ibrida fallita", { query: q }, error);
+    res.status(500).json({ error: "Hybrid search failed" });
+  }
+});
+app.post("/api/embeddings/backfill", async (req, res) => {
+  const { batchSize } = req.body || {};
+  try {
+    const vectorSearch2 = getVectorSearch();
+    const count = await vectorSearch2.backfillEmbeddings(
+      db.db,
+      parseIntSafe(String(batchSize), 50, 1, 500)
+    );
+    res.json({ success: true, generated: count });
+  } catch (error) {
+    logger.error("WORKER", "Backfill embeddings fallito", {}, error);
+    res.status(500).json({ error: "Backfill failed" });
+  }
+});
+app.get("/api/embeddings/stats", (_req, res) => {
+  try {
+    const vectorSearch2 = getVectorSearch();
+    const stats = vectorSearch2.getStats(db.db);
+    const embeddingService2 = getEmbeddingService();
+    res.json({
+      ...stats,
+      provider: embeddingService2.getProvider(),
+      dimensions: embeddingService2.getDimensions(),
+      available: embeddingService2.isAvailable()
+    });
+  } catch (error) {
+    logger.error("WORKER", "Embedding stats fallite", {}, error);
+    res.status(500).json({ error: "Stats failed" });
+  }
+});
 app.get("/api/observations", (req, res) => {
   const { offset, limit, project } = req.query;
   const _offset = parseIntSafe(offset, 0, 0, 1e6);
@@ -4129,13 +5337,153 @@ app.get("/api/projects", (_req, res) => {
     res.status(500).json({ error: "Failed to list projects" });
   }
 });
+app.get("/api/analytics/overview", (req, res) => {
+  const { project } = req.query;
+  if (project && !isValidProject(project)) {
+    res.status(400).json({ error: "Invalid project name" });
+    return;
+  }
+  try {
+    const overview = getAnalyticsOverview(db.db, project || void 0);
+    res.json(overview);
+  } catch (error) {
+    logger.error("WORKER", "Analytics overview fallita", { project }, error);
+    res.status(500).json({ error: "Analytics overview failed" });
+  }
+});
+app.get("/api/analytics/timeline", (req, res) => {
+  const { project, days } = req.query;
+  if (project && !isValidProject(project)) {
+    res.status(400).json({ error: "Invalid project name" });
+    return;
+  }
+  try {
+    const timeline = getObservationsTimeline(
+      db.db,
+      project || void 0,
+      parseIntSafe(days, 30, 1, 365)
+    );
+    res.json(timeline);
+  } catch (error) {
+    logger.error("WORKER", "Analytics timeline fallita", { project }, error);
+    res.status(500).json({ error: "Analytics timeline failed" });
+  }
+});
+app.get("/api/analytics/types", (req, res) => {
+  const { project } = req.query;
+  if (project && !isValidProject(project)) {
+    res.status(400).json({ error: "Invalid project name" });
+    return;
+  }
+  try {
+    const distribution = getTypeDistribution(db.db, project || void 0);
+    res.json(distribution);
+  } catch (error) {
+    logger.error("WORKER", "Analytics types fallita", { project }, error);
+    res.status(500).json({ error: "Analytics types failed" });
+  }
+});
+app.get("/api/analytics/sessions", (req, res) => {
+  const { project } = req.query;
+  if (project && !isValidProject(project)) {
+    res.status(400).json({ error: "Invalid project name" });
+    return;
+  }
+  try {
+    const stats = getSessionStats(db.db, project || void 0);
+    res.json(stats);
+  } catch (error) {
+    logger.error("WORKER", "Analytics sessions fallita", { project }, error);
+    res.status(500).json({ error: "Analytics sessions failed" });
+  }
+});
+app.get("/api/sessions", (req, res) => {
+  const { project } = req.query;
+  if (project && !isValidProject(project)) {
+    res.status(400).json({ error: "Invalid project name" });
+    return;
+  }
+  try {
+    const sessions = project ? getSessionsByProject(db.db, project, 50) : getActiveSessions(db.db);
+    res.json(sessions);
+  } catch (error) {
+    logger.error("WORKER", "Lista sessioni fallita", { project }, error);
+    res.status(500).json({ error: "Sessions list failed" });
+  }
+});
+app.get("/api/sessions/:id/checkpoint", (req, res) => {
+  const sessionId = parseInt(req.params.id, 10);
+  if (isNaN(sessionId) || sessionId <= 0) {
+    res.status(400).json({ error: "Invalid session ID" });
+    return;
+  }
+  try {
+    const checkpoint = getLatestCheckpoint(db.db, sessionId);
+    if (!checkpoint) {
+      res.status(404).json({ error: "No checkpoint found for this session" });
+      return;
+    }
+    res.json(checkpoint);
+  } catch (error) {
+    logger.error("WORKER", "Checkpoint fetch fallito", { sessionId }, error);
+    res.status(500).json({ error: "Checkpoint fetch failed" });
+  }
+});
+app.get("/api/checkpoint", (req, res) => {
+  const { project } = req.query;
+  if (!project) {
+    res.status(400).json({ error: "Project parameter is required" });
+    return;
+  }
+  if (!isValidProject(project)) {
+    res.status(400).json({ error: "Invalid project name" });
+    return;
+  }
+  try {
+    const checkpoint = getLatestCheckpointByProject(db.db, project);
+    if (!checkpoint) {
+      res.status(404).json({ error: "No checkpoint found for this project" });
+      return;
+    }
+    res.json(checkpoint);
+  } catch (error) {
+    logger.error("WORKER", "Checkpoint per progetto fallito", { project }, error);
+    res.status(500).json({ error: "Project checkpoint fetch failed" });
+  }
+});
+app.get("/api/report", (req, res) => {
+  const { project, period, format } = req.query;
+  if (project && !isValidProject(project)) {
+    res.status(400).json({ error: "Invalid project name" });
+    return;
+  }
+  const validPeriods = ["weekly", "monthly"];
+  const reportPeriod = validPeriods.includes(period || "") ? period : "weekly";
+  const daysBack = reportPeriod === "monthly" ? 30 : 7;
+  const now = Date.now();
+  const startEpoch = now - daysBack * 24 * 60 * 60 * 1e3;
+  try {
+    const data = getReportData(db.db, project || void 0, startEpoch, now);
+    const outputFormat = format || "json";
+    if (outputFormat === "markdown" || outputFormat === "md") {
+      res.type("text/markdown").send(formatReportMarkdown(data));
+    } else if (outputFormat === "text") {
+      res.type("text/plain").send(JSON.stringify(data, null, 2));
+    } else {
+      res.json(data);
+    }
+  } catch (error) {
+    logger.error("WORKER", "Report generation fallita", { project, period }, error);
+    res.status(500).json({ error: "Report generation failed" });
+  }
+});
 app.use(express.static(__worker_dirname, {
   index: false,
   maxAge: "1h"
 }));
 app.get("/", (_req, res) => {
   const viewerPath = join3(__worker_dirname, "viewer.html");
-  if (existsSync3(viewerPath)) {
+  if (existsSync4(viewerPath)) {
     res.sendFile(viewerPath);
   } else {
     res.status(404).json({ error: "Viewer not found. Run npm run build first." });
@@ -4149,7 +5497,7 @@ function shutdown(signal) {
   logger.info("WORKER", `Received ${signal}, shutting down gracefully...`);
   server.close(() => {
     logger.info("WORKER", "Server closed");
-    if (existsSync3(PID_FILE)) {
+    if (existsSync4(PID_FILE)) {
       unlinkSync(PID_FILE);
     }
     db.close();