@loreai/core 0.12.0 → 0.13.0

package/dist/node/index.js

@@ -163,6 +163,7 @@ function sha256(input) {
 // src/db.ts
 import { join, dirname } from "path";
 import { mkdirSync } from "fs";
+import { homedir } from "os";
 var MIGRATIONS = [
   `
   -- Version 1: Initial schema
@@ -491,11 +492,27 @@ var MIGRATIONS = [
   )
   WHERE content LIKE '%' || char(10) || '[tool:%'
      OR content LIKE '%' || char(10) || '[reasoning] %';
+  `,
+  `
+  -- Version 12: Context health diagnostic columns on distillations.
+  --
+  -- r_compression: k/\u221AN where k = distilled token count, N = source token
+  -- count. Values < 1.0 signal likely lossy compression. NULL for rows
+  -- created before this migration or for meta-distillations (gen > 0)
+  -- where the metric is not computed.
+  --
+  -- c_norm: normalized variance of relative-existence weights over source
+  -- message timestamps. Range [0, 1]; 0 = uniform distribution, 1 = attention
+  -- dominated by distant past. NULL for pre-migration rows or meta-distillations.
+  --
+  -- Both columns are nullable REALs \u2014 cheap to add, no backfill needed.
+  ALTER TABLE distillations ADD COLUMN r_compression REAL;
+  ALTER TABLE distillations ADD COLUMN c_norm REAL;
   `
 ];
 function dataDir() {
   const xdg = process.env.XDG_DATA_HOME;
-  const base = xdg || join(process.env.HOME || "~", ".local", "share");
+  const base = xdg || join(homedir(), ".local", "share");
   return join(base, "opencode-lore");
 }
 var instance;
@@ -11291,14 +11308,24 @@ function reciprocalRankFusion(lists, k = 60) {
   }
   return [...scores.values()].sort((a, b) => b.score - a.score);
 }
-async function expandQuery(llm, query, model) {
+function exactTermMatchRank(items, getText, query) {
+  const terms = filterTerms(query).map((t2) => t2.toLowerCase());
+  if (!terms.length) return [];
+  const scored = items.map((item) => {
+    const text4 = getText(item).toLowerCase();
+    const matches = terms.filter((t2) => text4.includes(t2)).length;
+    return { item, matches };
+  }).filter((s) => s.matches > 0).sort((a, b) => b.matches - a.matches);
+  return scored.map((s) => s.item);
+}
+async function expandQuery(llm, query, model, sessionID) {
   const TIMEOUT_MS = 3e3;
   try {
     const responseText = await Promise.race([
       llm.prompt(
         QUERY_EXPANSION_SYSTEM,
         `Input: "${query}"`,
-        { model, workerID: "lore-query-expand" }
+        { model, workerID: "lore-query-expand", thinking: false, urgent: true, sessionID }
       ),
       new Promise((resolve) => setTimeout(() => resolve(null), TIMEOUT_MS))
     ]);
@@ -25708,11 +25735,15 @@ var LoreConfig = external_exports.object({
    * Anthropic's April 23 postmortem identified dropping reasoning blocks as
    * the root cause of forgetfulness/repetition.
    *
-   * `idleResumeMinutes` is the threshold in minutes. Default 60 — matches
-   * Anthropic's extended-cache eviction window, conservative across providers.
+   * `idleResumeMinutes` is the threshold in minutes. Default 5 — matches
+   * Anthropic's default-tier prompt cache TTL. After 5 min of inactivity the
+   * upstream cache is cold, so preserving byte-identity wastes cache-write cost
+   * for no benefit. Refreshing the caches on resume produces a better-fitting
+   * window at the same cold-write price. Users on Anthropic's extended-cache
+   * tier (1 h TTL) should set this to 60 in `.lore.json`.
    * Set to 0 to disable the feature.
    */
-  idleResumeMinutes: external_exports.number().min(0).max(24 * 60).default(60),
+  idleResumeMinutes: external_exports.number().min(0).max(24 * 60).default(5),
   distillation: external_exports.object({
     minMessages: external_exports.number().min(3).default(5),
     maxSegment: external_exports.number().min(5).default(30),
@@ -25763,34 +25794,37 @@ var LoreConfig = external_exports.object({
      *  before search, improving recall for ambiguous queries. */
     queryExpansion: external_exports.boolean().default(false),
     /** Vector embedding search.
-     *  Supports multiple providers: "voyage" (Voyage AI, VOYAGE_API_KEY),
-     *  "openai" (OpenAI, OPENAI_API_KEY).
-     *  Automatically enabled when the configured provider's API key env var is set.
-     *  Set enabled: false to explicitly disable even with the key present. */
+     *  Supports multiple providers:
+     *  - "local" (default): fastembed + ONNX Runtime, no API key needed.
+     *    Uses bge-small-en-v1.5 (384 dims). Model downloaded on first use (~33MB),
+     *    cached in ~/.cache/fastembed. ~150ms per query embed.
+     *  - "voyage": Voyage AI (VOYAGE_API_KEY, voyage-code-3, 1024 dims)
+     *  - "openai": OpenAI (OPENAI_API_KEY, text-embedding-3-small, 1536 dims)
+     *  Set enabled: false to explicitly disable even with a provider available. */
     embeddings: external_exports.object({
       /** Enable/disable vector embedding search. Default: true.
-       *  Set to false to explicitly disable even when the API key is set. */
+       *  Set to false to explicitly disable. */
       enabled: external_exports.boolean().default(true),
-      /** Embedding provider. Default: "voyage".
-       *  Each provider reads its own env var for the API key:
+      /** Embedding provider. Default: "local".
+       *  - "local": fastembed + ONNX Runtime, no API key (default model: bge-small-en-v1.5, 384 dims)
        *  - "voyage": VOYAGE_API_KEY (default model: voyage-code-3, 1024 dims)
        *  - "openai": OPENAI_API_KEY (default model: text-embedding-3-small, 1536 dims) */
-      provider: external_exports.enum(["voyage", "openai"]).default("voyage"),
+      provider: external_exports.enum(["local", "voyage", "openai"]).default("local"),
       /** Model ID for the embedding provider. Default depends on provider. */
-      model: external_exports.string().default("voyage-code-3"),
-      /** Embedding dimensions. Default: 1024. */
-      dimensions: external_exports.number().min(256).max(2048).default(1024)
+      model: external_exports.string().default("BGESmallENV15"),
+      /** Embedding dimensions. Default: 384 (local) / 1024 (voyage) / 1536 (openai). */
+      dimensions: external_exports.number().min(64).max(2048).default(384)
     }).default({
       enabled: true,
-      provider: "voyage",
-      model: "voyage-code-3",
-      dimensions: 1024
+      provider: "local",
+      model: "BGESmallENV15",
+      dimensions: 384
     })
   }).default({
     ftsWeights: { title: 6, content: 2, category: 3 },
     recallLimit: 10,
     queryExpansion: false,
-    embeddings: { enabled: true, provider: "voyage", model: "voyage-code-3", dimensions: 1024 }
+    embeddings: { enabled: true, provider: "local", model: "BGESmallENV15", dimensions: 384 }
   }),
   crossProject: external_exports.boolean().default(false),
   agentsFile: external_exports.object({
@@ -25828,6 +25862,7 @@ __export(embedding_exports, {
   fromBlob: () => fromBlob,
   isAvailable: () => isAvailable,
   resetProvider: () => resetProvider,
+  runStartupBackfill: () => runStartupBackfill,
   toBlob: () => toBlob,
   vectorSearch: () => vectorSearch,
   vectorSearchDistillations: () => vectorSearchDistillations
@@ -25905,9 +25940,43 @@ var OpenAIProvider = class {
     return sorted.map((d) => new Float32Array(d.embedding));
   }
 };
-var PROVIDER_DEFAULTS = {
-  voyage: { model: "voyage-code-3", dimensions: 1024 },
-  openai: { model: "text-embedding-3-small", dimensions: 1536 }
+var LocalProvider = class {
+  maxBatchSize = 256;
+  model = null;
+  initPromise = null;
+  modelName;
+  constructor(modelName) {
+    this.modelName = modelName;
+  }
+  async getModel() {
+    if (this.model) return this.model;
+    if (!this.initPromise) {
+      this.initPromise = (async () => {
+        const { EmbeddingModel, FlagEmbedding } = await import("fastembed");
+        const enumValue = EmbeddingModel[this.modelName];
+        const m = await FlagEmbedding.init({
+          model: enumValue ?? this.modelName
+        });
+        this.model = m;
+        return m;
+      })();
+    }
+    return this.initPromise;
+  }
+  async embed(texts, inputType) {
+    const model = await this.getModel();
+    if (inputType === "query" && texts.length === 1) {
+      const vec = await model.queryEmbed(texts[0]);
+      return [new Float32Array(vec)];
+    }
+    const results = [];
+    for await (const batch of model.passageEmbed(texts)) {
+      for (const vec of batch) {
+        results.push(new Float32Array(vec));
+      }
+    }
+    return results;
+  }
 };
 var PROVIDER_ENV_KEYS = {
   voyage: "VOYAGE_API_KEY",
@@ -25926,21 +25995,35 @@ function getProvider() {
     return null;
   }
   const providerName = cfg.provider;
-  const apiKey = getProviderApiKey(providerName);
-  if (!apiKey) {
-    cachedProvider = null;
-    return null;
-  }
-  const defaults = PROVIDER_DEFAULTS[providerName];
-  const model = cfg.model === defaults?.model ? cfg.model : cfg.model;
-  const dimensions = cfg.dimensions;
+  const model = cfg.model;
   switch (providerName) {
-    case "voyage":
-      cachedProvider = new VoyageProvider(apiKey, model, dimensions);
+    case "local": {
+      try {
+        cachedProvider = new LocalProvider(model);
+      } catch {
+        info("local embedding provider unavailable (fastembed not installed)");
+        cachedProvider = null;
+      }
       break;
-    case "openai":
-      cachedProvider = new OpenAIProvider(apiKey, model, dimensions);
+    }
+    case "voyage": {
+      const apiKey = getProviderApiKey(providerName);
+      if (!apiKey) {
+        cachedProvider = null;
+        return null;
+      }
+      cachedProvider = new VoyageProvider(apiKey, model, cfg.dimensions);
+      break;
+    }
+    case "openai": {
+      const apiKey = getProviderApiKey(providerName);
+      if (!apiKey) {
+        cachedProvider = null;
+        return null;
+      }
+      cachedProvider = new OpenAIProvider(apiKey, model, cfg.dimensions);
       break;
+    }
     default:
       info(`unknown embedding provider: ${providerName}`);
       cachedProvider = null;
@@ -26045,6 +26128,29 @@ function checkConfigChange() {
   ).run(EMBEDDING_CONFIG_KEY, current2, current2);
   return true;
 }
+async function runStartupBackfill() {
+  if (!isAvailable()) return;
+  const knowledgeEmbedded = await backfillEmbeddings();
+  const distillationEmbedded = await backfillDistillationEmbeddings();
+  const kTotal = db().query("SELECT COUNT(*) as n FROM knowledge WHERE confidence > 0.2").get().n;
+  const kWithEmb = db().query(
+    "SELECT COUNT(*) as n FROM knowledge WHERE embedding IS NOT NULL AND confidence > 0.2"
+  ).get().n;
+  const dTotal = db().query(
+    "SELECT COUNT(*) as n FROM distillations WHERE archived = 0 AND observations != ''"
+  ).get().n;
+  const dWithEmb = db().query(
+    "SELECT COUNT(*) as n FROM distillations WHERE embedding IS NOT NULL AND archived = 0"
+  ).get().n;
+  const parts = [];
+  if (knowledgeEmbedded > 0 || distillationEmbedded > 0) {
+    parts.push(`backfilled ${knowledgeEmbedded} knowledge + ${distillationEmbedded} distillations`);
+  }
+  parts.push(
+    `coverage: knowledge ${kWithEmb}/${kTotal}, distillations ${dWithEmb}/${dTotal}`
+  );
+  info(`embedding startup: ${parts.join("; ")}`);
+}
 async function backfillEmbeddings() {
   checkConfigChange();
   const provider = getProvider();
@@ -26801,6 +26907,7 @@ function check2(projectPath) {
 // src/distillation.ts
 var distillation_exports = {};
 __export(distillation_exports, {
+  backfillMetrics: () => backfillMetrics,
   compressionRatio: () => compressionRatio,
   detectSegments: () => detectSegments,
   latestMetaObservations: () => latestMetaObservations,
@@ -26813,6 +26920,72 @@ __export(distillation_exports, {
   workerSessionIDs: () => workerSessionIDs
 });
 
+// src/pattern-extract.ts
+var pattern_extract_exports = {};
+__export(pattern_extract_exports, {
+  extractPatterns: () => extractPatterns
+});
+var PATTERNS = [
+  // Decision patterns
+  {
+    regex: /decided to (?:use |switch to |go with |adopt )(.+?)(?:\.|,|$)/gi,
+    category: "decision",
+    titleFn: (m) => `Decided to use ${m[1].trim()}`
+  },
+  {
+    regex: /chose (.+?) over (.+?)(?:\.|,|$)/gi,
+    category: "decision",
+    titleFn: (m) => `Chose ${m[1].trim()} over ${m[2].trim()}`
+  },
+  {
+    regex: /switched from (.+?) to (.+?)(?:\.|,|$)/gi,
+    category: "decision",
+    titleFn: (m) => `Switched from ${m[1].trim()} to ${m[2].trim()}`
+  },
+  {
+    regex: /going with (.+?) (?:because|for|due to)(.+?)(?:\.|,|$)/gi,
+    category: "decision",
+    titleFn: (m) => `Going with ${m[1].trim()}`
+  },
+  {
+    regex: /migrat(?:ed|ing) (?:from .+? )?to (.+?)(?:\.|,|$)/gi,
+    category: "decision",
+    titleFn: (m) => `Migrated to ${m[1].trim()}`
+  },
+  {
+    regex: /adopted (.+?) (?:for|as|instead)(.+?)(?:\.|,|$)/gi,
+    category: "decision",
+    titleFn: (m) => `Adopted ${m[1].trim()}`
+  },
+  // Preference patterns
+  {
+    regex: /prefers? (.+?) (?:over|to|instead of|rather than) (.+?)(?:\.|,|$)/gi,
+    category: "preference",
+    titleFn: (m) => `Prefers ${m[1].trim()} over ${m[2].trim()}`
+  },
+  {
+    regex: /(?:user |team |we )(?:always |usually |typically )(?:use|prefer|go with) (.+?)(?:\.|,|$)/gi,
+    category: "preference",
+    titleFn: (m) => `Typically uses ${m[1].trim()}`
+  }
+];
+function extractPatterns(observations) {
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const { regex, category, titleFn } of PATTERNS) {
+    regex.lastIndex = 0;
+    let match;
+    while ((match = regex.exec(observations)) !== null) {
+      const title = titleFn(match);
+      const key = title.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      results.push({ category, title, content: match[0].trim() });
+    }
+  }
+  return results;
+}
+
 // src/gradient.ts
 function estimate2(text4) {
   return Math.ceil(text4.length / 3);
@@ -26848,12 +27021,17 @@ function makeSessionState() {
     lastWindowMessageIDs: /* @__PURE__ */ new Set(),
     forceMinLayer: 0,
     lastTransformEstimate: 0,
+    ltmTokens: 0,
     prefixCache: null,
     rawWindowCache: null,
     lastTurnAt: 0,
     cameOutOfIdle: false,
+    postIdleCompact: false,
     consecutiveHighLayer: 0,
-    lastPrefixHash: ""
+    lastPrefixHash: "",
+    bustCount: 0,
+    transformCount: 0,
+    distillationSnapshot: null
   };
 }
 var sessionStates = /* @__PURE__ */ new Map();
@@ -26874,16 +27052,21 @@ function onIdleResume(sessionID, thresholdMs, now = Date.now()) {
   if (idleMs < thresholdMs) return { triggered: false };
   state.prefixCache = null;
   state.rawWindowCache = null;
+  state.distillationSnapshot = null;
   state.cameOutOfIdle = true;
+  state.postIdleCompact = true;
   return { triggered: true, idleMs };
 }
+function getLastTurnAt(sessionID) {
+  return sessionStates.get(sessionID)?.lastTurnAt ?? 0;
+}
 function consumeCameOutOfIdle(sessionID) {
   const state = sessionStates.get(sessionID);
   if (!state || !state.cameOutOfIdle) return false;
   state.cameOutOfIdle = false;
   return true;
 }
-var ltmTokens = 0;
+var ltmTokensFallback = 0;
 function setModelLimits(limits) {
   contextLimit = limits.context || 2e5;
   outputReserved = Math.min(limits.output || 32e3, 32e3);
@@ -26896,11 +27079,18 @@ function computeLayer0Cap(targetCostPerTurn, cacheReadCostPerToken) {
   const rawCap = Math.floor(targetCostPerTurn / cacheReadCostPerToken);
   return Math.max(rawCap, MIN_LAYER0_FLOOR);
 }
-function setLtmTokens(tokens) {
-  ltmTokens = tokens;
+function setLtmTokens(tokens, sessionID) {
+  if (sessionID) {
+    getSessionState(sessionID).ltmTokens = tokens;
+  }
+  ltmTokensFallback = tokens;
 }
-function getLtmTokens() {
-  return ltmTokens;
+function getLtmTokens(sessionID) {
+  if (sessionID) {
+    const state = sessionStates.get(sessionID);
+    if (state) return state.ltmTokens;
+  }
+  return ltmTokensFallback;
 }
 function getLtmBudget(ltmFraction) {
   const overhead = calibratedOverhead ?? FIRST_TURN_OVERHEAD;
@@ -26916,7 +27106,7 @@ function calibrate(actualInput, sessionID, messageCount) {
   if (sessionID !== void 0) {
     const state = getSessionState(sessionID);
     state.lastKnownInput = actualInput;
-    state.lastKnownLtm = ltmTokens;
+    state.lastKnownLtm = state.ltmTokens;
     if (messageCount !== void 0) state.lastKnownMessageCount = messageCount;
   }
 }
@@ -26947,7 +27137,9 @@ function inspectSessionState(sessionID) {
     hasPrefixCache: state.prefixCache !== null,
     hasRawWindowCache: state.rawWindowCache !== null,
     cameOutOfIdle: state.cameOutOfIdle,
-    lastTurnAt: state.lastTurnAt
+    postIdleCompact: state.postIdleCompact,
+    lastTurnAt: state.lastTurnAt,
+    distillationSnapshot: state.distillationSnapshot
   };
 }
 function setLastTurnAtForTest(sessionID, ms) {
@@ -26959,6 +27151,25 @@ function loadDistillations(projectPath, sessionID) {
   const params = sessionID ? [pid, sessionID] : [pid];
   return db().query(query).all(...params);
 }
+function loadDistillationsCached(projectPath, sessionID, messages, sessState) {
+  let lastUserMsgId = null;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].info.role === "user") {
+      lastUserMsgId = messages[i].info.id;
+      break;
+    }
+  }
+  const snapshot = sessState.distillationSnapshot;
+  if (snapshot && snapshot.lastUserMsgId === lastUserMsgId) {
+    return snapshot.rows;
+  }
+  const rows = loadDistillations(projectPath, sessionID);
+  sessState.distillationSnapshot = { rows, lastUserMsgId };
+  info(
+    `distillation refresh: ${rows.length} rows (user msg ${lastUserMsgId?.substring(0, 16) ?? "none"})`
+  );
+  return rows;
+}
 function stripSystemReminders(text4) {
   return text4.replace(/<system-reminder>[\s\S]*?<\/system-reminder>\n?/g, (match) => {
     const inner = match.match(
@@ -27011,24 +27222,51 @@ function simpleHash(str) {
   }
   return hash2;
 }
-function extractFilePath(input) {
+function extractReadRange(input) {
   try {
     const parsed = JSON.parse(input);
-    return parsed.path || parsed.filePath || parsed.file;
+    const path = parsed.path || parsed.filePath || parsed.file;
+    if (!path) return void 0;
+    const offset = typeof parsed.offset === "number" ? parsed.offset : void 0;
+    const limit = typeof parsed.limit === "number" ? parsed.limit : void 0;
+    return { path, offset, limit };
   } catch {
     const match = input.match(/(?:[\w.-]+\/)+[\w.-]+\.\w{1,5}/);
-    return match?.[0];
+    if (!match) return void 0;
+    return { path: match[0], offset: void 0, limit: void 0 };
   }
 }
-function dedupAnnotation(toolName, filePath) {
+function laterReadCovers(later, earlier) {
+  if (later.path !== earlier.path) return false;
+  if (later.offset === void 0 && later.limit === void 0) return true;
+  if (earlier.offset === void 0 && earlier.limit === void 0) return false;
+  const laterStart = later.offset ?? 1;
+  const earlierStart = earlier.offset ?? 1;
+  if (later.limit === void 0) return laterStart <= earlierStart;
+  if (earlier.limit === void 0) return false;
+  const laterEnd = laterStart + later.limit;
+  const earlierEnd = earlierStart + earlier.limit;
+  return laterStart <= earlierStart && laterEnd >= earlierEnd;
+}
+function rangeLabel(range) {
+  if (range.offset !== void 0 && range.limit !== void 0) {
+    return ` lines ${range.offset}-${range.offset + range.limit - 1}`;
+  }
+  if (range.offset !== void 0) {
+    return ` from line ${range.offset}`;
+  }
+  return "";
+}
+function dedupAnnotation(toolName, filePath, range) {
   if (filePath) {
-    return `[earlier version of ${filePath} \u2014 see latest read below for current content]`;
+    const rl = range ? rangeLabel(range) : "";
+    return `[earlier read of ${filePath}${rl} \u2014 see latest read below for current content]`;
   }
   return `[duplicate output \u2014 same content as later ${toolName} in this session \u2014 use recall for details]`;
 }
 function deduplicateToolOutputs(messages, currentTurnIdx) {
   const contentLatest = /* @__PURE__ */ new Map();
-  const fileLatest = /* @__PURE__ */ new Map();
+  const fileReads = /* @__PURE__ */ new Map();
   for (let i = 0; i < messages.length; i++) {
     for (const part of messages[i].parts) {
       if (!isToolPart(part) || part.state.status !== "completed") continue;
@@ -27038,8 +27276,15 @@ function deduplicateToolOutputs(messages, currentTurnIdx) {
       contentLatest.set(key, i);
       if (part.tool === "read_file" || part.tool === "read") {
         const inputStr = typeof part.state.input === "string" ? part.state.input : JSON.stringify(part.state.input);
-        const fp = extractFilePath(inputStr);
-        if (fp) fileLatest.set(`read:${fp}`, i);
+        const range = extractReadRange(inputStr);
+        if (range) {
+          let entries = fileReads.get(range.path);
+          if (!entries) {
+            entries = [];
+            fileReads.set(range.path, entries);
+          }
+          entries.push({ range, msgIdx: i });
+        }
       }
     }
   }
@@ -27053,20 +27298,30 @@ function deduplicateToolOutputs(messages, currentTurnIdx) {
       if (!output || output.length < DEDUP_MIN_CHARS) return part;
       const contentKey = `${part.tool}:${simpleHash(output)}`;
       const isLatestContent = contentLatest.get(contentKey) === msgIdx;
-      let filePath;
-      let isLatestFile = true;
+      let readRange;
+      let coveredByLater = false;
       if (part.tool === "read_file" || part.tool === "read") {
         const inputStr = typeof part.state.input === "string" ? part.state.input : JSON.stringify(part.state.input);
-        filePath = extractFilePath(inputStr);
-        if (filePath) isLatestFile = fileLatest.get(`read:${filePath}`) === msgIdx;
+        readRange = extractReadRange(inputStr);
+        if (readRange) {
+          const entries = fileReads.get(readRange.path);
+          if (entries) {
+            for (const entry of entries) {
+              if (entry.msgIdx > msgIdx && laterReadCovers(entry.range, readRange)) {
+                coveredByLater = true;
+                break;
+              }
+            }
+          }
+        }
       }
-      if (isLatestContent && isLatestFile) return part;
+      if (isLatestContent && !coveredByLater) return part;
       partsChanged = true;
       return {
         ...part,
         state: {
           ...part.state,
-          output: dedupAnnotation(part.tool, filePath)
+          output: dedupAnnotation(part.tool, readRange?.path, readRange)
         }
       };
     });
@@ -27086,7 +27341,7 @@ function sanitizeToolParts(messages) {
       const { status } = part.state;
       if (status === "completed" || status === "error") return part;
       partsChanged = true;
-      const now = Date.now();
+      const existingStart = "time" in part.state ? part.state.time.start : 0;
       return {
         ...part,
         state: {
@@ -27095,8 +27350,8 @@ function sanitizeToolParts(messages) {
           error: "[tool execution interrupted \u2014 session recovered]",
           metadata: "metadata" in part.state ? part.state.metadata : void 0,
           time: {
-            start: "time" in part.state ? part.state.time.start : now,
-            end: now
+            start: existingStart,
+            end: existingStart
           }
         }
       };
@@ -27120,97 +27375,6 @@ function stripToolOutputs(parts) {
     };
   });
 }
-function formatRelativeTime(date5, now) {
-  const diffMs = now.getTime() - date5.getTime();
-  const diffDays = Math.floor(diffMs / (1e3 * 60 * 60 * 24));
-  if (diffDays === 0) return "today";
-  if (diffDays === 1) return "yesterday";
-  if (diffDays < 7) return `${diffDays} days ago`;
-  if (diffDays < 14) return "1 week ago";
-  if (diffDays < 30) return `${Math.floor(diffDays / 7)} weeks ago`;
-  if (diffDays < 60) return "1 month ago";
-  if (diffDays < 365) return `${Math.floor(diffDays / 30)} months ago`;
-  return `${Math.floor(diffDays / 365)} year${Math.floor(diffDays / 365) > 1 ? "s" : ""} ago`;
-}
-function parseDateFromContent(s) {
-  const simple = s.match(/([A-Z][a-z]+)\s+(\d{1,2}),?\s+(\d{4})/);
-  if (simple) {
-    const d = /* @__PURE__ */ new Date(`${simple[1]} ${simple[2]}, ${simple[3]}`);
-    if (!isNaN(d.getTime())) return d;
-  }
-  const range = s.match(/([A-Z][a-z]+)\s+(\d{1,2})-\d{1,2},?\s+(\d{4})/);
-  if (range) {
-    const d = /* @__PURE__ */ new Date(`${range[1]} ${range[2]}, ${range[3]}`);
-    if (!isNaN(d.getTime())) return d;
-  }
-  const vague = s.match(/(late|early|mid)[- ]?([A-Z][a-z]+)\s+(\d{4})/i);
-  if (vague) {
-    const day = vague[1].toLowerCase() === "early" ? 7 : vague[1].toLowerCase() === "late" ? 23 : 15;
-    const d = /* @__PURE__ */ new Date(`${vague[2]} ${day}, ${vague[3]}`);
-    if (!isNaN(d.getTime())) return d;
-  }
-  return null;
-}
-function expandInlineEstimatedDates(text4, now) {
-  return text4.replace(
-    /\(((?:meaning|estimated)\s+)([^)]+\d{4})\)/gi,
-    (match, prefix, dateContent) => {
-      const d = parseDateFromContent(dateContent);
-      if (!d) return match;
-      const rel = formatRelativeTime(d, now);
-      const matchIdx = text4.indexOf(match);
-      const lineStart = text4.lastIndexOf("\n", matchIdx) + 1;
-      const linePrefix = text4.slice(lineStart, matchIdx);
-      const isFutureIntent = /\b(?:will|plans?\s+to|planning\s+to|going\s+to|intends?\s+to)\b/i.test(
-        linePrefix
-      );
-      if (d < now && isFutureIntent)
-        return `(${prefix}${dateContent} \u2014 ${rel}, likely already happened)`;
-      return `(${prefix}${dateContent} \u2014 ${rel})`;
-    }
-  );
-}
-function addRelativeTimeToObservations(text4, now) {
-  const withInline = expandInlineEstimatedDates(text4, now);
-  const dateHeaderRe = /^(Date:\s*)([A-Z][a-z]+ \d{1,2}, \d{4})$/gm;
-  const found = [];
-  let m;
-  while ((m = dateHeaderRe.exec(withInline)) !== null) {
-    const d = new Date(m[2]);
-    if (!isNaN(d.getTime()))
-      found.push({
-        index: m.index,
-        date: d,
-        full: m[0],
-        prefix: m[1],
-        ds: m[2]
-      });
-  }
-  if (!found.length) return withInline;
-  let result = "";
-  let last = 0;
-  for (let i = 0; i < found.length; i++) {
-    const curr = found[i];
-    const prev = found[i - 1];
-    result += withInline.slice(last, curr.index);
-    if (prev) {
-      const gapDays = Math.floor(
-        (curr.date.getTime() - prev.date.getTime()) / 864e5
-      );
-      if (gapDays > 1) {
-        const gap = gapDays < 7 ? `[${gapDays} days later]` : gapDays < 14 ? "[1 week later]" : gapDays < 30 ? `[${Math.floor(gapDays / 7)} weeks later]` : gapDays < 60 ? "[1 month later]" : `[${Math.floor(gapDays / 30)} months later]`;
-        result += `
-${gap}
-
-`;
-      }
-    }
-    result += `${curr.prefix}${curr.ds} (${formatRelativeTime(curr.date, now)})`;
-    last = curr.index + curr.full.length;
-  }
-  result += withInline.slice(last);
-  return result;
-}
 function buildPrefixMessages(formatted) {
   return [
     {
@@ -27267,12 +27431,7 @@ function buildPrefixMessages(formatted) {
 }
 function distilledPrefix(distillations) {
   if (!distillations.length) return [];
-  const now = /* @__PURE__ */ new Date();
-  const annotated = distillations.map((d) => ({
-    ...d,
-    observations: addRelativeTimeToObservations(d.observations, now)
-  }));
-  const formatted = formatDistillations(annotated);
+  const formatted = formatDistillations(distillations);
   if (!formatted) return [];
   return buildPrefixMessages(formatted);
 }
@@ -27292,12 +27451,7 @@ function distilledPrefixCached(distillations, sessionID, sessState) {
       };
     }
     const newRows = distillations.slice(prefixCache.rowCount);
-    const now2 = /* @__PURE__ */ new Date();
-    const annotated2 = newRows.map((d) => ({
-      ...d,
-      observations: addRelativeTimeToObservations(d.observations, now2)
-    }));
-    const deltaText = formatDistillations(annotated2);
+    const deltaText = formatDistillations(newRows);
     if (deltaText) {
       const fullText2 = prefixCache.cachedText + "\n\n" + deltaText;
       const messages2 = buildPrefixMessages(fullText2);
@@ -27313,12 +27467,7 @@ function distilledPrefixCached(distillations, sessionID, sessState) {
       return { messages: messages2, tokens: tokens2 };
     }
   }
-  const now = /* @__PURE__ */ new Date();
-  const annotated = distillations.map((d) => ({
-    ...d,
-    observations: addRelativeTimeToObservations(d.observations, now)
-  }));
-  const fullText = formatDistillations(annotated);
+  const fullText = formatDistillations(distillations);
   if (!fullText) {
     sessState.prefixCache = null;
     return { messages: [], tokens: 0 };
@@ -27341,29 +27490,40 @@ function tryFitStable(input) {
   const rawWindowCache = input.sessState.rawWindowCache;
   const cacheValid = rawWindowCache !== null && rawWindowCache.sessionID === input.sessionID;
   if (cacheValid) {
-    const pinnedIdx = input.messages.findIndex(
-      (m) => m.info.id === rawWindowCache.firstMessageID
+    const newMessages = Math.max(0, input.messages.length - rawWindowCache.pinnedTotalCount);
+    const windowSize = rawWindowCache.pinnedRawCount + newMessages;
+    const pinnedIdx = Math.max(0, input.messages.length - windowSize);
+    const pinnedWindow = input.messages.slice(pinnedIdx);
+    const pinnedTokens = pinnedWindow.reduce(
+      (sum, m) => sum + estimateMessage(m),
+      0
     );
-    if (pinnedIdx !== -1) {
-      const pinnedWindow = input.messages.slice(pinnedIdx);
-      const pinnedTokens = pinnedWindow.reduce(
-        (sum, m) => sum + estimateMessage(m),
-        0
-      );
-      if (pinnedTokens <= input.rawBudget) {
-        const processed = pinnedWindow.map((msg) => {
-          const parts = cleanParts(msg.parts);
-          return parts !== msg.parts ? { info: msg.info, parts } : msg;
-        });
-        const total = input.prefixTokens + pinnedTokens;
-        return {
-          messages: [...input.prefix, ...processed],
-          distilledTokens: input.prefixTokens,
-          rawTokens: pinnedTokens,
-          totalTokens: total
+    const highWaterBudget = Math.max(rawWindowCache.pinnedBudget, input.rawBudget);
+    const effectiveBudget = highWaterBudget * 1.15;
+    if (pinnedTokens <= effectiveBudget) {
+      if (pinnedTokens > rawWindowCache.pinnedBudget * 1.15) {
+        input.sessState.rawWindowCache = {
+          ...rawWindowCache,
+          pinnedRawCount: pinnedWindow.length,
+          pinnedTotalCount: input.messages.length,
+          pinnedBudget: input.rawBudget
         };
       }
+      const processed = pinnedWindow.map((msg) => {
+        const parts = cleanParts(msg.parts);
+        return parts !== msg.parts ? { info: msg.info, parts } : msg;
+      });
+      const total = input.prefixTokens + pinnedTokens;
+      return {
+        messages: [...input.prefix, ...processed],
+        distilledTokens: input.prefixTokens,
+        rawTokens: pinnedTokens,
+        totalTokens: total
+      };
     }
+    info(
+      `pin-overflow: session=${input.sessionID} pinnedTokens=${pinnedTokens} pinnedBudget=${rawWindowCache.pinnedBudget} effectiveBudget=${Math.round(effectiveBudget)} currentRawBudget=${input.rawBudget} windowSize=${pinnedWindow.length}`
+    );
   }
   const result = tryFit({
     messages: input.messages,
@@ -27374,11 +27534,13 @@ function tryFitStable(input) {
     strip: "none"
   });
   if (result) {
-    const rawStart = result.messages[input.prefix.length];
-    if (rawStart) {
+    const rawMessageCount = result.messages.length - input.prefix.length;
+    if (rawMessageCount > 0) {
       input.sessState.rawWindowCache = {
         sessionID: input.sessionID,
-        firstMessageID: rawStart.info.id
+        pinnedRawCount: rawMessageCount,
+        pinnedTotalCount: input.messages.length,
+        pinnedBudget: input.rawBudget
       };
     }
   }
@@ -27393,14 +27555,15 @@ function needsUrgentDistillation() {
 function transformInner(input) {
   const cfg = config2();
   const overhead = getOverhead();
+  const sid = input.sessionID ?? input.messages[0]?.info.sessionID;
+  const sessState = sid ? getSessionState(sid) : makeSessionState();
+  const sessLtmTokens = sid ? sessState.ltmTokens : ltmTokensFallback;
   const usable = Math.max(
     0,
-    contextLimit - outputReserved - overhead - ltmTokens
+    contextLimit - outputReserved - overhead - sessLtmTokens
   );
   const distilledBudget = Math.floor(usable * cfg.budget.distilled);
-  const rawBudget = Math.floor(usable * cfg.budget.raw);
-  const sid = input.sessionID ?? input.messages[0]?.info.sessionID;
-  const sessState = sid ? getSessionState(sid) : makeSessionState();
+  let rawBudget = Math.floor(usable * cfg.budget.raw);
   let effectiveMinLayer = sessState.forceMinLayer;
   sessState.forceMinLayer = 0;
   if (sid && effectiveMinLayer > 0) saveForceMinLayer(sid, 0);
@@ -27413,17 +27576,26 @@ function transformInner(input) {
     return result.totalTokens * UNCALIBRATED_SAFETY <= maxInput;
   }
   if (calibrated && sessState.lastLayer >= 1 && input.messages.length >= sessState.lastKnownMessageCount) {
+    effectiveMinLayer = Math.max(effectiveMinLayer, sessState.lastLayer);
+  }
+  const postIdleCompact = sessState.postIdleCompact;
+  if (postIdleCompact) {
+    sessState.postIdleCompact = false;
     effectiveMinLayer = Math.max(effectiveMinLayer, 1);
+    rawBudget = Math.floor(usable * 0.2);
+    info(
+      `post-idle compact: session=${sid} rawBudget=${rawBudget} (${Math.floor(usable * cfg.budget.raw)}\u2192${rawBudget})`
+    );
   }
   let expectedInput;
   if (calibrated) {
     const newMessages = sessState.lastWindowMessageIDs.size > 0 ? input.messages.filter((m) => !sessState.lastWindowMessageIDs.has(m.info.id)) : input.messages.slice(-Math.max(0, input.messages.length - sessState.lastKnownMessageCount));
     const newMsgTokens = newMessages.reduce((s, m) => s + estimateMessage(m), 0);
-    const ltmDelta = ltmTokens - sessState.lastKnownLtm;
+    const ltmDelta = sessLtmTokens - sessState.lastKnownLtm;
     expectedInput = sessState.lastKnownInput + newMsgTokens + ltmDelta;
   } else {
     const messageTokens = input.messages.reduce((s, m) => s + estimateMessage(m), 0);
-    expectedInput = messageTokens + overhead + ltmTokens;
+    expectedInput = messageTokens + overhead + sessLtmTokens;
   }
   const layer0Input = calibrated ? expectedInput : expectedInput * UNCALIBRATED_SAFETY;
   let layer0Ceiling = maxLayer0Tokens > 0 ? Math.min(maxInput, maxLayer0Tokens) : maxInput;
@@ -27431,7 +27603,7 @@ function transformInner(input) {
     layer0Ceiling = Math.floor(layer0Ceiling * 0.7);
   }
   if (effectiveMinLayer === 0 && layer0Input <= layer0Ceiling) {
-    const messageTokens = calibrated ? expectedInput - (ltmTokens - sessState.lastKnownLtm) : expectedInput - overhead - ltmTokens;
+    const messageTokens = calibrated ? expectedInput - (sessLtmTokens - sessState.lastKnownLtm) : expectedInput - overhead - sessLtmTokens;
     return {
       messages: input.messages,
       layer: 0,
@@ -27445,7 +27617,7 @@ function transformInner(input) {
   }
   const turnStart = currentTurnStart(input.messages);
   const dedupMessages = deduplicateToolOutputs(input.messages, turnStart);
-  const distillations = sid ? loadDistillations(input.projectPath, sid) : [];
+  const distillations = sid ? loadDistillationsCached(input.projectPath, sid, input.messages, sessState) : [];
   const cached2 = sid ? distilledPrefixCached(distillations, sid, sessState) : (() => {
     const msgs = distilledPrefix(distillations);
     return { messages: msgs, tokens: msgs.reduce((sum, m) => sum + estimateMessage(m), 0) };
@@ -27558,12 +27730,27 @@ function transform2(input) {
     state.lastLayer = result.layer;
     state.lastWindowMessageIDs = new Set(result.messages.map((m) => m.info.id));
     state.lastTurnAt = Date.now();
-    const prefixIds = result.messages.slice(0, 5).map((m) => m.info.id).join(",");
-    const prefixHash = `${result.layer}:${prefixIds}`;
+    const prefixFingerprint = result.messages.slice(0, 5).map((m) => {
+      const text4 = m.parts.map((p3) => {
+        if (isTextPart(p3)) return p3.text?.slice(0, 40) ?? "";
+        if (isReasoningPart(p3)) return p3.text?.slice(0, 40) ?? "";
+        return p3.type;
+      }).join("|");
+      return `${m.info.role}:${text4.slice(0, 60)}`;
+    }).join(",");
+    const prefixHash = `${result.layer}:${prefixFingerprint}`;
+    state.transformCount++;
     if (state.lastPrefixHash && state.lastPrefixHash !== prefixHash) {
+      state.bustCount++;
+      const rate = state.bustCount / state.transformCount;
       info(
-        `cache-bust detected: session=${sid} layer=${state.lastLayer}\u2192${result.layer} msgs=${state.lastTransformedCount}\u2192${result.messages.length} prefix=${state.lastPrefixHash.slice(0, 30)}\u2192${prefixHash.slice(0, 30)}`
+        `cache-bust #${state.bustCount} (${(rate * 100).toFixed(0)}%): session=${sid} layer=${state.lastLayer}\u2192${result.layer} msgs=${state.lastTransformedCount}\u2192${result.messages.length} prefix=${state.lastPrefixHash.slice(0, 30)}\u2192${prefixHash.slice(0, 30)}`
       );
+      if (state.transformCount >= 20 && rate > 0.5) {
+        warn(
+          `HIGH BUST RATE: session ${sid} has ${(rate * 100).toFixed(0)}% bust rate (${state.bustCount}/${state.transformCount} transforms)`
+        );
+      }
     }
     state.lastPrefixHash = prefixHash;
     if (result.layer >= 2) {
@@ -27782,7 +27969,7 @@ function parseSourceIds(raw) {
 }
 function loadForSession(projectPath, sessionID, includeArchived = false) {
   const pid = ensureProject(projectPath);
-  const sql = includeArchived ? "SELECT id, project_id, session_id, observations, source_ids, generation, token_count, created_at FROM distillations WHERE project_id = ? AND session_id = ? ORDER BY created_at ASC" : "SELECT id, project_id, session_id, observations, source_ids, generation, token_count, created_at FROM distillations WHERE project_id = ? AND session_id = ? AND archived = 0 ORDER BY created_at ASC";
+  const sql = includeArchived ? "SELECT id, project_id, session_id, observations, source_ids, generation, token_count, created_at, r_compression, c_norm FROM distillations WHERE project_id = ? AND session_id = ? ORDER BY created_at ASC" : "SELECT id, project_id, session_id, observations, source_ids, generation, token_count, created_at, r_compression, c_norm FROM distillations WHERE project_id = ? AND session_id = ? AND archived = 0 ORDER BY created_at ASC";
   const rows = db().query(sql).all(pid, sessionID);
   return rows.map((r) => ({
     ...r,
@@ -27795,8 +27982,8 @@ function storeDistillation(input) {
   const sourceJson = JSON.stringify(input.sourceIDs);
   const tokens = Math.ceil(input.observations.length / 3);
   db().query(
-    `INSERT INTO distillations (id, project_id, session_id, narrative, facts, observations, source_ids, generation, token_count, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    `INSERT INTO distillations (id, project_id, session_id, narrative, facts, observations, source_ids, generation, token_count, created_at, r_compression, c_norm)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
   ).run(
     id,
     pid,
@@ -27809,7 +27996,9 @@ function storeDistillation(input) {
     sourceJson,
     input.generation,
     tokens,
-    Date.now()
+    Date.now(),
+    input.rCompression ?? null,
+    input.cNorm ?? null
   );
   return id;
 }
@@ -27822,7 +28011,7 @@ function gen0Count(projectPath, sessionID) {
 function loadGen0(projectPath, sessionID) {
   const pid = ensureProject(projectPath);
   const rows = db().query(
-    "SELECT id, project_id, session_id, observations, source_ids, generation, token_count, created_at FROM distillations WHERE project_id = ? AND session_id = ? AND generation = 0 AND archived = 0 ORDER BY created_at ASC"
+    "SELECT id, project_id, session_id, observations, source_ids, generation, token_count, created_at, r_compression, c_norm FROM distillations WHERE project_id = ? AND session_id = ? AND generation = 0 AND archived = 0 ORDER BY created_at ASC"
   ).all(pid, sessionID);
   return rows.map((r) => ({
     ...r,
@@ -27889,7 +28078,8 @@ async function run(input) {
           projectPath: input.projectPath,
           sessionID: input.sessionID,
           messages: segment,
-          model: input.model
+          model: input.model,
+          urgent: input.urgent
         });
         if (result) {
           distilled += segment.length;
@@ -27897,12 +28087,13 @@ async function run(input) {
         }
       }
     }
-    if (gen0Count(input.projectPath, input.sessionID) >= cfg.distillation.metaThreshold) {
+    if (!input.skipMeta && gen0Count(input.projectPath, input.sessionID) >= cfg.distillation.metaThreshold) {
       await metaDistill({
         llm: input.llm,
         projectPath: input.projectPath,
         sessionID: input.sessionID,
-        model: input.model
+        model: input.model,
+        urgent: input.urgent
       });
       rounds++;
     }
@@ -27928,29 +28119,46 @@ async function distillSegment(input) {
   const responseText = await input.llm.prompt(
     DISTILLATION_SYSTEM,
     userContent,
-    { model, workerID: "lore-distill" }
+    { model, workerID: "lore-distill", thinking: false, urgent: input.urgent, sessionID: input.sessionID }
   );
   if (!responseText) return null;
   const result = parseDistillationResult(responseText);
   if (!result) return null;
+  const distilledTokens = Math.ceil(result.observations.length / 3);
+  const sourceTokens = input.messages.reduce((sum, m) => sum + m.tokens, 0);
+  const rComp = compressionRatio(distilledTokens, sourceTokens);
+  const cNorm = temporalCnorm(input.messages.map((m) => m.created_at));
   const distillId = storeDistillation({
     projectPath: input.projectPath,
     sessionID: input.sessionID,
     observations: result.observations,
     sourceIDs: input.messages.map((m) => m.id),
-    generation: 0
+    generation: 0,
+    rCompression: rComp,
+    cNorm
   });
   markDistilled(input.messages.map((m) => m.id));
-  const distilledTokens = Math.ceil(result.observations.length / 3);
-  const sourceTokens = input.messages.reduce((sum, m) => sum + m.tokens, 0);
-  const rComp = compressionRatio(distilledTokens, sourceTokens);
-  const cNorm = temporalCnorm(input.messages.map((m) => m.created_at));
   info(
     `distill segment: ${input.messages.length} msgs, ${sourceTokens}\u2192${distilledTokens} tokens, R=${rComp.toFixed(2)}, C_norm=${cNorm.toFixed(3)}`
   );
   if (isAvailable()) {
     embedDistillation(distillId, result.observations);
   }
+  if (config2().knowledge.enabled) {
+    for (const pat of extractPatterns(result.observations)) {
+      try {
+        create({
+          projectPath: input.projectPath,
+          category: pat.category,
+          title: pat.title,
+          content: pat.content,
+          session: input.sessionID,
+          scope: "project"
+        });
+      } catch {
+      }
+    }
+  }
   return result;
 }
 async function metaDistill(input) {
@@ -27966,7 +28174,7 @@ async function metaDistill(input) {
   const responseText = await input.llm.prompt(
     RECURSIVE_SYSTEM,
     userContent,
-    { model, workerID: "lore-distill" }
+    { model, workerID: "lore-distill", thinking: false, urgent: input.urgent, sessionID: input.sessionID }
   );
   if (!responseText) return null;
   const result = parseDistillationResult(responseText);
@@ -27995,8 +28203,54 @@ async function metaDistill(input) {
   if (isAvailable()) {
     embedDistillation(metaId, result.observations);
   }
+  if (config2().knowledge.enabled) {
+    for (const pat of extractPatterns(result.observations)) {
+      try {
+        create({
+          projectPath: input.projectPath,
+          category: pat.category,
+          title: pat.title,
+          content: pat.content,
+          session: input.sessionID,
+          scope: "project"
+        });
+      } catch {
+      }
+    }
+  }
   return result;
 }
+function backfillMetrics() {
+  const rows = db().query(
+    "SELECT id, source_ids, token_count FROM distillations WHERE r_compression IS NULL"
+  ).all();
+  if (!rows.length) return 0;
+  const update2 = db().prepare(
+    "UPDATE distillations SET r_compression = ?, c_norm = ? WHERE id = ?"
+  );
+  let updated = 0;
+  for (const row of rows) {
+    const sourceIds = parseSourceIds(row.source_ids);
+    if (!sourceIds.length) continue;
+    const placeholders = sourceIds.map(() => "?").join(",");
+    const sources = db().query(
+      `SELECT tokens, created_at FROM temporal_messages WHERE id IN (${placeholders})`
+    ).all(...sourceIds);
+    if (!sources.length) continue;
+    const sourceTokens = sources.reduce((sum, s) => sum + s.tokens, 0);
+    const timestamps = sources.map((s) => s.created_at);
+    const rComp = compressionRatio(row.token_count, sourceTokens);
+    const cNorm = temporalCnorm(timestamps);
+    update2.run(rComp, cNorm, row.id);
+    updated++;
+  }
+  if (updated > 0) {
+    info(
+      `backfilled metrics for ${updated} distillations (${rows.length - updated} skipped \u2014 missing sources)`
+    );
+  }
+  return updated;
+}
 
 // src/curator.ts
 var curator_exports = {};
@@ -28042,7 +28296,7 @@ async function run2(input) {
   const responseText = await input.llm.prompt(
     CURATOR_SYSTEM,
     userContent,
-    { model, workerID: "lore-curator" }
+    { model, workerID: "lore-curator", thinking: false, sessionID: input.sessionID }
   );
   if (!responseText) return { created: 0, updated: 0, deleted: 0 };
   const ops = parseOps(responseText);
@@ -28112,7 +28366,7 @@ async function consolidate(input) {
   const responseText = await input.llm.prompt(
     CONSOLIDATION_SYSTEM,
     userContent,
-    { model, workerID: "lore-curator" }
+    { model, workerID: "lore-curator", thinking: false, sessionID: input.sessionID }
   );
   if (!responseText) return { updated: 0, deleted: 0 };
   const ops = parseOps(responseText);
@@ -28138,12 +28392,39 @@ async function consolidate(input) {
 }
 
 // src/recall.ts
+function getTaggedText(tagged) {
+  switch (tagged.source) {
+    case "knowledge":
+    case "cross-knowledge":
+      return `${tagged.item.title} ${tagged.item.content}`;
+    case "distillation":
+      return tagged.item.observations;
+    case "temporal":
+      return tagged.item.content;
+    case "lat-section":
+      return `${tagged.item.heading} ${tagged.item.content}`;
+  }
+}
+function taggedResultKey(r) {
+  switch (r.source) {
+    case "knowledge":
+      return `k:${r.item.id}`;
+    case "cross-knowledge":
+      return `xk:${r.item.id}`;
+    case "distillation":
+      return `d:${r.item.id}`;
+    case "temporal":
+      return `t:${r.item.id}`;
+    case "lat-section":
+      return `lat:${r.item.id}`;
+  }
+}
 function searchDistillationsLike(input) {
   const terms = input.query.toLowerCase().split(/\s+/).filter((term) => term.length > 1);
   if (!terms.length) return [];
   const conditions = terms.map(() => "LOWER(observations) LIKE ?").join(" AND ");
   const likeParams = terms.map((term) => `%${term}%`);
-  const sql = input.sessionID ? `SELECT id, observations, generation, created_at, session_id FROM distillations WHERE project_id = ? AND session_id = ? AND ${conditions} ORDER BY created_at DESC LIMIT ?` : `SELECT id, observations, generation, created_at, session_id FROM distillations WHERE project_id = ? AND ${conditions} ORDER BY created_at DESC LIMIT ?`;
+  const sql = input.sessionID ? `SELECT id, observations, generation, created_at, session_id, c_norm FROM distillations WHERE project_id = ? AND session_id = ? AND ${conditions} ORDER BY created_at DESC LIMIT ?` : `SELECT id, observations, generation, created_at, session_id, c_norm FROM distillations WHERE project_id = ? AND ${conditions} ORDER BY created_at DESC LIMIT ?`;
   const allParams = input.sessionID ? [input.pid, input.sessionID, ...likeParams, input.limit] : [input.pid, ...likeParams, input.limit];
   return db().query(sql).all(...allParams);
 }
@@ -28152,12 +28433,12 @@ function searchDistillationsScored(input) {
   const limit = input.limit ?? 10;
   const q = ftsQuery(input.query);
   if (q === EMPTY_QUERY) return [];
-  const ftsSQL = input.sessionID ? `SELECT d.id, d.observations, d.generation, d.created_at, d.session_id, rank
+  const ftsSQL = input.sessionID ? `SELECT d.id, d.observations, d.generation, d.created_at, d.session_id, d.c_norm, rank
        FROM distillation_fts f
        CROSS JOIN distillations d ON d.rowid = f.rowid
        WHERE distillation_fts MATCH ?
        AND d.project_id = ? AND d.session_id = ?
-       ORDER BY rank LIMIT ?` : `SELECT d.id, d.observations, d.generation, d.created_at, d.session_id, rank
+       ORDER BY rank LIMIT ?` : `SELECT d.id, d.observations, d.generation, d.created_at, d.session_id, d.c_norm, rank
        FROM distillation_fts f
        CROSS JOIN distillations d ON d.rowid = f.rowid
        WHERE distillation_fts MATCH ?
@@ -28242,7 +28523,7 @@ async function runRecall(input) {
   let queries = [query];
   if (searchConfig?.queryExpansion && llm) {
     try {
-      queries = await expandQuery(llm, query);
+      queries = await expandQuery(llm, query, void 0, sessionID);
     } catch (err) {
       info("recall: query expansion failed, using original:", err);
     }
@@ -28351,7 +28632,7 @@ async function runRecall(input) {
         const distVectorHits = vectorSearchDistillations(queryVec, limit);
         const distVectorTagged = distVectorHits.map((hit) => {
           const row = db().query(
-            "SELECT id, observations, generation, created_at, session_id FROM distillations WHERE id = ?"
+            "SELECT id, observations, generation, created_at, session_id, c_norm FROM distillations WHERE id = ?"
           ).get(hit.id);
           if (!row) return null;
           return {
@@ -28414,6 +28695,57 @@ async function runRecall(input) {
       info("recall: cross-project knowledge search failed:", err);
     }
   }
+  {
+    const distillationCandidates = [];
+    for (const list4 of allRrfLists) {
+      for (const item of list4.items) {
+        if (item.source !== "distillation") continue;
+        const key = `d:${item.item.id}`;
+        const d = item.item;
+        const cNorm = d.c_norm ?? 0;
+        const ageDays = Math.min(
+          (Date.now() - d.created_at) / 864e5,
+          90
+        );
+        const score = cNorm + ageDays / 90 * 0.1;
+        distillationCandidates.push({ tagged: item, key, qualityScore: score });
+      }
+    }
+    if (distillationCandidates.length > 1) {
+      const seen = /* @__PURE__ */ new Set();
+      const unique = distillationCandidates.filter((c) => {
+        if (seen.has(c.key)) return false;
+        seen.add(c.key);
+        return true;
+      });
+      unique.sort((a, b) => a.qualityScore - b.qualityScore);
+      allRrfLists.push({
+        items: unique.map((c) => c.tagged),
+        key: (r) => `d:${r.item.id}`
+      });
+    }
+  }
+  if (filterTerms(query).length > 0 && allRrfLists.length > 0) {
+    const allCandidates = /* @__PURE__ */ new Map();
+    for (const list4 of allRrfLists) {
+      for (const item of list4.items) {
+        const key = list4.key(item);
+        if (!allCandidates.has(key)) allCandidates.set(key, item);
+      }
+    }
+    const candidateEntries = [...allCandidates.entries()];
+    const exactRanked = exactTermMatchRank(
+      candidateEntries,
+      ([, tagged]) => getTaggedText(tagged),
+      query
+    );
+    if (exactRanked.length) {
+      allRrfLists.push({
+        items: exactRanked.map(([, item]) => item),
+        key: taggedResultKey
+      });
+    }
+  }
   const fused = reciprocalRankFusion(allRrfLists);
   return formatFusedResults(fused, 20);
 }
@@ -28425,7 +28757,7 @@ var RECALL_PARAM_DESCRIPTIONS = {
 
 // src/agents-file.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
-import { dirname as dirname2 } from "path";
+import { dirname as dirname2, join as join5 } from "path";
 var LORE_SECTION_START = "<!-- This section is maintained by the coding agent via lore (https://github.com/BYK/loreai) -->";
 var LORE_SECTION_END = "<!-- End lore-managed section -->";
 var ALL_START_MARKERS = [
@@ -28434,6 +28766,8 @@ var ALL_START_MARKERS = [
   "<!-- This section is maintained by the coding agent via lore (https://github.com/BYK/opencode-lore) -->",
   "<!-- This section is auto-maintained by lore (https://github.com/BYK/opencode-lore) -->"
 ];
+var LORE_FILE = ".lore.md";
+var LORE_FILE_HEADER = "<!-- Managed by lore (https://github.com/BYK/loreai) \u2014 manual edits are imported on next session. -->";
 var UUID_RE2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 var MARKER_RE = /^<!--\s*lore:([0-9a-f-]+)\s*-->$/;
 function splitFile(fileContent) {
@@ -28543,8 +28877,9 @@ function buildSection(projectPath) {
   return out.join("\n");
 }
 function exportToFile(input) {
-  const sectionBody = buildSection(input.projectPath);
-  const newSection = LORE_SECTION_START + sectionBody + LORE_SECTION_END + "\n";
+  exportLoreFile(input.projectPath);
+  const pointerBody = "\n## Long-term Knowledge\n\nFor long-term knowledge entries managed by [lore](https://github.com/BYK/loreai) (gotchas, patterns, decisions, architecture), see [`.lore.md`](.lore.md) in the project root.\n";
+  const newSection = LORE_SECTION_START + pointerBody + LORE_SECTION_END + "\n";
   let fileContent = "";
   if (existsSync3(input.filePath)) {
     fileContent = readFileSync3(input.filePath, "utf8");
@@ -28568,15 +28903,9 @@ function shouldImport(input) {
   const expected = buildSection(input.projectPath);
   return hashSection(section) !== hashSection(expected);
 }
-function importFromFile(input) {
-  if (!existsSync3(input.filePath)) return;
-  const fileContent = readFileSync3(input.filePath, "utf8");
-  const { section, before } = splitFile(fileContent);
-  const textToParse = section ?? fileContent;
-  const fileEntries = parseEntriesFromSection(textToParse);
-  if (!fileEntries.length) return;
+function _importEntries(entries, projectPath) {
   const seenIds = /* @__PURE__ */ new Set();
-  for (const entry of fileEntries) {
+  for (const entry of entries) {
     if (entry.id !== null) {
       if (seenIds.has(entry.id)) continue;
       seenIds.add(entry.id);
@@ -28587,7 +28916,7 @@ function importFromFile(input) {
         }
       } else {
         create({
-          projectPath: input.projectPath,
+          projectPath,
           category: entry.category,
           title: entry.title,
           content: entry.content,
@@ -28597,13 +28926,13 @@ function importFromFile(input) {
         });
       }
     } else {
-      const existing = forProject(input.projectPath, true);
+      const existing = forProject(projectPath, true);
       const titleMatch = existing.find(
         (e) => e.title.toLowerCase() === entry.title.toLowerCase()
       );
       if (!titleMatch) {
         create({
-          projectPath: input.projectPath,
+          projectPath,
           category: entry.category,
           title: entry.title,
           content: entry.content,
@@ -28614,16 +28943,50 @@ function importFromFile(input) {
     }
   }
 }
+function importFromFile(input) {
+  if (!existsSync3(input.filePath)) return;
+  const fileContent = readFileSync3(input.filePath, "utf8");
+  const { section } = splitFile(fileContent);
+  const textToParse = section ?? fileContent;
+  const fileEntries = parseEntriesFromSection(textToParse);
+  if (!fileEntries.length) return;
+  _importEntries(fileEntries, input.projectPath);
+}
+function loreFileExists(projectPath) {
+  return existsSync3(join5(projectPath, LORE_FILE));
+}
+function exportLoreFile(projectPath) {
+  const sectionBody = buildSection(projectPath);
+  const content3 = LORE_FILE_HEADER + "\n" + sectionBody;
+  writeFileSync(join5(projectPath, LORE_FILE), content3, "utf8");
+}
+function shouldImportLoreFile(projectPath) {
+  const fp = join5(projectPath, LORE_FILE);
+  if (!existsSync3(fp)) return false;
+  const fileContent = readFileSync3(fp, "utf8");
+  const expected = LORE_FILE_HEADER + "\n" + buildSection(projectPath);
+  return hashSection(fileContent) !== hashSection(expected);
+}
+function importLoreFile(projectPath) {
+  const fp = join5(projectPath, LORE_FILE);
+  if (!existsSync3(fp)) return;
+  const fileContent = readFileSync3(fp, "utf8");
+  const fileEntries = parseEntriesFromSection(fileContent);
+  if (!fileEntries.length) return;
+  _importEntries(fileEntries, projectPath);
+}
 
 // src/worker-model.ts
 var worker_model_exports = {};
 __export(worker_model_exports, {
   WORKER_JUDGE_SYSTEM: () => WORKER_JUDGE_SYSTEM,
+  clearValidatedWorkerModel: () => clearValidatedWorkerModel,
   computeModelFingerprint: () => computeModelFingerprint,
   getValidatedWorkerModel: () => getValidatedWorkerModel,
   isValidationStale: () => isValidationStale,
   parseJudgeScore: () => parseJudgeScore,
   resolveWorkerModel: () => resolveWorkerModel,
+  runValidation: () => runValidation,
   selectWorkerCandidates: () => selectWorkerCandidates,
   storeValidatedWorkerModel: () => storeValidatedWorkerModel,
   structuralCheck: () => structuralCheck,
@@ -28635,7 +28998,13 @@ function selectWorkerCandidates(sessionModel, providerModels) {
     (m) => m.providerID === sessionModel.providerID && m.status === "active" && m.capabilities.input.text
   );
   if (eligible.length === 0) return [];
-  const sorted = [...eligible].sort((a, b) => a.cost.input - b.cost.input);
+  const sorted = [...eligible].sort((a, b) => {
+    const costDiff = a.cost.input - b.cost.input;
+    if (costDiff !== 0) return costDiff;
+    const aReasoning = a.capabilities.reasoning ? 1 : 0;
+    const bReasoning = b.capabilities.reasoning ? 1 : 0;
+    return aReasoning - bReasoning;
+  });
   const cheapest = sorted[0];
   const belowSession = sorted.filter((m) => m.cost.input < sessionModel.cost.input).pop();
   const candidates = /* @__PURE__ */ new Map();
@@ -28670,6 +29039,9 @@ function storeValidatedWorkerModel(result) {
     "INSERT INTO kv_meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = ?"
   ).run(key, value, value);
 }
+function clearValidatedWorkerModel(providerID) {
+  db().query("DELETE FROM kv_meta WHERE key = ?").run(`${KV_PREFIX}${providerID}`);
+}
 function isValidationStale(stored, currentFingerprint) {
   if (!stored) return true;
   return stored.fingerprint !== currentFingerprint;
@@ -28728,10 +29100,85 @@ function parseJudgeScore(response) {
   if (!match) return null;
   return parseInt(match[1], 10);
 }
+async function runValidation(input) {
+  const { llm, candidates, referenceObservations, sourceMessagesText, date: date5 } = input;
+  const userPrompt = distillationUser({
+    messages: sourceMessagesText,
+    date: date5
+  });
+  for (const candidate of candidates) {
+    if (candidate.id === input.sessionModelID) continue;
+    let candidateObservations = null;
+    try {
+      const raw = await llm.prompt(DISTILLATION_SYSTEM, userPrompt, {
+        model: { providerID: candidate.providerID, modelID: candidate.id },
+        workerID: "lore-distill",
+        thinking: false
+      });
+      if (raw) {
+        const match = raw.match(/<observations>([\s\S]*?)<\/observations>/);
+        candidateObservations = match ? match[1].trim() : raw.trim();
+      }
+    } catch (e) {
+      warn(`worker model validation: candidate ${candidate.id} failed:`, e);
+      continue;
+    }
+    const structural = structuralCheck(candidateObservations, referenceObservations);
+    if (!structural.passed) {
+      info(
+        `worker model validation: ${candidate.id} failed structural check: ${structural.reason}`
+      );
+      continue;
+    }
+    let judgeScore = null;
+    try {
+      const judgeResponse = await llm.prompt(
+        WORKER_JUDGE_SYSTEM,
+        workerJudgeUser(referenceObservations, candidateObservations),
+        { workerID: "lore-distill", thinking: false }
+        // use session model (no model override)
+      );
+      if (judgeResponse) {
+        judgeScore = parseJudgeScore(judgeResponse);
+      }
+    } catch (e) {
+      warn(`worker model validation: judge call failed for ${candidate.id}:`, e);
+    }
+    if (judgeScore !== null && judgeScore < 3) {
+      info(
+        `worker model validation: ${candidate.id} failed judge (score=${judgeScore})`
+      );
+      continue;
+    }
+    const fingerprint = computeModelFingerprint(
+      input.providerID,
+      input.sessionModelID,
+      candidates.map((c) => c.id)
+    );
+    const result = {
+      modelID: candidate.id,
+      providerID: candidate.providerID,
+      fingerprint,
+      validatedAt: Date.now(),
+      judgeScore
+    };
+    storeValidatedWorkerModel(result);
+    info(
+      `worker model validated: ${candidate.id} (judge=${judgeScore}) for provider ${input.providerID}`
+    );
+    return result;
+  }
+  clearValidatedWorkerModel(input.providerID);
+  info(
+    `worker model validation: no candidate passed for ${input.providerID} \u2014 cleared stale entry`
+  );
+  return null;
+}
 function resolveWorkerModel(providerID, configWorkerModel, configModel) {
   if (configWorkerModel) return configWorkerModel;
   const validated = getValidatedWorkerModel(providerID);
-  if (validated) {
+  const MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+  if (validated && Date.now() - validated.validatedAt <= MAX_AGE_MS) {
     return { providerID: validated.providerID, modelID: validated.modelID };
   }
   return configModel;
@@ -28742,11 +29189,11 @@ export {
   CURATOR_SYSTEM,
   DISTILLATION_SYSTEM,
   EMPTY_QUERY,
+  LORE_FILE,
   QUERY_EXPANSION_SYSTEM,
   RECALL_PARAM_DESCRIPTIONS,
   RECALL_TOOL_DESCRIPTION,
   RECURSIVE_SYSTEM,
-  WORKER_JUDGE_SYSTEM,
   buildCompactPrompt,
   calibrate,
   close,
@@ -28761,7 +29208,9 @@ export {
   distillationUser,
   embedding_exports as embedding,
   ensureProject,
+  exactTermMatchRank,
   expandQuery,
+  exportLoreFile,
   exportToFile,
   extractTopTerms,
   formatDistillations,
@@ -28770,10 +29219,12 @@ export {
   ftsQueryOr,
   getLastTransformEstimate,
   getLastTransformedCount,
+  getLastTurnAt,
   getLtmBudget,
   getLtmTokens,
   h,
   importFromFile,
+  importLoreFile,
   inline,
   inspectSessionState,
   isFirstRun,
@@ -28787,11 +29238,13 @@ export {
   load,
   loadForceMinLayer,
   log_exports as log,
+  loreFileExists,
   ltm_exports as ltm,
   needsUrgentDistillation,
   normalize,
   onIdleResume,
   p,
+  pattern_extract_exports as patternExtract,
   projectId,
   projectName,
   reciprocalRankFusion,
@@ -28807,6 +29260,7 @@ export {
   setMaxLayer0Tokens,
   setModelLimits,
   shouldImport,
+  shouldImportLoreFile,
   strong2 as strong,
   t,
   temporal_exports as temporal,
@@ -28814,7 +29268,6 @@ export {
   transform2 as transform,
   ul,
   unescapeMarkdown,
-  workerJudgeUser,
   worker_model_exports as workerModel,
   workerSessionIDs
 };