@loreai/core 0.15.0 → 0.17.0

package/src/git.ts

@@ -0,0 +1,144 @@
+/**
+ * git.ts — Git repository identification utilities.
+ *
+ * Extracts and normalizes git remote URLs to identify projects by their
+ * repository identity rather than filesystem path. This enables:
+ *  - Worktree awareness: main checkout and worktrees share one project
+ *  - Clone deduplication: same repo cloned to different paths is one project
+ *  - Fork awareness: prefers `upstream` remote to unify forks with their source
+ *
+ * Remote URL normalization strips protocol, auth, and `.git` suffix to produce
+ * a stable canonical identifier (e.g. "github.com/user/repo") regardless of
+ * how the remote was configured (SSH, HTTPS, git://).
+ */
+
+import { execSync } from "child_process";
+
+// ---------------------------------------------------------------------------
+// URL normalization
+// ---------------------------------------------------------------------------
+
+/**
+ * Normalize a git remote URL to a canonical form for comparison.
+ *
+ * Strips protocol, auth, `.git` suffix, and normalizes SSH ↔ HTTPS
+ * to produce a stable identifier regardless of how the remote was
+ * configured.
+ *
+ * Examples:
+ *   git@github.com:user/repo.git     → github.com/user/repo
+ *   https://github.com/user/repo.git → github.com/user/repo
+ *   ssh://git@github.com/user/repo   → github.com/user/repo
+ *   git://github.com/user/repo.git   → github.com/user/repo
+ *   https://user:token@github.com/user/repo → github.com/user/repo
+ */
+export function normalizeRemoteUrl(url: string): string {
+  let normalized = url.trim();
+
+  // SSH shorthand: git@host:user/repo.git → host/user/repo
+  const sshMatch = normalized.match(/^[\w.-]+@([\w.-]+):(.+)$/);
+  if (sshMatch) {
+    normalized = `${sshMatch[1]}/${sshMatch[2]}`;
+  } else {
+    // Strip protocol (https://, http://, ssh://, git://)
+    normalized = normalized.replace(/^[\w+]+:\/\//, "");
+    // Strip auth (user@, user:pass@)
+    normalized = normalized.replace(/^[^@/]+@/, "");
+  }
+
+  // Strip .git suffix
+  normalized = normalized.replace(/\.git$/, "");
+  // Strip trailing slashes
+  normalized = normalized.replace(/\/+$/, "");
+  // Lowercase the host portion for case-insensitive comparison.
+  // Host is everything before the first `/`.
+  const slashIdx = normalized.indexOf("/");
+  if (slashIdx > 0) {
+    normalized =
+      normalized.slice(0, slashIdx).toLowerCase() + normalized.slice(slashIdx);
+  } else {
+    normalized = normalized.toLowerCase();
+  }
+
+  return normalized;
+}
+
+// ---------------------------------------------------------------------------
+// Remote extraction
+// ---------------------------------------------------------------------------
+
+/**
+ * In-memory cache for git remote lookups. Keyed by absolute path, values are
+ * normalized remote URLs (or null for non-git directories). Prevents repeated
+ * subprocess spawns for the same path within a single process lifetime.
+ */
+const gitRemoteCache = new Map<string, string | null>();
+
+/**
+ * Clear the in-memory git remote cache.
+ *
+ * Intended for test harnesses that need deterministic behavior across
+ * test cases without leaking cached results.
+ */
+export function clearGitRemoteCache(): void {
+  gitRemoteCache.clear();
+}
+
+/**
+ * Get the canonical git remote URL for a repository at the given path.
+ *
+ * Prefers `upstream` remote (for forks) over `origin`, then falls back
+ * to any other remote. Returns null if the path is not in a git repo
+ * or has no remotes configured.
+ *
+ * Results are cached in-memory for the process lifetime to avoid repeated
+ * subprocess calls — `git remote -v` only runs once per unique path.
+ */
+export function getGitRemote(path: string): string | null {
+  const cached = gitRemoteCache.get(path);
+  if (cached !== undefined) return cached;
+
+  try {
+    // git remote -v outputs lines like:
+    //   origin  git@github.com:user/repo.git (fetch)
+    //   upstream  https://github.com/org/repo.git (fetch)
+    const output = execSync("git remote -v", {
+      cwd: path,
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"], // suppress stderr
+    });
+
+    const remotes = new Map<string, string>();
+    for (const line of output.split("\n")) {
+      // Only parse fetch URLs (avoid duplicates from push lines)
+      const match = line.match(/^(\S+)\s+(\S+)\s+\(fetch\)$/);
+      if (match) {
+        remotes.set(match[1], match[2]);
+      }
+    }
+
+    if (remotes.size === 0) {
+      gitRemoteCache.set(path, null);
+      return null;
+    }
+
+    // Prefer upstream (fork source) > origin > any other
+    const url =
+      remotes.get("upstream") ??
+      remotes.get("origin") ??
+      remotes.values().next().value;
+    if (!url) {
+      gitRemoteCache.set(path, null);
+      return null;
+    }
+
+    const result = normalizeRemoteUrl(url);
+    gitRemoteCache.set(path, result);
+    return result;
+  } catch {
+    // Not a git repo, git not installed, timeout, etc.
+    gitRemoteCache.set(path, null);
+    return null;
+  }
+}

package/src/gradient.ts

@@ -46,6 +46,127 @@ let maxLayer0Tokens = 0;
 
 const MIN_LAYER0_FLOOR = 40_000;
 
+// ---------------------------------------------------------------------------
+// Cost-aware context token cap (layer 1+)
+//
+// Limits total tokens (distilled + raw) to keep per-bust cache write cost
+// bounded. For opus-4-6 at $6.25/M write, a $1.00 target yields a 160K cap.
+// For sonnet-4 at $3.75/M write, the cap is 267K (effectively uncapped).
+//
+// The cap is further adjusted dynamically per session via bust rate EMA and
+// inter-bust interval tracking: tighten when busts are frequent, relax when
+// the cache is working well. Asymmetric rates: tighten fast, relax slowly.
+// ---------------------------------------------------------------------------
+
+/** Static ceiling for total context tokens, derived from model pricing.
+ *  0 = disabled (no cap). Set via setMaxContextTokens(). */
+let maxContextTokensCeiling = 0;
+
+const MIN_CONTEXT_FLOOR = 130_000;
+
+/** Compute the context ceiling from a per-bust cost target and cache-write price per token. */
+export function computeContextCap(
+  targetBustCost: number,
+  cacheWriteCostPerToken: number,
+): number {
+  if (targetBustCost <= 0 || cacheWriteCostPerToken <= 0) return 0;
+  return Math.max(MIN_CONTEXT_FLOOR, Math.floor(targetBustCost / cacheWriteCostPerToken));
+}
+
+/** Set the static context ceiling. Called by the host adapter after computing
+ *  from model pricing. The effective per-session cap may be lower due to
+ *  dynamic adaptation (bust rate EMA). */
+export function setMaxContextTokens(tokens: number) {
+  maxContextTokensCeiling = Math.max(0, Math.floor(tokens));
+}
+
+/** Returns the current static ceiling (for external callers / tests). */
+export function getMaxContextTokens(): number {
+  return maxContextTokensCeiling;
+}
+
+/**
+ * Feed cache usage data after each API response. Updates the per-session
+ * bust rate EMA and inter-bust interval, which adjust the effective context
+ * cap dynamically.
+ *
+ * @param cacheWrite - cache_creation_input_tokens from the API response
+ * @param cacheRead  - cache_read_input_tokens from the API response
+ * @param sessionID  - session that produced this response
+ */
+export function updateBustRate(
+  cacheWrite: number,
+  cacheRead: number,
+  sessionID?: string,
+): void {
+  if (!sessionID) return;
+  const state = getSessionState(sessionID);
+  const total = cacheWrite + cacheRead;
+  if (total === 0) return;
+
+  // Bust ratio: fraction of total input that was cache-written (0 = all reads, 1 = all writes)
+  const bustRatio = cacheWrite / total;
+
+  // EMA update (α = 0.3 for smoothing — responsive but not twitchy)
+  state.bustRateEMA =
+    state.bustRateEMA < 0
+      ? bustRatio  // first observation
+      : state.bustRateEMA * 0.7 + bustRatio * 0.3;
+
+  // Inter-bust interval tracking: a "bust" is when >50% of input is writes
+  const now = Date.now();
+  if (bustRatio > 0.5) {
+    if (state.lastBustAt > 0) {
+      const interval = now - state.lastBustAt;
+      state.interBustIntervalEMA =
+        state.interBustIntervalEMA < 0
+          ? interval
+          : state.interBustIntervalEMA * 0.7 + interval * 0.3;
+    }
+    state.lastBustAt = now;
+  }
+
+  // Adapt per-session cap based on bust rate and interval
+  adaptContextCap(state);
+}
+
+/** Adapt the per-session context cap based on bust rate and break frequency. */
+function adaptContextCap(state: SessionState): void {
+  if (maxContextTokensCeiling <= 0) return; // disabled
+
+  const cap = state.dynamicContextCap > 0
+    ? state.dynamicContextCap
+    : maxContextTokensCeiling;
+
+  let newCap = cap;
+
+  // Primary signal: bust rate EMA
+  if (state.bustRateEMA > 0.8) {
+    // Mostly writes — tighten by 10%
+    newCap = Math.floor(cap * 0.90);
+  } else if (state.bustRateEMA < 0.3) {
+    // Mostly reads — relax by 5% (slower than tightening)
+    newCap = Math.floor(cap * 1.05);
+  }
+
+  // Secondary signal: inter-bust interval
+  if (state.interBustIntervalEMA > 0) {
+    if (state.interBustIntervalEMA < 2 * 60_000) {
+      // Busts less than 2 min apart — proactively tighten by extra 5%
+      newCap = Math.floor(newCap * 0.95);
+    } else if (state.interBustIntervalEMA > 10 * 60_000) {
+      // Busts more than 10 min apart — allow extra relaxation
+      newCap = Math.floor(newCap * 1.03);
+    }
+  }
+
+  // Clamp to [floor, ceiling]
+  state.dynamicContextCap = Math.max(
+    MIN_CONTEXT_FLOOR,
+    Math.min(maxContextTokensCeiling, newCap),
+  );
+}
+
 // 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;
@@ -133,6 +254,18 @@ type SessionState = {
   /** Consecutive turns at layer >= 2. When >= 3, log a compaction hint. */
   consecutiveHighLayer: number;
 
+  // --- Cost-aware context cap dynamic state ---
+
+  /** EMA of bust ratio (cacheWrite / total). -1 = uninitialized. */
+  bustRateEMA: number;
+  /** EMA of time between full busts (ms). -1 = uninitialized. */
+  interBustIntervalEMA: number;
+  /** Epoch ms of the last full bust (cacheWrite > 50% of total). 0 = never. */
+  lastBustAt: number;
+  /** Per-session dynamic context cap (tokens). Adjusted by adaptContextCap().
+   *  0 = use the static ceiling (maxContextTokensCeiling). */
+  dynamicContextCap: number;
+
   /**
    * Distillation row snapshot — cached to avoid hitting the DB on every
    * transform() call. Refreshed only at turn boundaries (when a new user
@@ -166,6 +299,11 @@ function makeSessionState(): SessionState {
     postIdleCompact: false,
     consecutiveHighLayer: 0,
 
+    bustRateEMA: -1,
+    interBustIntervalEMA: -1,
+    lastBustAt: 0,
+    dynamicContextCap: 0,
+
     distillationSnapshot: null,
   };
 }
@@ -978,7 +1116,7 @@ function buildPrefixMessages(formatted: string): MessageWithParts[] {
           sessionID: "",
           messageID: "lore-distilled-assistant",
           type: "text" as const,
-          text: formatted + "\n\nI'm ready to continue.",
+          text: formatted,
           time: { start: 0, end: 0 },
         },
       ],
@@ -1291,11 +1429,13 @@ export type TransformResult = {
   rawBudget: number;
 };
 
-// Signal that we need urgent distillation
-let urgentDistillation = false;
-export function needsUrgentDistillation(): boolean {
-  const v = urgentDistillation;
-  urgentDistillation = false;
+// Per-session urgent distillation tracking.
+// Keyed by sessionID. Set by layer returns in transformInner(),
+// consumed (read + delete) by needsUrgentDistillation(sessionID).
+const urgentDistillationMap = new Map<string, boolean>();
+export function needsUrgentDistillation(sessionID: string): boolean {
+  const v = urgentDistillationMap.get(sessionID) ?? false;
+  urgentDistillationMap.delete(sessionID);
   return v;
 }
 
@@ -1315,10 +1455,23 @@ function transformInner(input: {
   // minus LTM tokens already injected into the system prompt this turn.
   // Read LTM tokens from per-session state to avoid cross-session contamination.
   const sessLtmTokens = sid ? sessState.ltmTokens : ltmTokensFallback;
-  const usable = Math.max(
+  const usableRaw = Math.max(
     0,
     contextLimit - outputReserved - overhead - sessLtmTokens,
   );
+
+  // Cost-aware context cap: limit total distilled + raw tokens to keep
+  // per-bust cache write cost bounded. On opus-4-6 at $6.25/M, a $1.00
+  // target yields a 160K ceiling; on sonnet-4 at $3.75/M, 267K (effectively
+  // uncapped at 200K context). Per-session dynamic adaptation may reduce
+  // this further based on observed bust rate and break frequency.
+  const effectiveCap = sid && sessState.dynamicContextCap > 0
+    ? sessState.dynamicContextCap
+    : maxContextTokensCeiling;
+  const usable = effectiveCap > 0 && usableRaw > effectiveCap
+    ? effectiveCap
+    : usableRaw;
+
   const distilledBudget = Math.floor(usable * cfg.budget.distilled);
   // Base raw budget. May be overridden below for post-idle compact mode.
   let rawBudget = Math.floor(usable * cfg.budget.raw);
@@ -1385,12 +1538,11 @@ function transformInner(input: {
     sessState.postIdleCompact = false;
     // Skip layer 0 — don't pass through all raw messages on a cold cache.
     effectiveMinLayer = Math.max(effectiveMinLayer, 1) as SafetyLayer;
-    // Use a tighter raw budget: 20% of usable instead of the normal 40%.
-    // The distilled prefix covers the older history; the raw window only
-    // needs the current turn + minimal recent context. This reduces the
-    // total cold-cache write cost by up to 20% of usable (~29K tokens on
-    // a 200K context model).
-    rawBudget = Math.floor(usable * 0.20);
+    // Use a tighter raw budget. When the cost-aware context cap is active,
+    // total write size is already bounded — use a moderate 30%. Without
+    // the cap, use a tighter 20% to limit cold-write cost directly.
+    const postIdleRawFraction = effectiveCap > 0 ? 0.30 : 0.20;
+    rawBudget = Math.floor(usable * postIdleRawFraction);
     log.info(
       `post-idle compact: session=${sid} rawBudget=${rawBudget}` +
       ` (${Math.floor(usable * cfg.budget.raw)}→${rawBudget})`,
@@ -1500,7 +1652,12 @@ function transformInner(input: {
           rawBudget,
           strip: "none",
         });
-    if (fitsWithSafetyMargin(layer1)) return { ...layer1!, layer: 1, usable, distilledBudget, rawBudget };
+    if (fitsWithSafetyMargin(layer1)) {
+      if (cached.tokens === 0 && sid) {
+        urgentDistillationMap.set(sid, true);
+      }
+      return { ...layer1!, layer: 1, usable, distilledBudget, rawBudget };
+    }
   }
 
   // Layer 1 didn't fit (or was force-skipped) — reset the raw window cache.
@@ -1520,7 +1677,7 @@ function transformInner(input: {
       protectedTurns: 2,
     });
     if (fitsWithSafetyMargin(layer2)) {
-      urgentDistillation = true;
+      if (sid) urgentDistillationMap.set(sid, true);
       return { ...layer2!, layer: 2, usable, distilledBudget, rawBudget };
     }
   }
@@ -1541,7 +1698,7 @@ function transformInner(input: {
     strip: "all-tools",
   });
   if (fitsWithSafetyMargin(layer3)) {
-    urgentDistillation = true;
+    if (sid) urgentDistillationMap.set(sid, true);
     return { ...layer3!, layer: 3, usable, distilledBudget, rawBudget };
   }
 
@@ -1558,7 +1715,7 @@ function transformInner(input: {
   // 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;
+  if (sid) urgentDistillationMap.set(sid, true);
   const nuclearDistillations = distillations.slice(-2);
   const nuclearPrefix = distilledPrefix(nuclearDistillations);
   const nuclearPrefixTokens = nuclearPrefix.reduce(

package/src/index.ts

@@ -11,21 +11,27 @@
 
 export * as temporal from "./temporal";
 export * as ltm from "./ltm";
+export * as data from "./data";
 export * as distillation from "./distillation";
 export * as curator from "./curator";
 export * as embedding from "./embedding";
+export * as embeddingVendor from "./embedding-vendor";
 export * as latReader from "./lat-reader";
 export * as patternExtract from "./pattern-extract";
 export * as log from "./log";
 
 export {
   runRecall,
+  searchRecall,
+  recallById,
   RECALL_TOOL_DESCRIPTION,
   RECALL_PARAM_DESCRIPTIONS,
   type RecallInput,
   type RecallResult,
   type RecallScope,
   type ScoredDistillation,
+  type TaggedResult,
+  type ScoredTaggedResult,
 } from "./recall";
 
 export type {
@@ -50,22 +56,33 @@ export { isTextPart, isReasoningPart, isToolPart } from "./types";
 export { load, config, type LoreConfig } from "./config";
 export {
   db,
+  dbPath,
   ensureProject,
   isFirstRun,
   projectId,
   projectName,
+  mergeProjectInternal,
   loadForceMinLayer,
   saveForceMinLayer,
+  saveSessionCosts,
+  loadSessionCosts,
+  loadAllSessionCosts,
+  type SessionCostSnapshot,
   getMeta,
   setMeta,
   getInstanceId,
   close,
 } from "./db";
+export { normalizeRemoteUrl, getGitRemote, clearGitRemoteCache } from "./git";
 export {
   transform,
   setModelLimits,
   setMaxLayer0Tokens,
   computeLayer0Cap,
+  setMaxContextTokens,
+  computeContextCap,
+  getMaxContextTokens,
+  updateBustRate,
   needsUrgentDistillation,
   calibrate,
   setLtmTokens,
@@ -106,6 +123,7 @@ export {
   importLoreFile,
   shouldImportLoreFile,
   loreFileExists,
+  clearLoreFileCache,
   LORE_FILE,
 } from "./agents-file";
 export { workerSessionIDs, isWorkerSession } from "./worker";
@@ -113,6 +131,7 @@ export * as workerModel from "./worker-model";
 export {
   ftsQuery,
   ftsQueryOr,
+  ftsQueryRelaxed,
   EMPTY_QUERY,
   reciprocalRankFusion,
   expandQuery,
@@ -133,4 +152,5 @@ export {
   normalize,
   sanitizeSurrogates,
   unescapeMarkdown,
+  renderMarkdown,
 } from "./markdown";

package/src/lat-reader.ts

@@ -15,7 +15,7 @@ import { remark } from "remark";
 import type { Root, Heading, Paragraph, Text } from "mdast";
 import { db, ensureProject } from "./db";
 import { sha256 } from "#db/driver";
-import { ftsQuery, ftsQueryOr, extractTopTerms, EMPTY_QUERY } from "./search";
+import { ftsQuery, extractTopTerms, EMPTY_QUERY, runRelaxedSearch } from "./search";
 import * as log from "./log";
 
 const processor = remark();
@@ -274,7 +274,7 @@ export function refresh(projectPath: string): number {
 
 /**
  * Search lat sections by FTS5 with BM25 scoring.
- * Uses AND-then-OR fallback (same pattern as knowledge search).
+ * Uses progressive AND relaxation before falling back to OR.
  */
 export function searchScored(input: {
   query: string;
@@ -282,8 +282,6 @@ export function searchScored(input: {
   limit?: number;
 }): ScoredLatSection[] {
   const limit = input.limit ?? 10;
-  const q = ftsQuery(input.query);
-  if (q === EMPTY_QUERY) return [];
 
   const pid = ensureProject(input.projectPath);
 
@@ -297,13 +295,9 @@ export function searchScored(input: {
        ORDER BY rank LIMIT ?`;
 
   try {
-    const results = db().query(ftsSQL).all(q, pid, limit) as ScoredLatSection[];
-    if (results.length) return results;
-
-    // AND returned nothing — try OR fallback
-    const qOr = ftsQueryOr(input.query);
-    if (qOr === EMPTY_QUERY) return [];
-    return db().query(ftsSQL).all(qOr, pid, limit) as ScoredLatSection[];
+    return runRelaxedSearch(input.query, (matchExpr) =>
+      db().query(ftsSQL).all(matchExpr, pid, limit) as ScoredLatSection[],
+    );
   } catch {
     return [];
   }

package/src/ltm.ts

@@ -1,7 +1,7 @@
 import { uuidv7 } from "uuidv7";
 import { db, ensureProject } from "./db";
 import { config } from "./config";
-import { ftsQuery, ftsQueryOr, EMPTY_QUERY, extractTopTerms } from "./search";
+import { ftsQuery, EMPTY_QUERY, extractTopTerms, runRelaxedSearch } from "./search";
 import * as embedding from "./embedding";
 import * as latReader from "./lat-reader";
 import * as log from "./log";
@@ -454,8 +454,6 @@ export function search(input: {
   limit?: number;
 }): KnowledgeEntry[] {
   const limit = input.limit ?? 20;
-  const q = ftsQuery(input.query);
-  if (q === EMPTY_QUERY) return [];
 
   const pid = input.projectPath ? ensureProject(input.projectPath) : null;
 
@@ -473,22 +471,14 @@ export function search(input: {
        ORDER BY bm25(knowledge_fts, ?, ?, ?) LIMIT ?`;
 
   const { title, content, category } = ftsWeights();
-  const ftsParams = pid
-    ? [q, pid, title, content, category, limit]
-    : [q, title, content, category, limit];
 
   try {
-    const results = db().query(ftsSQL).all(...ftsParams) as KnowledgeEntry[];
-    if (results.length) return results;
-
-    // AND returned nothing — try OR fallback for broader recall
-    const qOr = ftsQueryOr(input.query);
-    if (qOr === EMPTY_QUERY) return [];
-
-    const ftsParamsOr = pid
-      ? [qOr, pid, title, content, category, limit]
-      : [qOr, title, content, category, limit];
-    return db().query(ftsSQL).all(...ftsParamsOr) as KnowledgeEntry[];
+    return runRelaxedSearch(input.query, (matchExpr) => {
+      const params = pid
+        ? [matchExpr, pid, title, content, category, limit]
+        : [matchExpr, title, content, category, limit];
+      return db().query(ftsSQL).all(...params) as KnowledgeEntry[];
+    });
   } catch {
     return searchLike({
       query: input.query,
@@ -510,8 +500,6 @@ export function searchScored(input: {
   limit?: number;
 }): ScoredKnowledgeEntry[] {
   const limit = input.limit ?? 20;
-  const q = ftsQuery(input.query);
-  if (q === EMPTY_QUERY) return [];
 
   const pid = input.projectPath ? ensureProject(input.projectPath) : null;
   const { title, content, category } = ftsWeights();
@@ -529,20 +517,13 @@ export function searchScored(input: {
        AND k.confidence > 0.2
        ORDER BY rank LIMIT ?`;
 
-  const ftsParams = pid
-    ? [title, content, category, q, pid, limit]
-    : [title, content, category, q, limit];
-
   try {
-    const results = db().query(ftsSQL).all(...ftsParams) as ScoredKnowledgeEntry[];
-    if (results.length) return results;
-
-    const qOr = ftsQueryOr(input.query);
-    if (qOr === EMPTY_QUERY) return [];
-    const ftsParamsOr = pid
-      ? [title, content, category, qOr, pid, limit]
-      : [title, content, category, qOr, limit];
-    return db().query(ftsSQL).all(...ftsParamsOr) as ScoredKnowledgeEntry[];
+    return runRelaxedSearch(input.query, (matchExpr) => {
+      const params = pid
+        ? [title, content, category, matchExpr, pid, limit]
+        : [title, content, category, matchExpr, limit];
+      return db().query(ftsSQL).all(...params) as ScoredKnowledgeEntry[];
+    });
   } catch {
     return [];
   }
@@ -560,8 +541,6 @@ export function searchScoredOtherProjects(input: {
   limit?: number;
 }): ScoredKnowledgeEntry[] {
   const limit = input.limit ?? 10;
-  const q = ftsQuery(input.query);
-  if (q === EMPTY_QUERY) return [];
 
   const excludePid = ensureProject(input.excludeProjectPath);
   const { title, content, category } = ftsWeights();
@@ -578,17 +557,11 @@ export function searchScoredOtherProjects(input: {
      AND k.confidence > 0.2
      ORDER BY rank LIMIT ?`;
 
-  const ftsParams = [title, content, category, q, excludePid, limit];
-
   try {
-    const results = db().query(ftsSQL).all(...ftsParams) as ScoredKnowledgeEntry[];
-    if (results.length) return results;
-
-    // AND returned nothing — try OR fallback
-    const qOr = ftsQueryOr(input.query);
-    if (qOr === EMPTY_QUERY) return [];
-    const ftsParamsOr = [title, content, category, qOr, excludePid, limit];
-    return db().query(ftsSQL).all(...ftsParamsOr) as ScoredKnowledgeEntry[];
+    return runRelaxedSearch(input.query, (matchExpr) => {
+      const params = [title, content, category, matchExpr, excludePid, limit];
+      return db().query(ftsSQL).all(...params) as ScoredKnowledgeEntry[];
+    });
   } catch {
     return [];
   }

package/src/markdown.ts

@@ -1,3 +1,4 @@
+import { micromark } from "micromark";
 import { remark } from "remark";
 import type {
   Root,
@@ -127,3 +128,17 @@ export function strong(value: string): Strong {
 export function root(...children: Root["children"]): Root {
   return { type: "root", children };
 }
+
+/**
+ * Render a markdown string to sanitized HTML.
+ *
+ * Uses micromark with default options:
+ * - Raw HTML in input is escaped (no allowDangerousHtml)
+ * - Only safe URL protocols are permitted (no allowDangerousProtocol)
+ *
+ * The output is safe to embed directly in an HTML page without
+ * additional escaping.
+ */
+export function renderMarkdown(md: string): string {
+  return micromark(md);
+}

package/src/prompt.ts

@@ -446,8 +446,7 @@ Rules:
 - Keep every section, even when empty.
 - Use terse bullets, not prose paragraphs.
 - Preserve exact file paths, commands, error strings, and identifiers when known.
-- Do not mention the summary process or that context was compacted.
-- End with "I'm ready to continue." on its own line after the closing "---".`;
+- Do not mention the summary process or that context was compacted.`;
 
 // Build the user-facing prompt passed to the compaction agent during /compact.
 // Lore injects pre-computed distillations as context separately; this prompt