@loreai/core 0.10.2 → 0.11.1

package/src/embedding.ts

@@ -12,6 +12,11 @@ import { db } from "./db";
 import { config } from "./config";
 import * as log from "./log";
 
+/** Timeout for embedding API fetch calls (ms). Prevents a hanging API from
+ *  blocking the recall tool indefinitely. 10s is generous for typical 100-500ms
+ *  embedding calls but bounded enough to avoid minutes-long hangs. */
+const EMBED_TIMEOUT_MS = 10_000;
+
 // ---------------------------------------------------------------------------
 // Provider interface
 // ---------------------------------------------------------------------------
@@ -58,6 +63,7 @@ class VoyageProvider implements EmbeddingProvider {
         input_type: inputType,
         output_dimension: this.dimensions,
       }),
+      signal: AbortSignal.timeout(EMBED_TIMEOUT_MS),
     });
 
     if (!res.ok) {
@@ -112,6 +118,7 @@ class OpenAIProvider implements EmbeddingProvider {
         Authorization: `Bearer ${this.apiKey}`,
       },
       body: JSON.stringify(body),
+      signal: AbortSignal.timeout(EMBED_TIMEOUT_MS),
     });
 
     if (!res.ok) {

package/src/gradient.ts

@@ -4,6 +4,7 @@ import { db, ensureProject, loadForceMinLayer, saveForceMinLayer } from "./db";
 import { config } from "./config";
 import { formatDistillations } from "./prompt";
 import { normalize } from "./markdown";
+import * as log from "./log";
 
 type MessageWithParts = LoreMessageWithParts;
 
@@ -36,6 +37,15 @@ function estimateMessage(msg: MessageWithParts): number {
 let contextLimit = 200_000; // sensible default
 let outputReserved = 32_000;
 
+// Cost-aware layer-0 token cap. When > 0, the layer-0 passthrough gate uses
+// min(maxInput, maxLayer0Tokens) instead of maxInput alone. Derived from the
+// model's cache-read cost: cap = targetCostPerTurn / costPerToken. This prevents
+// expensive models from sending huge contexts at layer 0, where cache-read costs
+// compound linearly across turns. Set to 0 to disable (use full context).
+let maxLayer0Tokens = 0;
+
+const MIN_LAYER0_FLOOR = 40_000;
+
 // Conservative overhead reserve for first-turn (before calibration):
 // accounts for provider system prompt + AGENTS.md + tool definitions + env info
 const FIRST_TURN_OVERHEAD = 15_000;
@@ -83,6 +93,29 @@ type SessionState = {
   prefixCache: PrefixCache | null;
   /** Raw window pin cache (Approach B) */
   rawWindowCache: RawWindowCache | null;
+  /**
+   * Wall-clock timestamp (epoch ms) of the most recent transform() call for this
+   * session. Used by onIdleResume() to detect cold-cache resumption — when the
+   * gap between turns exceeds Anthropic's prompt cache eviction window (5 min
+   * default / 1 hour extended), the byte-identity caching subsystems
+   * (prefixCache, rawWindowCache) are providing no value because the cache is
+   * already cold. Refreshing them on resume lets us produce a better-fitting
+   * window without paying a cache cost we'd otherwise be trying to preserve.
+   * 0 = never set (first turn).
+   */
+  lastTurnAt: number;
+  /**
+   * Set true by onIdleResume() when an idle-resume reset just fired; consumed
+   * (and cleared) by the LTM degraded-recovery branch in the OpenCode hook to
+   * skip the conversation-vs-LTM token comparison. After idle eviction the
+   * cache-bust cost is effectively zero, so we should always recover LTM on
+   * the post-idle turn regardless of conversation size.
+   */
+  cameOutOfIdle: boolean;
+  /** Consecutive turns at layer >= 2. When >= 3, log a compaction hint. */
+  consecutiveHighLayer: number;
+  /** Hash of the first message IDs in the last transform output — for cache-bust diagnostics. */
+  lastPrefixHash: string;
 };
 
 function makeSessionState(): SessionState {
@@ -97,6 +130,10 @@ function makeSessionState(): SessionState {
     lastTransformEstimate: 0,
     prefixCache: null,
     rawWindowCache: null,
+    lastTurnAt: 0,
+    cameOutOfIdle: false,
+    consecutiveHighLayer: 0,
+    lastPrefixHash: "",
   };
 }
 
@@ -116,6 +153,65 @@ function getSessionState(sessionID: string): SessionState {
   return state;
 }
 
+/**
+ * Detect cold-cache resumption and refresh byte-identity caches.
+ *
+ * Anthropic's prompt cache evicts entries after ~5 minutes (default tier) /
+ * ~1 hour (extended tier). When a session resumes after the eviction window,
+ * the cache is provably cold — every prefix we've been carefully keeping
+ * byte-stable (`prefixCache`, `rawWindowCache`, plus the host's per-session
+ * LTM cache) provides no benefit on this turn. Worse, the LTM block was
+ * scored against the conversation context as it was on the previous turn,
+ * which may have drifted significantly in N hours.
+ *
+ * On resume after `thresholdMs`:
+ *   - reset the distilled prefix cache (next turn re-renders from scratch)
+ *   - reset the raw window pin cache (next turn picks a fresh cutoff)
+ *   - set `cameOutOfIdle` so the OpenCode host can also clear `ltmSessionCache`
+ *     and bypass the conversation-vs-LTM cost comparison in the LTM
+ *     degraded-recovery branch
+ *
+ * Importantly, this does NOT touch:
+ *   - reasoning blocks (Anthropic's April 23 postmortem identifies dropping
+ *     reasoning blocks as the root cause of forgetfulness/repetition; Lore
+ *     preserves reasoning by policy across all gradient layers)
+ *   - the gradient layer (cold cache doesn't change token budgets;
+ *     calibration's actualInput = input + cache.read + cache.write already
+ *     accounts for cache misses correctly)
+ *   - calibration state (`lastKnownInput`, overhead EMA, message-ID set) —
+ *     the next API response will refresh these via the normal calibrate() path
+ *
+ * Set `thresholdMs <= 0` to disable. Returns true if a reset fired so the
+ * caller can log/observe.
+ */
+export function onIdleResume(
+  sessionID: string,
+  thresholdMs: number,
+  now: number = Date.now(),
+): { triggered: false } | { triggered: true; idleMs: number } {
+  if (thresholdMs <= 0) return { triggered: false };
+  const state = getSessionState(sessionID);
+  if (state.lastTurnAt === 0) return { triggered: false }; // first turn — nothing to refresh
+  const idleMs = now - state.lastTurnAt;
+  if (idleMs < thresholdMs) return { triggered: false };
+  state.prefixCache = null;
+  state.rawWindowCache = null;
+  state.cameOutOfIdle = true;
+  return { triggered: true, idleMs };
+}
+
+/**
+ * Read-and-clear the cameOutOfIdle flag. The OpenCode host's LTM degraded-
+ * recovery branch consumes this to decide whether to bypass the
+ * conversation-vs-LTM token comparison on a post-idle turn.
+ */
+export function consumeCameOutOfIdle(sessionID: string): boolean {
+  const state = sessionStates.get(sessionID);
+  if (!state || !state.cameOutOfIdle) return false;
+  state.cameOutOfIdle = false;
+  return true;
+}
+
 // LTM tokens injected via system transform hook this turn.
 // Set by setLtmTokens() after the system hook runs; consumed by transform().
 let ltmTokens = 0;
@@ -131,6 +227,27 @@ export function setModelLimits(limits: { context: number; output: number }) {
   outputReserved = Math.min(limits.output || 32_000, 32_000);
 }
 
+/**
+ * Set the cost-aware layer-0 token cap. When the cap > 0, the layer-0
+ * passthrough gate uses `min(maxInput, cap)` instead of `maxInput` alone.
+ *
+ * Call from the host adapter after computing the cap from model pricing:
+ * `cap = max(targetCostPerTurn / model.cost.cache.read, MIN_LAYER0_FLOOR)`
+ */
+export function setMaxLayer0Tokens(tokens: number) {
+  maxLayer0Tokens = Math.max(0, Math.floor(tokens));
+}
+
+/** Compute the layer-0 token cap from a per-turn cost target and cache-read price. */
+export function computeLayer0Cap(
+  targetCostPerTurn: number,
+  cacheReadCostPerToken: number,
+): number {
+  if (targetCostPerTurn <= 0 || cacheReadCostPerToken <= 0) return 0;
+  const rawCap = Math.floor(targetCostPerTurn / cacheReadCostPerToken);
+  return Math.max(rawCap, MIN_LAYER0_FLOOR);
+}
+
 /** Called by the system transform hook after formatting LTM knowledge. */
 export function setLtmTokens(tokens: number) {
   ltmTokens = tokens;
@@ -251,6 +368,37 @@ export function resetCalibration(sessionID?: string) {
   }
 }
 
+/**
+ * For testing only — observe session-state cache fields without exposing the
+ * full type. Returns null when the session has no state. The boolean fields
+ * answer "does this cache hold something right now?" — sufficient for asserting
+ * that onIdleResume() reset them.
+ */
+export function inspectSessionState(sessionID: string): {
+  hasPrefixCache: boolean;
+  hasRawWindowCache: boolean;
+  cameOutOfIdle: boolean;
+  lastTurnAt: number;
+} | null {
+  const state = sessionStates.get(sessionID);
+  if (!state) return null;
+  return {
+    hasPrefixCache: state.prefixCache !== null,
+    hasRawWindowCache: state.rawWindowCache !== null,
+    cameOutOfIdle: state.cameOutOfIdle,
+    lastTurnAt: state.lastTurnAt,
+  };
+}
+
+/**
+ * For testing only — set the session's lastTurnAt field. Used to simulate
+ * idle gaps without sleeping. Creates the session state if not present so
+ * tests don't need to seed it via a transform() call.
+ */
+export function setLastTurnAtForTest(sessionID: string, ms: number): void {
+  getSessionState(sessionID).lastTurnAt = ms;
+}
+
 type Distillation = {
   id: string;
   observations: string;
@@ -320,20 +468,41 @@ function cleanParts(parts: LorePart[]): LorePart[] {
   return filtered.length > 0 ? filtered : parts;
 }
 
+// Upper bound on how much of the output the path-extraction regex scans.
+// Two mitigations for catastrophic backtracking in `PATH_RE`:
+//   1. Skip entirely if the input contains no '/' (a path requires at least
+//      one separator, so without one the regex has no possible match yet
+//      still backtracks O(n²) on long runs of [\w.-]).
+//   2. Cap the scanned slice at this limit so even crafted inputs with a
+//      '/' somewhere don't stall the worker. The annotation only needs a
+//      few representative paths — sampling the first 64KB is plenty.
+const ANNOTATION_PATH_SCAN_LIMIT = 64 * 1024;
+const PATH_RE = /(?:[\w.-]+\/)+[\w.-]+\.\w{1,5}/g;
+
 // Build a metadata annotation for a stripped tool output, preserving key signals
 // about what was lost without requiring an LLM call. Inspired by the per-token
 // scalar bias β from "Fast KV Compaction via Attention Matching" (Zweiger et al.,
 // 2025) — when tokens are removed, preserving metadata about the removed content
 // helps the model compensate for information loss and decide whether to recall.
 // Reference: https://arxiv.org/abs/2602.16284
-function toolStripAnnotation(toolName: string, output: string): string {
+export function toolStripAnnotation(toolName: string, output: string): string {
   const lines = output.split("\n").length;
-  const chars = output.length;
 
   // Detect key signals via lightweight heuristics — no LLM call
   const hasError = /\b(?:error|fail(?:ed|ure)?|exception|panic|traceback)\b/i.test(output);
-  const paths = output.match(/(?:[\w.-]+\/)+[\w.-]+\.\w{1,5}/g);
-  const uniquePaths = paths ? [...new Set(paths)].slice(0, 5) : [];
+
+  // Path extraction: skip entirely if no '/' is present (cheap O(n) check
+  // via indexOf) to avoid PATH_RE's O(n²) backtracking on long runs of
+  // [\w.-] without a separator. Otherwise sample the first N KB.
+  let uniquePaths: string[] = [];
+  if (output.indexOf("/") !== -1) {
+    const pathScan =
+      output.length > ANNOTATION_PATH_SCAN_LIMIT
+        ? output.slice(0, ANNOTATION_PATH_SCAN_LIMIT)
+        : output;
+    const paths = pathScan.match(PATH_RE);
+    if (paths) uniquePaths = [...new Set(paths)].slice(0, 5);
+  }
 
   let annotation = `[output omitted — ${toolName}: ${lines} lines`;
   if (hasError) annotation += ", contained errors";
@@ -1113,7 +1282,20 @@ function transformInner(input: {
   // estimated at 146K passes layer 0 but actually costs 214K → overflow.
   const layer0Input = calibrated ? expectedInput : expectedInput * UNCALIBRATED_SAFETY;
 
-  if (effectiveMinLayer === 0 && layer0Input <= maxInput) {
+  // Cost-aware layer-0 cap: use the smaller of the API limit and the cost-derived
+  // cap. When maxLayer0Tokens is 0 (disabled), fall back to pure maxInput.
+  let layer0Ceiling = maxLayer0Tokens > 0
+    ? Math.min(maxInput, maxLayer0Tokens)
+    : maxInput;
+
+  // Cold-cache awareness: on the first turn (uncalibrated = no prior API data),
+  // the entire context is a cache WRITE at 12.5× the cache-read price. Use 70%
+  // of the normal cap to reduce the cold-write cost.
+  if (!calibrated && layer0Ceiling < maxInput) {
+    layer0Ceiling = Math.floor(layer0Ceiling * 0.7);
+  }
+
+  if (effectiveMinLayer === 0 && layer0Input <= layer0Ceiling) {
     // All messages fit — return unmodified to preserve append-only prompt-cache pattern.
     // Raw messages are strictly better context than lossy distilled summaries.
     const messageTokens = calibrated
@@ -1140,6 +1322,7 @@ function transformInner(input: {
   const turnStart = currentTurnStart(input.messages);
   const dedupMessages = deduplicateToolOutputs(input.messages, turnStart);
 
+
   const distillations = sid ? loadDistillations(input.projectPath, sid) : [];
 
   // Layer 1 uses the append-only cached prefix (Approach C) to keep the
@@ -1222,11 +1405,19 @@ function transformInner(input: {
     return { ...layer3!, layer: 3, usable, distilledBudget, rawBudget };
   }
 
-  // Layer 4: Emergency — last 2 distillations, last 3 raw messages with tool parts intact.
+  // Layer 4: Emergency — last 2 distillations + token-budget raw tail.
   // We do NOT strip tool parts here: doing so would cause an infinite tool-call loop because
   // the model would lose sight of its own in-progress tool calls and re-invoke them endlessly.
   // Instead, we aggressively drop old messages and rely on the `recall` tool (which the model
   // is always instructed to use) to retrieve any older details it needs.
+  //
+  // Token-budget tail (F7): instead of a fixed `slice(-3)`, size the raw
+  // tail using `clamp(usable * 0.25, 2_000, 8_000)` tokens — matching
+  // upstream OpenCode's tail-budget formula for compaction. The current
+  // agentic turn (from `currentTurnStart()`) is ALWAYS fully included even
+  // if it alone exceeds the tail budget — layer 4 is the terminal layer
+  // and must always return. Remaining budget is filled backward with older
+  // messages.
   urgentDistillation = true;
   const nuclearDistillations = distillations.slice(-2);
   const nuclearPrefix = distilledPrefix(nuclearDistillations);
@@ -1234,15 +1425,40 @@ function transformInner(input: {
     (sum, m) => sum + estimateMessage(m),
     0,
   );
-  const nuclearRaw = input.messages.slice(-3).map((m) => ({
+
+  // Token budget for the raw tail. clamp(usable * 0.25, 2K, 8K).
+  const tailBudget = Math.max(2_000, Math.min(8_000, Math.floor(usable * 0.25)));
+
+  // Current turn is always included (non-negotiable — dropping it causes
+  // the infinite tool-call loop). Clean parts but never strip tool outputs.
+  const nuclearTurnStart = currentTurnStart(input.messages);
+  const currentTurn = input.messages.slice(nuclearTurnStart).map((m) => ({
     info: m.info,
     parts: cleanParts(m.parts),
   }));
-  const nuclearRawTokens = nuclearRaw.reduce(
+  const currentTurnTokens = currentTurn.reduce(
     (sum, m) => sum + estimateMessage(m),
     0,
   );
 
+  // Fill remaining budget walking backward from the turn boundary.
+  const olderMessages: MessageWithParts[] = [];
+  let olderTokens = 0;
+  const remaining = Math.max(0, tailBudget - currentTurnTokens);
+  for (let i = nuclearTurnStart - 1; i >= 0 && olderTokens < remaining; i--) {
+    const msg = input.messages[i];
+    const est = estimateMessage(msg);
+    if (olderTokens + est > remaining) break;
+    olderMessages.unshift({
+      info: msg.info,
+      parts: cleanParts(msg.parts),
+    });
+    olderTokens += est;
+  }
+
+  const nuclearRaw = [...olderMessages, ...currentTurn];
+  const nuclearRawTokens = olderTokens + currentTurnTokens;
+
   return {
     messages: [...nuclearPrefix, ...nuclearRaw],
     layer: 4,
@@ -1282,6 +1498,45 @@ export function transform(input: {
     state.lastTransformEstimate = result.totalTokens;
     state.lastLayer = result.layer;
     state.lastWindowMessageIDs = new Set(result.messages.map((m) => m.info.id));
+    // Mark wall-clock for onIdleResume() — must record on every transform()
+    // so the next-turn idle check has an accurate baseline. Done after the
+    // result fields above so a thrown transformInner doesn't update it.
+    state.lastTurnAt = Date.now();
+
+    // --- Cache-bust diagnostics (LORE_DEBUG only) ---
+    // Track byte-identity of the message prefix. When the prefix hash changes
+    // between consecutive turns, it means Anthropic's prompt cache is invalidated
+    // and the entire context is re-written (12.5× cache-read price). This helps
+    // identify which code paths are breaking byte-identity.
+    const prefixIds = result.messages.slice(0, 5).map((m) => m.info.id).join(",");
+    const prefixHash = `${result.layer}:${prefixIds}`;
+    if (state.lastPrefixHash && state.lastPrefixHash !== prefixHash) {
+      log.info(
+        `cache-bust detected: session=${sid} layer=${state.lastLayer}→${result.layer}` +
+        ` msgs=${state.lastTransformedCount}→${result.messages.length}` +
+        ` prefix=${state.lastPrefixHash.slice(0, 30)}→${prefixHash.slice(0, 30)}`,
+      );
+    }
+    state.lastPrefixHash = prefixHash;
+
+    // --- Compaction hint ---
+    if (result.layer >= 2) {
+      state.consecutiveHighLayer++;
+      if (state.consecutiveHighLayer === 3) {
+        log.info(
+          `session ${sid} has been at gradient layer ${result.layer}+ for 3 consecutive turns.` +
+          ` Consider running /compact to reset the context window.`,
+        );
+      }
+    } else {
+      state.consecutiveHighLayer = 0;
+    }
+
+    log.info(
+      `gradient: session=${sid} layer=${result.layer} tokens=${result.totalTokens}` +
+      ` (distilled=${result.distilledTokens} raw=${result.rawTokens})` +
+      ` usable=${result.usable} cap=${maxLayer0Tokens || "off"}`,
+    );
   }
   return result;
 }
@@ -1291,21 +1546,54 @@ export function estimateMessages(messages: MessageWithParts[]): number {
   return messages.reduce((sum, m) => sum + estimateMessage(m), 0);
 }
 
-// Identify the current agentic turn: the last user message plus all subsequent
-// assistant messages that share its ID as parentID. These messages form an atomic
-// unit — the model must see all of them or it will lose track of its own prior
-// tool calls and re-issue them in an infinite loop.
+// Identify the current agentic turn: walk backwards from the end to find the
+// boundary where it's safe to strip tool outputs. The "current turn" includes:
+// 1. All messages from the last user message onwards (the explicit turn boundary)
+// 2. All messages that are part of an unfinished tool-call chain BEFORE that user
+//    message — because subagent/child user messages can appear mid-chain, and the
+//    parent's tool-call chain must be kept intact or the model re-issues tool calls.
+//
+// The heuristic: walk backwards from the last user message, and if we see assistant
+// messages with tool parts (tool-call chains), keep extending the boundary back.
+// Stop when we hit a user message that's followed by a non-tool assistant (a clean
+// conversational boundary, not a mid-chain subagent injection).
 function currentTurnStart(messages: MessageWithParts[]): number {
-  // Find the last user message
-  let lastUserIdx = -1;
+  if (messages.length === 0) return 0;
+
+  // Start from the last user message
+  let boundary = messages.length;
   for (let i = messages.length - 1; i >= 0; i--) {
     if (messages[i].info.role === "user") {
-      lastUserIdx = i;
+      boundary = i;
       break;
     }
   }
-  if (lastUserIdx === -1) return 0; // no user message — treat all as current turn
-  return lastUserIdx;
+  if (boundary === messages.length) return 0; // no user message — protect all
+
+  // Now walk backwards past any tool-call chains that precede this user message.
+  // A tool-call chain looks like: ...assistant(tool-calls) → user(subagent) → ...
+  // We keep extending boundary back while we see tool-bearing assistant messages.
+  for (let i = boundary - 1; i >= 0; i--) {
+    const msg = messages[i];
+    const hasToolParts = msg.parts.some(isToolPart);
+    if (hasToolParts) {
+      // This assistant message has tools — it's part of an active chain.
+      // Extend the boundary to include it.
+      boundary = i;
+      continue;
+    }
+    if (msg.info.role === "user") {
+      // A user message with no tool-bearing assistant before it — this might be
+      // another subagent injection. Keep walking back.
+      boundary = i;
+      continue;
+    }
+    // Non-tool assistant message (pure text response) — this is a clean boundary.
+    // The chain above this point is a completed conversation turn.
+    break;
+  }
+
+  return boundary;
 }
 
 function tryFit(input: {

package/src/index.ts

@@ -60,6 +60,8 @@ export {
 export {
   transform,
   setModelLimits,
+  setMaxLayer0Tokens,
+  computeLayer0Cap,
   needsUrgentDistillation,
   calibrate,
   setLtmTokens,
@@ -68,6 +70,13 @@ export {
   setForceMinLayer,
   getLastTransformedCount,
   getLastTransformEstimate,
+  toolStripAnnotation,
+  onIdleResume,
+  consumeCameOutOfIdle,
+  // Test-only — exposed at the barrel so host-package tests can simulate idle
+  // gaps without sleeping. Not part of the public API.
+  setLastTurnAtForTest,
+  inspectSessionState,
 } from "./gradient";
 export {
   formatKnowledge,
@@ -81,9 +90,16 @@ export {
   CONSOLIDATION_SYSTEM,
   consolidationUser,
   QUERY_EXPANSION_SYSTEM,
+  COMPACT_SUMMARY_TEMPLATE,
+  buildCompactPrompt,
 } from "./prompt";
 export { shouldImport, importFromFile, exportToFile } from "./agents-file";
 export { workerSessionIDs, isWorkerSession } from "./worker";
+export * as workerModel from "./worker-model";
+export {
+  WORKER_JUDGE_SYSTEM,
+  workerJudgeUser,
+} from "./worker-model";
 export {
   ftsQuery,
   ftsQueryOr,

package/src/lat-reader.ts

@@ -290,8 +290,8 @@ export function searchScored(input: {
   const ftsSQL = `SELECT s.id, s.project_id, s.file, s.heading, s.depth, s.content,
          s.content_hash, s.first_paragraph, s.updated_at,
          bm25(lat_sections_fts, 6.0, 2.0) as rank
-       FROM lat_sections s
-       JOIN lat_sections_fts f ON s.rowid = f.rowid
+       FROM lat_sections_fts f
+       CROSS JOIN lat_sections s ON s.rowid = f.rowid
        WHERE lat_sections_fts MATCH ?
        AND s.project_id = ?
        ORDER BY rank LIMIT ?`;
@@ -335,8 +335,8 @@ export function scoreForSession(
         `SELECT s.id, s.project_id, s.file, s.heading, s.depth, s.content,
                 s.content_hash, s.first_paragraph, s.updated_at,
                 bm25(lat_sections_fts, 6.0, 2.0) as rank
-         FROM lat_sections s
-         JOIN lat_sections_fts f ON s.rowid = f.rowid
+         FROM lat_sections_fts f
+         CROSS JOIN lat_sections s ON s.rowid = f.rowid
          WHERE lat_sections_fts MATCH ?
          AND s.project_id = ?
          ORDER BY rank`,

package/src/ltm.ts

@@ -215,11 +215,11 @@ function scoreEntriesFTS(sessionContext: string): Map<string, number> {
   try {
     const results = db()
       .query(
-        `SELECT k.id, bm25(knowledge_fts, ?, ?, ?) as rank
-         FROM knowledge k
-         JOIN knowledge_fts f ON k.rowid = f.rowid
-         WHERE knowledge_fts MATCH ?
-         AND k.confidence > 0.2`,
+         `SELECT k.id, bm25(knowledge_fts, ?, ?, ?) as rank
+          FROM knowledge_fts f
+          CROSS JOIN knowledge k ON k.rowid = f.rowid
+          WHERE knowledge_fts MATCH ?
+          AND k.confidence > 0.2`,
       )
       .all(title, content, category, q) as Array<{
       id: string;
@@ -460,14 +460,14 @@ export function search(input: {
   const pid = input.projectPath ? ensureProject(input.projectPath) : null;
 
   const ftsSQL = pid
-    ? `SELECT ${KNOWLEDGE_COLS_K} FROM knowledge k
-       JOIN knowledge_fts f ON k.rowid = f.rowid
+    ? `SELECT ${KNOWLEDGE_COLS_K} FROM knowledge_fts f
+       CROSS JOIN knowledge k ON k.rowid = f.rowid
        WHERE knowledge_fts MATCH ?
        AND (k.project_id = ? OR k.project_id IS NULL OR k.cross_project = 1)
        AND k.confidence > 0.2
        ORDER BY bm25(knowledge_fts, ?, ?, ?) LIMIT ?`
-    : `SELECT ${KNOWLEDGE_COLS_K} FROM knowledge k
-       JOIN knowledge_fts f ON k.rowid = f.rowid
+    : `SELECT ${KNOWLEDGE_COLS_K} FROM knowledge_fts f
+       CROSS JOIN knowledge k ON k.rowid = f.rowid
        WHERE knowledge_fts MATCH ?
        AND k.confidence > 0.2
        ORDER BY bm25(knowledge_fts, ?, ?, ?) LIMIT ?`;
@@ -517,14 +517,14 @@ export function searchScored(input: {
   const { title, content, category } = ftsWeights();
 
   const ftsSQL = pid
-    ? `SELECT ${KNOWLEDGE_COLS_K}, bm25(knowledge_fts, ?, ?, ?) as rank FROM knowledge k
-       JOIN knowledge_fts f ON k.rowid = f.rowid
+    ? `SELECT ${KNOWLEDGE_COLS_K}, bm25(knowledge_fts, ?, ?, ?) as rank FROM knowledge_fts f
+       CROSS JOIN knowledge k ON k.rowid = f.rowid
        WHERE knowledge_fts MATCH ?
        AND (k.project_id = ? OR k.project_id IS NULL OR k.cross_project = 1)
        AND k.confidence > 0.2
        ORDER BY rank LIMIT ?`
-    : `SELECT ${KNOWLEDGE_COLS_K}, bm25(knowledge_fts, ?, ?, ?) as rank FROM knowledge k
-       JOIN knowledge_fts f ON k.rowid = f.rowid
+    : `SELECT ${KNOWLEDGE_COLS_K}, bm25(knowledge_fts, ?, ?, ?) as rank FROM knowledge_fts f
+       CROSS JOIN knowledge k ON k.rowid = f.rowid
        WHERE knowledge_fts MATCH ?
        AND k.confidence > 0.2
        ORDER BY rank LIMIT ?`;
@@ -569,8 +569,8 @@ export function searchScoredOtherProjects(input: {
   // Find entries from other projects that are NOT cross-project (those are
   // already included in the normal search via the cross_project=1 filter).
   // Also exclude entries with no project_id (global) — already included.
-  const ftsSQL = `SELECT ${KNOWLEDGE_COLS_K}, bm25(knowledge_fts, ?, ?, ?) as rank FROM knowledge k
-     JOIN knowledge_fts f ON k.rowid = f.rowid
+  const ftsSQL = `SELECT ${KNOWLEDGE_COLS_K}, bm25(knowledge_fts, ?, ?, ?) as rank FROM knowledge_fts f
+     CROSS JOIN knowledge k ON k.rowid = f.rowid
      WHERE knowledge_fts MATCH ?
      AND k.project_id IS NOT NULL
      AND k.project_id != ?
@@ -819,8 +819,8 @@ export function check(projectPath: string): IntegrityIssue[] {
       const { title, content, category } = config().search.ftsWeights;
       const matches = db()
         .query(
-          `SELECT k.id, k.title FROM knowledge k
-           JOIN knowledge_fts f ON k.rowid = f.rowid
+          `SELECT k.id, k.title FROM knowledge_fts f
+           CROSS JOIN knowledge k ON k.rowid = f.rowid
            WHERE knowledge_fts MATCH ?
            AND k.id != ?
            AND k.confidence > 0.2