@loreai/core 0.18.0 → 0.19.0

package/dist/node/index.js

@@ -125,6 +125,7 @@ __export(temporal_exports, {
   CHUNK_TERMINATOR: () => CHUNK_TERMINATOR,
   bySession: () => bySession,
   count: () => count,
+  hasMessages: () => hasMessages,
   markDistilled: () => markDistilled,
   partsToText: () => partsToText,
   prune: () => prune,
@@ -754,6 +755,55 @@ var MIGRATIONS = [
     WHERE ih.project_id = projects.id
       AND ih.source_id = '__declined__'
   );
+  `,
+  `
+  -- Version 23: Persist volatile session tracking state across restarts.
+  -- Previously these were in-memory only, causing duplicate processing,
+  -- false compaction detection, and expensive prompt cache busts on restart.
+  ALTER TABLE session_state ADD COLUMN last_curated_at INTEGER NOT NULL DEFAULT 0;
+  ALTER TABLE session_state ADD COLUMN message_count INTEGER NOT NULL DEFAULT 0;
+  ALTER TABLE session_state ADD COLUMN turns_since_curation INTEGER NOT NULL DEFAULT 0;
+  ALTER TABLE session_state ADD COLUMN ltm_cache_text TEXT;
+  ALTER TABLE session_state ADD COLUMN ltm_cache_tokens INTEGER;
+  ALTER TABLE session_state ADD COLUMN ltm_pin_text TEXT;
+  ALTER TABLE session_state ADD COLUMN ltm_pin_tokens INTEGER;
+  ALTER TABLE session_state ADD COLUMN consecutive_text_only_turns INTEGER NOT NULL DEFAULT 0;
+  `,
+  `
+  -- Version 24: Persist remaining volatile session state across restarts.
+  -- Session identity (Tier 1/2/3 session correlation)
+  ALTER TABLE session_state ADD COLUMN fingerprint TEXT NOT NULL DEFAULT '';
+  ALTER TABLE session_state ADD COLUMN header_session_id TEXT;
+  ALTER TABLE session_state ADD COLUMN header_name TEXT;
+  -- Cache warming state
+  ALTER TABLE session_state ADD COLUMN resolved_conversation_ttl TEXT NOT NULL DEFAULT '5m';
+  ALTER TABLE session_state ADD COLUMN warmup_state TEXT;
+  -- Gradient calibration state (survives restarts to avoid uncalibrated busts)
+  ALTER TABLE session_state ADD COLUMN dynamic_context_cap REAL NOT NULL DEFAULT 0;
+  ALTER TABLE session_state ADD COLUMN bust_rate_ema REAL NOT NULL DEFAULT -1;
+  ALTER TABLE session_state ADD COLUMN inter_bust_interval_ema REAL NOT NULL DEFAULT -1;
+  ALTER TABLE session_state ADD COLUMN last_layer INTEGER NOT NULL DEFAULT 0;
+  ALTER TABLE session_state ADD COLUMN last_known_input INTEGER NOT NULL DEFAULT 0;
+  ALTER TABLE session_state ADD COLUMN last_turn_at INTEGER NOT NULL DEFAULT 0;
+  ALTER TABLE session_state ADD COLUMN last_bust_at INTEGER NOT NULL DEFAULT 0;
+  `,
+  `
+  -- Version 25: Adaptive dedup threshold \u2014 store accept/reject feedback
+  -- on embedding-based duplicate pairs for per-project threshold calibration.
+  -- Titles stored instead of FK IDs because entries are deleted during dedup;
+  -- the similarity float is the actual calibration input.
+  CREATE TABLE IF NOT EXISTS dedup_feedback (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    project_id TEXT,
+    entry_a_title TEXT NOT NULL,
+    entry_b_title TEXT NOT NULL,
+    similarity REAL NOT NULL,
+    accepted INTEGER NOT NULL,
+    source TEXT NOT NULL DEFAULT 'manual',
+    created_at INTEGER NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS idx_dedup_feedback_project
+    ON dedup_feedback(project_id);
   `
 ];
 function dbPath() {
@@ -890,6 +940,11 @@ function close() {
   }
 }
 function ensureProject(path, name) {
+  if (!process.env.LORE_DB_PATH && /^\/test\//.test(path)) {
+    throw new Error(
+      `Refusing to create project with test path "${path}" in the production DB. Set LORE_DB_PATH to a temp path, or run tests via \`bun test\` from the repo root.`
+    );
+  }
   const existing = db().query("SELECT id, git_remote FROM projects WHERE path = ?").get(path);
   if (existing) {
     if (!existing.git_remote) {
@@ -1058,6 +1113,153 @@ function loadAllSessionCosts() {
   }
   return result;
 }
+function saveSessionTracking(sessionID, state) {
+  const now = Date.now();
+  db().query(
+    "INSERT OR IGNORE INTO session_state (session_id, force_min_layer, updated_at) VALUES (?, 0, ?)"
+  ).run(sessionID, now);
+  const sets = ["updated_at = ?"];
+  const vals = [now];
+  if (state.lastCuratedAt !== void 0) {
+    sets.push("last_curated_at = ?");
+    vals.push(state.lastCuratedAt);
+  }
+  if (state.messageCount !== void 0) {
+    sets.push("message_count = ?");
+    vals.push(state.messageCount);
+  }
+  if (state.turnsSinceCuration !== void 0) {
+    sets.push("turns_since_curation = ?");
+    vals.push(state.turnsSinceCuration);
+  }
+  if (state.consecutiveTextOnlyTurns !== void 0) {
+    sets.push("consecutive_text_only_turns = ?");
+    vals.push(state.consecutiveTextOnlyTurns);
+  }
+  if (state.ltmCacheText !== void 0) {
+    sets.push("ltm_cache_text = ?");
+    vals.push(state.ltmCacheText);
+  }
+  if (state.ltmCacheTokens !== void 0) {
+    sets.push("ltm_cache_tokens = ?");
+    vals.push(state.ltmCacheTokens);
+  }
+  if (state.ltmPinText !== void 0) {
+    sets.push("ltm_pin_text = ?");
+    vals.push(state.ltmPinText);
+  }
+  if (state.ltmPinTokens !== void 0) {
+    sets.push("ltm_pin_tokens = ?");
+    vals.push(state.ltmPinTokens);
+  }
+  if (state.fingerprint !== void 0) {
+    sets.push("fingerprint = ?");
+    vals.push(state.fingerprint);
+  }
+  if (state.headerSessionId !== void 0) {
+    sets.push("header_session_id = ?");
+    vals.push(state.headerSessionId);
+  }
+  if (state.headerName !== void 0) {
+    sets.push("header_name = ?");
+    vals.push(state.headerName);
+  }
+  if (state.resolvedConversationTTL !== void 0) {
+    sets.push("resolved_conversation_ttl = ?");
+    vals.push(state.resolvedConversationTTL);
+  }
+  if (state.warmupState !== void 0) {
+    sets.push("warmup_state = ?");
+    vals.push(state.warmupState);
+  }
+  if (state.dynamicContextCap !== void 0) {
+    sets.push("dynamic_context_cap = ?");
+    vals.push(state.dynamicContextCap);
+  }
+  if (state.bustRateEMA !== void 0) {
+    sets.push("bust_rate_ema = ?");
+    vals.push(state.bustRateEMA);
+  }
+  if (state.interBustIntervalEMA !== void 0) {
+    sets.push("inter_bust_interval_ema = ?");
+    vals.push(state.interBustIntervalEMA);
+  }
+  if (state.lastLayer !== void 0) {
+    sets.push("last_layer = ?");
+    vals.push(state.lastLayer);
+  }
+  if (state.lastKnownInput !== void 0) {
+    sets.push("last_known_input = ?");
+    vals.push(state.lastKnownInput);
+  }
+  if (state.lastTurnAt !== void 0) {
+    sets.push("last_turn_at = ?");
+    vals.push(state.lastTurnAt);
+  }
+  if (state.lastBustAt !== void 0) {
+    sets.push("last_bust_at = ?");
+    vals.push(state.lastBustAt);
+  }
+  db().query(
+    "UPDATE session_state SET " + sets.join(", ") + " WHERE session_id = ?"
+  ).run(...vals, sessionID);
+}
+function loadSessionTracking(sessionID) {
+  const row = db().query(
+    `SELECT last_curated_at, message_count, turns_since_curation,
+              consecutive_text_only_turns,
+              ltm_cache_text, ltm_cache_tokens, ltm_pin_text, ltm_pin_tokens,
+              fingerprint, header_session_id, header_name,
+              resolved_conversation_ttl, warmup_state,
+              dynamic_context_cap, bust_rate_ema, inter_bust_interval_ema,
+              last_layer, last_known_input, last_turn_at, last_bust_at
+       FROM session_state WHERE session_id = ?`
+  ).get(sessionID);
+  if (!row) return null;
+  return {
+    lastCuratedAt: row.last_curated_at,
+    messageCount: row.message_count,
+    turnsSinceCuration: row.turns_since_curation,
+    consecutiveTextOnlyTurns: row.consecutive_text_only_turns,
+    ltmCacheText: row.ltm_cache_text,
+    ltmCacheTokens: row.ltm_cache_tokens,
+    ltmPinText: row.ltm_pin_text,
+    ltmPinTokens: row.ltm_pin_tokens,
+    fingerprint: row.fingerprint,
+    headerSessionId: row.header_session_id,
+    headerName: row.header_name,
+    resolvedConversationTTL: row.resolved_conversation_ttl,
+    warmupState: row.warmup_state,
+    dynamicContextCap: row.dynamic_context_cap,
+    bustRateEMA: row.bust_rate_ema,
+    interBustIntervalEMA: row.inter_bust_interval_ema,
+    lastLayer: row.last_layer,
+    lastKnownInput: row.last_known_input,
+    lastTurnAt: row.last_turn_at,
+    lastBustAt: row.last_bust_at
+  };
+}
+function loadHeaderSessionIndex() {
+  const rows = db().query(
+    `SELECT session_id, header_session_id, header_name
+       FROM session_state
+       WHERE header_session_id IS NOT NULL AND header_name IS NOT NULL`
+  ).all();
+  return rows.map((row) => ({
+    sessionId: row.session_id,
+    headerSessionId: row.header_session_id,
+    headerName: row.header_name
+  }));
+}
+function getKV(key) {
+  const row = db().query("SELECT value FROM kv_meta WHERE key = ?").get(key);
+  return row?.value ?? null;
+}
+function setKV(key, value) {
+  db().query(
+    "INSERT INTO kv_meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = ?"
+  ).run(key, value, value);
+}
 function getMeta(key) {
   const row = db().query("SELECT value FROM metadata WHERE key = ?").get(key);
   return row?.value ?? null;
@@ -26770,7 +26972,16 @@ var LocalProvider = class {
           workerUrl = vendorWorkerUrl;
         }
       } else {
-        workerUrl = new URL(`./embedding-worker${import.meta.url.endsWith(".ts") ? ".ts" : ".js"}`, import.meta.url);
+        const selfUrl = typeof import.meta.url === "string" ? import.meta.url : void 0;
+        if (selfUrl) {
+          workerUrl = new URL(
+            `./embedding-worker${selfUrl.endsWith(".ts") ? ".ts" : ".js"}`,
+            selfUrl
+          );
+        } else {
+          const { pathToFileURL } = await import("node:url");
+          workerUrl = new URL("./embedding-worker.cjs", pathToFileURL(__filename));
+        }
       }
       const vendor = vendorModelInfo();
       const workerInitData = {
@@ -27045,8 +27256,14 @@ function fromBlob(blob) {
   const bytes = new Uint8Array(blob);
   return new Float32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 4);
 }
-function vectorSearch(queryEmbedding, limit = 10) {
-  const rows = db().query("SELECT id, embedding FROM knowledge WHERE embedding IS NOT NULL AND confidence > 0.2").all();
+function vectorSearch(queryEmbedding, limit = 10, excludeCategories) {
+  let sql = "SELECT id, embedding FROM knowledge WHERE embedding IS NOT NULL AND confidence > 0.2";
+  const params = [];
+  if (excludeCategories?.length) {
+    sql += ` AND category NOT IN (${excludeCategories.map(() => "?").join(",")})`;
+    params.push(...excludeCategories);
+  }
+  const rows = db().query(sql).all(...params);
   const scored = [];
   for (const row of rows) {
     const vec = fromBlob(row.embedding);
@@ -27435,6 +27652,12 @@ function count(projectPath, sessionID) {
   const params = sessionID ? [pid, sessionID] : [pid];
   return db().query(query).get(...params).count;
 }
+function hasMessages(projectPath, sessionID) {
+  const pid = ensureProject(projectPath);
+  return !!db().query(
+    "SELECT 1 FROM temporal_messages WHERE project_id = ? AND session_id = ? LIMIT 1"
+  ).get(pid, sessionID);
+}
 function undistilledCount(projectPath, sessionID) {
   const pid = ensureProject(projectPath);
   const query = sessionID ? "SELECT COUNT(*) as count FROM temporal_messages WHERE project_id = ? AND session_id = ? AND distilled = 0" : "SELECT COUNT(*) as count FROM temporal_messages WHERE project_id = ? AND distilled = 0";
@@ -27493,11 +27716,13 @@ function prune(input) {
 var ltm_exports = {};
 __export(ltm_exports, {
   all: () => all2,
+  calibrateDedupThreshold: () => calibrateDedupThreshold,
   cascadeRefReplace: () => cascadeRefReplace,
   check: () => check2,
   cleanDeadRefs: () => cleanDeadRefs,
   create: () => create,
   crossProject: () => crossProject,
+  dedupPairKey: () => dedupPairKey,
   deduplicate: () => deduplicate,
   deduplicateGlobal: () => deduplicateGlobal,
   extractRefs: () => extractRefs,
@@ -27505,9 +27730,17 @@ __export(ltm_exports, {
   forProject: () => forProject,
   forSession: () => forSession,
   get: () => get,
+  getDedupFeedback: () => getDedupFeedback,
+  getDedupFeedbackCount: () => getDedupFeedbackCount,
+  loadCalibratedThreshold: () => loadCalibratedThreshold,
+  pruneDedupFeedback: () => pruneDedupFeedback,
   pruneOversized: () => pruneOversized,
+  recordAutoSignals: () => recordAutoSignals,
+  recordDedupFeedback: () => recordDedupFeedback,
+  recordDedupResultFeedback: () => recordDedupResultFeedback,
   remove: () => remove,
   resolveRef: () => resolveRef2,
+  saveCalibratedThreshold: () => saveCalibratedThreshold,
   search: () => search3,
   searchScored: () => searchScored3,
   searchScoredOtherProjects: () => searchScoredOtherProjects,
@@ -28244,18 +28477,29 @@ function scoreEntriesFTS(sessionContext) {
     return /* @__PURE__ */ new Map();
   }
 }
-function forSession(projectPath, sessionID, maxTokens) {
+async function forSession(projectPath, sessionID, maxTokens, options) {
   const pid = ensureProject(projectPath);
+  const categoryFilter = options?.categories;
+  const excludeFilter = options?.excludeCategories;
+  let categoryClause = "";
+  let categoryParams = [];
+  if (categoryFilter?.length) {
+    categoryClause = ` AND category IN (${categoryFilter.map(() => "?").join(",")})`;
+    categoryParams = categoryFilter;
+  } else if (excludeFilter?.length) {
+    categoryClause = ` AND category NOT IN (${excludeFilter.map(() => "?").join(",")})`;
+    categoryParams = excludeFilter;
+  }
   const projectEntries = db().query(
     `SELECT ${KNOWLEDGE_COLS} FROM knowledge
-       WHERE project_id = ? AND cross_project = 0 AND confidence > 0.2
+       WHERE project_id = ? AND cross_project = 0 AND confidence > 0.2${categoryClause}
        ORDER BY confidence DESC, updated_at DESC`
-  ).all(pid);
+  ).all(pid, ...categoryParams);
   const crossEntries = db().query(
     `SELECT ${KNOWLEDGE_COLS} FROM knowledge
-       WHERE (project_id IS NULL OR cross_project = 1) AND confidence > 0.2
+       WHERE (project_id IS NULL OR cross_project = 1) AND confidence > 0.2${categoryClause}
        ORDER BY confidence DESC, updated_at DESC`
-  ).all();
+  ).all(...categoryParams);
   if (!crossEntries.length && !projectEntries.length) return [];
   let sessionContext = "";
   if (sessionID) {
@@ -28276,22 +28520,52 @@ function forSession(projectPath, sessionID, maxTokens) {
       sessionContext += recentMsgs.map((m) => m.content).join("\n");
     }
   }
+  if (!sessionContext.trim() && options?.contextHint) {
+    sessionContext = options.contextHint;
+  }
   let scoredProject;
   let scoredCross;
-  if (sessionContext.trim().length > 20) {
+  if (sessionContext.trim().length > 20 && isAvailable()) {
+    let vectorScores;
+    try {
+      const [contextVec] = await embed([sessionContext], "query");
+      const hits = vectorSearch(contextVec, 50, excludeFilter);
+      vectorScores = new Map(hits.map((h3) => [h3.id, h3.similarity]));
+    } catch (err) {
+      warn("Vector scoring failed, falling back to FTS5:", err);
+      vectorScores = /* @__PURE__ */ new Map();
+    }
+    if (vectorScores.size > 0) {
+      const ftsScores = scoreEntriesFTS(sessionContext);
+      const rawScored = projectEntries.map((entry) => {
+        const vecScore = vectorScores.get(entry.id);
+        const score = vecScore != null ? vecScore * entry.confidence : (ftsScores.get(entry.id) ?? 0) * entry.confidence;
+        return { entry, score };
+      });
+      const matched = rawScored.filter((s) => s.score > 0);
+      const matchedIds = new Set(matched.map((s) => s.entry.id));
+      const safetyNet = projectEntries.filter((e) => !matchedIds.has(e.id)).slice(0, PROJECT_SAFETY_NET).map((e) => ({ entry: e, score: 1e-3 * e.confidence }));
+      scoredProject = [...matched, ...safetyNet];
+      scoredCross = crossEntries.filter((e) => vectorScores.has(e.id) || ftsScores.has(e.id)).map((e) => {
+        const vecScore = vectorScores.get(e.id);
+        const score = vecScore != null ? vecScore * e.confidence : (ftsScores.get(e.id) ?? 0) * e.confidence;
+        return { entry: e, score };
+      });
+    } else {
+      const ftsScores = scoreEntriesFTS(sessionContext);
+      ({ scoredProject, scoredCross } = scoreFTS(
+        projectEntries,
+        crossEntries,
+        ftsScores
+      ));
+    }
+  } else if (sessionContext.trim().length > 20) {
     const ftsScores = scoreEntriesFTS(sessionContext);
-    const rawScored = projectEntries.map((entry) => ({
-      entry,
-      score: (ftsScores.get(entry.id) ?? 0) * entry.confidence
-    }));
-    const matched = rawScored.filter((s) => s.score > 0);
-    const matchedIds = new Set(matched.map((s) => s.entry.id));
-    const safetyNet = projectEntries.filter((e) => !matchedIds.has(e.id)).slice(0, PROJECT_SAFETY_NET).map((e) => ({ entry: e, score: 1e-3 * e.confidence }));
-    scoredProject = [...matched, ...safetyNet];
-    scoredCross = crossEntries.filter((e) => ftsScores.has(e.id)).map((e) => ({
-      entry: e,
-      score: (ftsScores.get(e.id) ?? 0) * e.confidence
-    }));
+    ({ scoredProject, scoredCross } = scoreFTS(
+      projectEntries,
+      crossEntries,
+      ftsScores
+    ));
   } else {
     scoredProject = projectEntries.slice(0, NO_CONTEXT_FALLBACK_CAP).map((entry) => ({ entry, score: entry.confidence }));
     scoredCross = crossEntries.slice(0, NO_CONTEXT_FALLBACK_CAP).map((entry) => ({ entry, score: entry.confidence }));
@@ -28337,6 +28611,21 @@ function forSession(projectPath, sessionID, maxTokens) {
   }
   return result;
 }
+function scoreFTS(projectEntries, crossEntries, ftsScores) {
+  const rawScored = projectEntries.map((entry) => ({
+    entry,
+    score: (ftsScores.get(entry.id) ?? 0) * entry.confidence
+  }));
+  const matched = rawScored.filter((s) => s.score > 0);
+  const matchedIds = new Set(matched.map((s) => s.entry.id));
+  const safetyNet = projectEntries.filter((e) => !matchedIds.has(e.id)).slice(0, PROJECT_SAFETY_NET).map((e) => ({ entry: e, score: 1e-3 * e.confidence }));
+  const scoredProject = [...matched, ...safetyNet];
+  const scoredCross = crossEntries.filter((e) => ftsScores.has(e.id)).map((e) => ({
+    entry: e,
+    score: (ftsScores.get(e.id) ?? 0) * e.confidence
+  }));
+  return { scoredProject, scoredCross };
+}
 function all2() {
   return db().query(
     `SELECT ${KNOWLEDGE_COLS} FROM knowledge WHERE confidence > 0.2 ORDER BY confidence DESC, updated_at DESC`
@@ -28580,8 +28869,11 @@ function check2(projectPath) {
   }
   return issues;
 }
-function _dedup(entries, dryRun) {
-  if (entries.length < 2) return { clusters: [], totalRemoved: 0 };
+function dedupPairKey(idA, idB) {
+  return idA < idB ? `${idA}:${idB}` : `${idB}:${idA}`;
+}
+function _dedup(entries, dryRun, embeddingThreshold = EMBEDDING_DEDUP_THRESHOLD) {
+  if (entries.length < 2) return { clusters: [], totalRemoved: 0, pairSimilarities: /* @__PURE__ */ new Map(), entryTitles: /* @__PURE__ */ new Map() };
   const embeddingMap = /* @__PURE__ */ new Map();
   {
     const entryIds = entries.map((e) => e.id);
@@ -28596,6 +28888,7 @@ function _dedup(entries, dryRun) {
     }
   }
   const neighborMap = /* @__PURE__ */ new Map();
+  const pairSimilarities = /* @__PURE__ */ new Map();
   for (const entry of entries) {
     const neighbors = [];
     const entryVec = embeddingMap.get(entry.id);
@@ -28609,7 +28902,13 @@ function _dedup(entries, dryRun) {
         const otherVec = embeddingMap.get(other.id);
         if (otherVec && entryVec.length === otherVec.length) {
           similarity = cosineSimilarity(entryVec, otherVec);
-          embeddingMatch = similarity >= EMBEDDING_DEDUP_THRESHOLD;
+          embeddingMatch = similarity >= embeddingThreshold;
+        }
+      }
+      if (similarity > 0) {
+        const pk = dedupPairKey(entry.id, other.id);
+        if (!pairSimilarities.has(pk)) {
+          pairSimilarities.set(pk, similarity);
         }
       }
       if (titleMatch || embeddingMatch) {
@@ -28661,20 +28960,178 @@ function _dedup(entries, dryRun) {
     totalRemoved += merged.length;
   }
   result.sort((a, b) => b.merged.length - a.merged.length);
-  return { clusters: result, totalRemoved };
+  const entryTitles = new Map(entries.map((e) => [e.id, e.title]));
+  return { clusters: result, totalRemoved, pairSimilarities, entryTitles };
 }
 async function deduplicate(projectPath, opts) {
+  const pid = ensureProject(projectPath);
+  const threshold = loadCalibratedThreshold(pid) ?? EMBEDDING_DEDUP_THRESHOLD;
   const entries = forProject(projectPath, false);
-  return _dedup(entries, opts?.dryRun ?? true);
+  return _dedup(entries, opts?.dryRun ?? true, threshold);
 }
 async function deduplicateGlobal(opts) {
+  const threshold = loadCalibratedThreshold(null) ?? EMBEDDING_DEDUP_THRESHOLD;
   const entries = db().query(
     `SELECT ${KNOWLEDGE_COLS} FROM knowledge
        WHERE project_id IS NULL
        AND confidence > 0.2
        ORDER BY confidence DESC, updated_at DESC`
   ).all();
-  return _dedup(entries, opts?.dryRun ?? true);
+  return _dedup(entries, opts?.dryRun ?? true, threshold);
+}
+var MIN_CALIBRATION_SAMPLES = 20;
+var DEFAULT_EMBEDDING_DEDUP_THRESHOLD = EMBEDDING_DEDUP_THRESHOLD;
+var AUTO_SIGNAL_MIN_SIMILARITY = 0.8;
+var AUTO_SIGNAL_MAX_PAIRS = 50;
+function recordDedupFeedback(input) {
+  db().query(
+    `INSERT INTO dedup_feedback
+         (project_id, entry_a_title, entry_b_title, similarity, accepted, source, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    input.projectId,
+    input.entryATitle,
+    input.entryBTitle,
+    input.similarity,
+    input.accepted ? 1 : 0,
+    input.source,
+    Date.now()
+  );
+}
+function recordDedupResultFeedback(projectId2, result, accepted, source) {
+  for (const cluster of result.clusters) {
+    for (const merged of cluster.merged) {
+      const pk = dedupPairKey(cluster.surviving.id, merged.id);
+      const similarity = result.pairSimilarities.get(pk);
+      if (similarity != null && similarity > 0) {
+        recordDedupFeedback({
+          projectId: projectId2,
+          entryATitle: cluster.surviving.title,
+          entryBTitle: merged.title,
+          similarity,
+          accepted,
+          source
+        });
+      }
+    }
+  }
+}
+function recordAutoSignals(projectId2, result) {
+  const mergedPairs = /* @__PURE__ */ new Set();
+  for (const cluster of result.clusters) {
+    for (const merged of cluster.merged) {
+      mergedPairs.add(dedupPairKey(cluster.surviving.id, merged.id));
+    }
+  }
+  const titleMap = new Map(result.entryTitles);
+  for (const cluster of result.clusters) {
+    if (!titleMap.has(cluster.surviving.id)) {
+      titleMap.set(cluster.surviving.id, cluster.surviving.title);
+    }
+    for (const m of cluster.merged) {
+      if (!titleMap.has(m.id)) titleMap.set(m.id, m.title);
+    }
+  }
+  const signals = [];
+  for (const [pk, sim] of result.pairSimilarities) {
+    if (sim < AUTO_SIGNAL_MIN_SIMILARITY) continue;
+    if (mergedPairs.has(pk)) continue;
+    const [idA, idB] = pk.split(":");
+    const titleA = titleMap.get(idA);
+    const titleB = titleMap.get(idB);
+    if (!titleA || !titleB) continue;
+    signals.push({ entryATitle: titleA, entryBTitle: titleB, similarity: sim });
+  }
+  const currentThreshold = loadCalibratedThreshold(projectId2) ?? DEFAULT_EMBEDDING_DEDUP_THRESHOLD;
+  signals.sort((a, b) => Math.abs(a.similarity - currentThreshold) - Math.abs(b.similarity - currentThreshold));
+  const capped = signals.slice(0, AUTO_SIGNAL_MAX_PAIRS);
+  pruneDedupFeedback(projectId2);
+  for (const s of capped) {
+    recordDedupFeedback({
+      projectId: projectId2,
+      entryATitle: s.entryATitle,
+      entryBTitle: s.entryBTitle,
+      similarity: s.similarity,
+      accepted: false,
+      source: "auto_dedup"
+    });
+  }
+}
+function getDedupFeedback(projectId2) {
+  const rows = projectId2 !== null ? db().query(
+    "SELECT similarity, accepted, source FROM dedup_feedback WHERE project_id = ? ORDER BY similarity"
+  ).all(projectId2) : db().query(
+    "SELECT similarity, accepted, source FROM dedup_feedback WHERE project_id IS NULL ORDER BY similarity"
+  ).all();
+  return rows.map((r) => ({ similarity: r.similarity, accepted: r.accepted === 1, source: r.source }));
+}
+function getDedupFeedbackCount(projectId2) {
+  const row = projectId2 !== null ? db().query("SELECT COUNT(*) as cnt FROM dedup_feedback WHERE project_id = ?").get(projectId2) : db().query("SELECT COUNT(*) as cnt FROM dedup_feedback WHERE project_id IS NULL").get();
+  return row?.cnt ?? 0;
+}
+var MAX_FEEDBACK_ROWS_PER_PROJECT = 500;
+function pruneDedupFeedback(projectId2) {
+  const count3 = getDedupFeedbackCount(projectId2);
+  if (count3 <= MAX_FEEDBACK_ROWS_PER_PROJECT) return;
+  const excess = count3 - MAX_FEEDBACK_ROWS_PER_PROJECT;
+  if (projectId2 !== null) {
+    db().query(
+      `DELETE FROM dedup_feedback WHERE id IN (
+           SELECT id FROM dedup_feedback WHERE project_id = ?
+           ORDER BY created_at ASC LIMIT ?
+         )`
+    ).run(projectId2, excess);
+  } else {
+    db().query(
+      `DELETE FROM dedup_feedback WHERE id IN (
+           SELECT id FROM dedup_feedback WHERE project_id IS NULL
+           ORDER BY created_at ASC LIMIT ?
+         )`
+    ).run(excess);
+  }
+}
+function calibrateDedupThreshold(projectId2) {
+  const feedback = getDedupFeedback(projectId2);
+  if (feedback.length < MIN_CALIBRATION_SAMPLES) return null;
+  const accepted = feedback.filter((f) => f.accepted);
+  const rejected = feedback.filter((f) => !f.accepted);
+  if (rejected.length === 0) {
+    const minAccepted = Math.min(...accepted.map((f) => f.similarity));
+    return Math.max(0.85, minAccepted - 5e-3);
+  }
+  if (accepted.length === 0) {
+    warn("dedup calibration: all feedback is reject \u2014 keeping default threshold");
+    return null;
+  }
+  const allSims = [...new Set(feedback.map((f) => f.similarity))].sort((a, b) => a - b);
+  let bestThreshold = DEFAULT_EMBEDDING_DEDUP_THRESHOLD;
+  let bestAccuracy = -1;
+  for (let i = 0; i < allSims.length - 1; i++) {
+    const candidate = (allSims[i] + allSims[i + 1]) / 2;
+    const correctAccepted = accepted.filter((f) => f.similarity >= candidate).length;
+    const correctRejected = rejected.filter((f) => f.similarity < candidate).length;
+    const accuracy = (correctAccepted + correctRejected) / feedback.length;
+    if (accuracy > bestAccuracy || accuracy === bestAccuracy && candidate > bestThreshold) {
+      bestAccuracy = accuracy;
+      bestThreshold = candidate;
+    }
+  }
+  return Math.max(0.85, Math.min(0.98, bestThreshold));
+}
+function saveCalibratedThreshold(projectId2, threshold, sampleSize) {
+  const key = `dedup_threshold:${projectId2 ?? "global"}`;
+  setKV(key, JSON.stringify({ threshold, sampleSize, calibratedAt: Date.now() }));
+}
+function loadCalibratedThreshold(projectId2) {
+  const key = `dedup_threshold:${projectId2 ?? "global"}`;
+  const raw = getKV(key);
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    return typeof parsed.threshold === "number" ? parsed.threshold : null;
+  } catch {
+    return null;
+  }
 }
 
 // src/data.ts
@@ -29523,6 +29980,16 @@ function getSessionState(sessionID) {
   if (!state) {
     state = makeSessionState();
     state.forceMinLayer = loadForceMinLayer(sessionID);
+    const persisted = loadSessionTracking(sessionID);
+    if (persisted && persisted.lastTurnAt > 0) {
+      state.dynamicContextCap = persisted.dynamicContextCap;
+      state.bustRateEMA = persisted.bustRateEMA;
+      state.interBustIntervalEMA = persisted.interBustIntervalEMA;
+      state.lastLayer = persisted.lastLayer;
+      state.lastKnownInput = persisted.lastKnownInput;
+      state.lastTurnAt = persisted.lastTurnAt;
+      state.lastBustAt = persisted.lastBustAt;
+    }
     sessionStates.set(sessionID, state);
   }
   return state;
@@ -29628,6 +30095,19 @@ function inspectSessionState(sessionID) {
 function setLastTurnAtForTest(sessionID, ms) {
   getSessionState(sessionID).lastTurnAt = ms;
 }
+function saveGradientState(sessionID) {
+  const state = sessionStates.get(sessionID);
+  if (!state) return;
+  saveSessionTracking(sessionID, {
+    dynamicContextCap: state.dynamicContextCap,
+    bustRateEMA: state.bustRateEMA,
+    interBustIntervalEMA: state.interBustIntervalEMA,
+    lastLayer: state.lastLayer,
+    lastKnownInput: state.lastKnownInput,
+    lastTurnAt: state.lastTurnAt,
+    lastBustAt: state.lastBustAt
+  });
+}
 function loadDistillations(projectPath, sessionID) {
   const pid = ensureProject(projectPath);
   const query = sessionID ? "SELECT id, observations, generation, token_count, created_at, session_id FROM distillations WHERE project_id = ? AND session_id = ? AND archived = 0 ORDER BY created_at ASC" : "SELECT id, observations, generation, token_count, created_at, session_id FROM distillations WHERE project_id = ? AND archived = 0 ORDER BY created_at ASC";
@@ -29912,6 +30392,26 @@ function buildPrefixMessages(formatted) {
     }
   ];
 }
+var DECISION_RE = /\b(?:decision|decided|chose|chosen|agreed)\b/i;
+var GOTCHA_RE = /\b(?:gotcha|(?:critical|known|subtle)\s+bug|broken|crash(?:ed|es)?|regression)\b/i;
+var ARCH_RE = /\b(?:architecture|design.(?:decision|pattern)|system.design)\b/i;
+function importanceBonus(d) {
+  let bonus = 0;
+  if (DECISION_RE.test(d.observations)) bonus += 0.3;
+  if (GOTCHA_RE.test(d.observations)) bonus += 0.2;
+  if (ARCH_RE.test(d.observations)) bonus += 0.1;
+  if (d.generation >= 1) bonus += 0.2;
+  return Math.min(bonus, 1);
+}
+function selectDistillations(all3, limit) {
+  if (all3.length <= limit) return all3;
+  const maxIdx = all3.length - 1;
+  const scored = all3.map((d, i) => ({
+    d,
+    score: (maxIdx > 0 ? i / maxIdx : 1) * 0.7 + importanceBonus(d) * 0.3
+  }));
+  return scored.sort((a, b) => b.score - a.score).slice(0, limit).map((s) => s.d).sort((a, b) => a.created_at - b.created_at);
+}
 function distilledPrefix(distillations) {
   if (!distillations.length) return [];
   const formatted = formatDistillations(distillations);
@@ -30029,6 +30529,11 @@ function tryFitStable(input) {
   }
   return result;
 }
+var COMPRESSION_STAGES = [
+  { strip: "none", rawFrac: null, distFrac: null, distLimit: Infinity, protectedTurns: 0, useStableWindow: true },
+  { strip: "old-tools", rawFrac: 0.5, distFrac: null, distLimit: Infinity, protectedTurns: 2, useStableWindow: false },
+  { strip: "all-tools", rawFrac: 0.55, distFrac: 0.15, distLimit: 5, protectedTurns: 0, useStableWindow: false }
+];
 var urgentDistillationMap = /* @__PURE__ */ new Map();
 function needsUrgentDistillation(sessionID) {
   const v = urgentDistillationMap.get(sessionID) ?? false;
@@ -30060,7 +30565,7 @@ function transformInner(input) {
     if (calibrated) return true;
     return result.totalTokens * UNCALIBRATED_SAFETY <= maxInput;
   }
-  if (calibrated && sessState.lastLayer >= 1 && input.messages.length >= sessState.lastKnownMessageCount) {
+  if (calibrated && sessState.lastLayer >= 1 && sessState.lastLayer <= 3 && input.messages.length >= sessState.lastKnownMessageCount) {
     effectiveMinLayer = Math.max(effectiveMinLayer, sessState.lastLayer);
   }
   const postIdleCompact = sessState.postIdleCompact;
@@ -30098,7 +30603,8 @@ function transformInner(input) {
       totalTokens: Math.max(0, messageTokens),
       usable,
       distilledBudget,
-      rawBudget
+      rawBudget,
+      refreshLtm: false
     };
   }
   const turnStart = currentTurnStart(input.messages);
@@ -30108,67 +30614,52 @@ function transformInner(input) {
     const msgs = distilledPrefix(distillations);
     return { messages: msgs, tokens: msgs.reduce((sum, m) => sum + estimateMessage(m), 0) };
   })();
-  if (effectiveMinLayer <= 1) {
-    const layer1 = sid ? tryFitStable({
-      messages: dedupMessages,
-      prefix: cached2.messages,
-      prefixTokens: cached2.tokens,
-      distilledBudget,
-      rawBudget,
-      sessionID: sid,
-      sessState
-    }) : tryFit({
-      messages: dedupMessages,
-      prefix: cached2.messages,
-      prefixTokens: cached2.tokens,
-      distilledBudget,
-      rawBudget,
-      strip: "none"
-    });
-    if (fitsWithSafetyMargin(layer1)) {
-      if (cached2.tokens === 0 && sid) {
+  for (let s = 0; s < COMPRESSION_STAGES.length; s++) {
+    const stageLayer = s + 1;
+    if (effectiveMinLayer > stageLayer) continue;
+    const stage = COMPRESSION_STAGES[s];
+    const stageRawBudget = stage.rawFrac !== null ? Math.floor(usable * stage.rawFrac) : rawBudget;
+    const stageDistBudget = stage.distFrac !== null ? Math.floor(usable * stage.distFrac) : distilledBudget;
+    let stagePrefix = cached2.messages;
+    let stagePrefixTokens = cached2.tokens;
+    if (stage.distLimit !== Infinity && distillations.length > stage.distLimit) {
+      const trimmed = selectDistillations(distillations, stage.distLimit);
+      stagePrefix = distilledPrefix(trimmed);
+      stagePrefixTokens = stagePrefix.reduce((sum, m) => sum + estimateMessage(m), 0);
+    }
+    let result;
+    if (stage.useStableWindow && sid) {
+      result = tryFitStable({
+        messages: dedupMessages,
+        prefix: stagePrefix,
+        prefixTokens: stagePrefixTokens,
+        distilledBudget: stageDistBudget,
+        rawBudget: stageRawBudget,
+        sessionID: sid,
+        sessState
+      });
+    } else {
+      sessState.rawWindowCache = null;
+      result = tryFit({
+        messages: dedupMessages,
+        prefix: stagePrefix,
+        prefixTokens: stagePrefixTokens,
+        distilledBudget: stageDistBudget,
+        rawBudget: stageRawBudget,
+        strip: stage.strip,
+        protectedTurns: stage.protectedTurns
+      });
+    }
+    if (fitsWithSafetyMargin(result)) {
+      if (sid && (s > 0 || cached2.tokens === 0)) {
         urgentDistillationMap.set(sid, true);
       }
-      return { ...layer1, layer: 1, usable, distilledBudget, rawBudget };
+      return { ...result, layer: stageLayer, usable, distilledBudget, rawBudget, refreshLtm: false };
     }
   }
   sessState.rawWindowCache = null;
-  if (effectiveMinLayer <= 2) {
-    const layer2 = tryFit({
-      messages: dedupMessages,
-      prefix: cached2.messages,
-      prefixTokens: cached2.tokens,
-      distilledBudget,
-      rawBudget: Math.floor(usable * 0.5),
-      // give raw more room
-      strip: "old-tools",
-      protectedTurns: 2
-    });
-    if (fitsWithSafetyMargin(layer2)) {
-      if (sid) urgentDistillationMap.set(sid, true);
-      return { ...layer2, layer: 2, usable, distilledBudget, rawBudget };
-    }
-  }
-  const trimmedDistillations = distillations.slice(-5);
-  const trimmedPrefix = distilledPrefix(trimmedDistillations);
-  const trimmedPrefixTokens = trimmedPrefix.reduce(
-    (sum, m) => sum + estimateMessage(m),
-    0
-  );
-  const layer3 = tryFit({
-    messages: dedupMessages,
-    prefix: trimmedPrefix,
-    prefixTokens: trimmedPrefixTokens,
-    distilledBudget: Math.floor(usable * 0.15),
-    rawBudget: Math.floor(usable * 0.55),
-    strip: "all-tools"
-  });
-  if (fitsWithSafetyMargin(layer3)) {
-    if (sid) urgentDistillationMap.set(sid, true);
-    return { ...layer3, layer: 3, usable, distilledBudget, rawBudget };
-  }
   if (sid) urgentDistillationMap.set(sid, true);
-  const nuclearDistillations = distillations.slice(-2);
+  const nuclearDistillations = selectDistillations(distillations, 2);
   const nuclearPrefix = distilledPrefix(nuclearDistillations);
   const nuclearPrefixTokens = nuclearPrefix.reduce(
     (sum, m) => sum + estimateMessage(m),
@@ -30207,7 +30698,8 @@ function transformInner(input) {
     totalTokens: nuclearPrefixTokens + nuclearRawTokens,
     usable,
     distilledBudget,
-    rawBudget
+    rawBudget,
+    refreshLtm: true
   };
 }
 function transform2(input) {
@@ -30314,6 +30806,185 @@ function isWorkerSession(sessionID) {
   return workerSessionIDs.has(sessionID);
 }
 
+// ../../node_modules/.bun/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
+var Node = class {
+  value;
+  next;
+  constructor(value) {
+    this.value = value;
+  }
+};
+var Queue = class {
+  #head;
+  #tail;
+  #size;
+  constructor() {
+    this.clear();
+  }
+  enqueue(value) {
+    const node2 = new Node(value);
+    if (this.#head) {
+      this.#tail.next = node2;
+      this.#tail = node2;
+    } else {
+      this.#head = node2;
+      this.#tail = node2;
+    }
+    this.#size++;
+  }
+  dequeue() {
+    const current2 = this.#head;
+    if (!current2) {
+      return;
+    }
+    this.#head = this.#head.next;
+    this.#size--;
+    if (!this.#head) {
+      this.#tail = void 0;
+    }
+    return current2.value;
+  }
+  peek() {
+    if (!this.#head) {
+      return;
+    }
+    return this.#head.value;
+  }
+  clear() {
+    this.#head = void 0;
+    this.#tail = void 0;
+    this.#size = 0;
+  }
+  get size() {
+    return this.#size;
+  }
+  *[Symbol.iterator]() {
+    let current2 = this.#head;
+    while (current2) {
+      yield current2.value;
+      current2 = current2.next;
+    }
+  }
+  *drain() {
+    while (this.#head) {
+      yield this.dequeue();
+    }
+  }
+};
+
+// ../../node_modules/.bun/p-limit@7.3.0/node_modules/p-limit/index.js
+function pLimit(concurrency) {
+  let rejectOnClear = false;
+  if (typeof concurrency === "object") {
+    ({ concurrency, rejectOnClear = false } = concurrency);
+  }
+  validateConcurrency(concurrency);
+  if (typeof rejectOnClear !== "boolean") {
+    throw new TypeError("Expected `rejectOnClear` to be a boolean");
+  }
+  const queue = new Queue();
+  let activeCount = 0;
+  const resumeNext = () => {
+    if (activeCount < concurrency && queue.size > 0) {
+      activeCount++;
+      queue.dequeue().run();
+    }
+  };
+  const next = () => {
+    activeCount--;
+    resumeNext();
+  };
+  const run3 = async (function_, resolve, arguments_) => {
+    const result = (async () => function_(...arguments_))();
+    resolve(result);
+    try {
+      await result;
+    } catch {
+    }
+    next();
+  };
+  const enqueue = (function_, resolve, reject, arguments_) => {
+    const queueItem = { reject };
+    new Promise((internalResolve) => {
+      queueItem.run = internalResolve;
+      queue.enqueue(queueItem);
+    }).then(run3.bind(void 0, function_, resolve, arguments_));
+    if (activeCount < concurrency) {
+      resumeNext();
+    }
+  };
+  const generator = (function_, ...arguments_) => new Promise((resolve, reject) => {
+    enqueue(function_, resolve, reject, arguments_);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value() {
+        if (!rejectOnClear) {
+          queue.clear();
+          return;
+        }
+        const abortError = AbortSignal.abort().reason;
+        while (queue.size > 0) {
+          queue.dequeue().reject(abortError);
+        }
+      }
+    },
+    concurrency: {
+      get: () => concurrency,
+      set(newConcurrency) {
+        validateConcurrency(newConcurrency);
+        concurrency = newConcurrency;
+        queueMicrotask(() => {
+          while (activeCount < concurrency && queue.size > 0) {
+            resumeNext();
+          }
+        });
+      }
+    },
+    map: {
+      async value(iterable, function_) {
+        const promises = Array.from(iterable, (value, index2) => this(function_, value, index2));
+        return Promise.all(promises);
+      }
+    }
+  });
+  return generator;
+}
+function validateConcurrency(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+}
+
+// src/session-limiter.ts
+function createLimiterPool() {
+  const limiters = /* @__PURE__ */ new Map();
+  function get2(key) {
+    let limiter = limiters.get(key);
+    if (!limiter) {
+      limiter = pLimit(1);
+      limiters.set(key, limiter);
+    }
+    return limiter;
+  }
+  function isBusy(key) {
+    const limiter = limiters.get(key);
+    return limiter ? limiter.activeCount + limiter.pendingCount > 0 : false;
+  }
+  function clear() {
+    limiters.clear();
+  }
+  return { get: get2, isBusy, clear };
+}
+var distillLimiter = createLimiterPool();
+var curatorLimiter = createLimiterPool();
+
 // src/distillation.ts
 function compressionRatio(distilledTokens, sourceTokens) {
   if (sourceTokens <= 0) return 0;
@@ -30558,6 +31229,9 @@ function resetOrphans(projectPath, sessionID) {
   return orphans.length;
 }
 async function run(input) {
+  return distillLimiter.get(input.sessionID)(() => runInner(input));
+}
+async function runInner(input) {
   const orphans = resetOrphans(input.projectPath, input.sessionID);
   if (orphans > 0) {
     info(
@@ -30601,7 +31275,7 @@ async function run(input) {
       }
     }
     if (!input.skipMeta && gen0Count(input.projectPath, input.sessionID) >= cfg.distillation.metaThreshold) {
-      await metaDistill({
+      await metaDistillInner({
         llm: input.llm,
         projectPath: input.projectPath,
         sessionID: input.sessionID,
@@ -30651,17 +31325,25 @@ async function distillSegment(input) {
     );
     return null;
   }
-  const distillId = storeDistillation({
-    projectPath: input.projectPath,
-    sessionID: input.sessionID,
-    observations: result.observations,
-    sourceIDs: input.messages.map((m) => m.id),
-    generation: 0,
-    rCompression: rComp,
-    cNorm,
-    callType: input.callType
-  });
-  markDistilled(input.messages.map((m) => m.id));
+  let distillId;
+  db().exec("BEGIN IMMEDIATE");
+  try {
+    distillId = storeDistillation({
+      projectPath: input.projectPath,
+      sessionID: input.sessionID,
+      observations: result.observations,
+      sourceIDs: input.messages.map((m) => m.id),
+      generation: 0,
+      rCompression: rComp,
+      cNorm,
+      callType: input.callType
+    });
+    markDistilled(input.messages.map((m) => m.id));
+    db().exec("COMMIT");
+  } catch (e) {
+    db().exec("ROLLBACK");
+    throw e;
+  }
   info(
     `distill segment: ${input.messages.length} msgs, ${sourceTokens}\u2192${distilledTokens} tokens, R=${rComp.toFixed(2)}, C_norm=${cNorm.toFixed(3)}`
   );
@@ -30695,6 +31377,9 @@ async function distillSegment(input) {
   return result;
 }
 async function metaDistill(input) {
+  return distillLimiter.get(input.sessionID)(() => metaDistillInner(input));
+}
+async function metaDistillInner(input) {
   const existing = loadGen0(input.projectPath, input.sessionID);
   const priorMeta = latestMeta(input.projectPath, input.sessionID);
   if (priorMeta) {
@@ -30994,11 +31679,27 @@ function applyOps(ops, input) {
   return { created, updated, deleted };
 }
 var lastCuratedAt = /* @__PURE__ */ new Map();
+function getLastCuratedAt(sessionID) {
+  const cached2 = lastCuratedAt.get(sessionID);
+  if (cached2 !== void 0) return cached2;
+  const persisted = loadSessionTracking(sessionID);
+  const ts = persisted?.lastCuratedAt ?? 0;
+  lastCuratedAt.set(sessionID, ts);
+  return ts;
+}
 async function run2(input) {
   const cfg = config2();
   if (!cfg.curator.enabled) return { created: 0, updated: 0, deleted: 0 };
+  if (curatorLimiter.isBusy(input.sessionID)) {
+    info(`curation skipped: already running for session ${input.sessionID.slice(0, 16)}`);
+    return { created: 0, updated: 0, deleted: 0 };
+  }
+  return curatorLimiter.get(input.sessionID)(() => runInner2(input));
+}
+async function runInner2(input) {
+  const cfg = config2();
   const all3 = bySession(input.projectPath, input.sessionID);
-  const sessionCuratedAt = lastCuratedAt.get(input.sessionID) ?? 0;
+  const sessionCuratedAt = getLastCuratedAt(input.sessionID);
   const recent = all3.filter((m) => m.created_at > sessionCuratedAt);
   if (recent.length < 3) return { created: 0, updated: 0, deleted: 0 };
   const text4 = recent.map((m) => `[${m.role}] ${m.content}`).join("\n\n");
@@ -31042,11 +31743,22 @@ async function run2(input) {
         info(`post-curation dedup: merged ${dupes.totalRemoved} duplicate entries`);
         result.deleted += dupes.totalRemoved;
       }
+      if (dupes.pairSimilarities.size > 0) {
+        const pid = ensureProject(input.projectPath);
+        recordAutoSignals(pid, dupes);
+        const newThreshold = calibrateDedupThreshold(pid);
+        if (newThreshold !== null) {
+          const count3 = getDedupFeedbackCount(pid);
+          saveCalibratedThreshold(pid, newThreshold, count3);
+        }
+      }
     } catch (err) {
       warn("post-curation dedup failed (non-fatal):", err);
     }
   }
-  lastCuratedAt.set(input.sessionID, Date.now());
+  const now = Date.now();
+  lastCuratedAt.set(input.sessionID, now);
+  saveSessionTracking(input.sessionID, { lastCuratedAt: now });
   return result;
 }
 function resetCurationTracker(sessionID) {
@@ -33169,6 +33881,7 @@ export {
   ftsQueryRelaxed,
   getGitRemote,
   getInstanceId,
+  getKV,
   getLastImportAt,
   getLastTransformEstimate,
   getLastTransformedCount,
@@ -33194,7 +33907,9 @@ export {
   load,
   loadAllSessionCosts,
   loadForceMinLayer,
+  loadHeaderSessionIndex,
   loadSessionCosts,
+  loadSessionTracking,
   log_exports as log,
   loreFileExists,
   ltm_exports as ltm,
@@ -33215,10 +33930,13 @@ export {
   runRecall,
   sanitizeSurrogates,
   saveForceMinLayer,
+  saveGradientState,
   saveSessionCosts,
+  saveSessionTracking,
   searchRecall,
   serialize,
   setForceMinLayer,
+  setKV,
   setLastImportAt,
   setLastTurnAtForTest,
   setLtmTokens,