recallnest 2.5.4 → 2.6.0

package/src/context-composer-stable-selection.ts

@@ -162,7 +162,13 @@ function formatStableResult(category: StableCategory, result: RetrievalResult):
   // F1: Tag low-confidence memories in resume_context output
   const conf = getConfidence(result.entry);
   const tag = conf < 0.5 ? " [低置信]" : "";
-  return cleanText(`${STABLE_CATEGORY_LABELS[category]}: ${text}${tag}`, 230);
+  // 220 是 stableContext 的 schema 上限（session-schema.ts:61），不是随手写的数：
+  // 这里曾是 230，比上限大 10，而 interleaveUnique（context-composer-stable.ts:199-206）
+  // 不再截一次 —— 于是任何 221~230 字符的行都会让 composeResumeContext 末尾的
+  // ResumeContextResponseSchema.parse（context-composer.ts:541）抛
+  // "stableContext must be at most 220 characters"，整个 resume_context 调用失败。
+  // 改这个数之前先看 schema，两边必须一起动。
+  return cleanText(`${STABLE_CATEGORY_LABELS[category]}: ${text}${tag}`, 220);
 }
 
 export function selectStableResults(

package/src/data-checkup.ts

@@ -98,7 +98,7 @@ function checkOrphanMemories(entries: MemoryEntry[]): CheckResult {
 function checkTierDistribution(entries: MemoryEntry[]): CheckResult {
   const tierCounts: Record<MemoryTier, number> = { core: 0, working: 0, peripheral: 0 };
   for (const e of entries) {
-    const tier = resolveTier(e.metadata);
+    const tier = resolveTier(e.metadata, e.importance);
     tierCounts[tier]++;
   }
 

package/src/decay-engine.ts

@@ -122,26 +122,63 @@ export function computeArousalBoost(
 // HP-7: Decay Exemptions
 // ============================================================================
 
+/**
+ * Categories whose entries are procedural memory (knowing *how*), not declarative.
+ *
+ * Only `patterns` qualifies: RecallNest's skill schema stores skills under
+ * `category = "patterns"` (see memory-schema.ts), so this covers both workflow
+ * patterns and skills.
+ *
+ * `cases` is deliberately NOT here. A case is a problem/solution pair with a real
+ * episodic component ("that CI failure on 07-24"), and its solution can go stale
+ * when the underlying tool changes — it *should* decay. Procedural rules do not:
+ * see the "什么该衰减" discussion in hippo [[条件失效优于时间衰减]].
+ */
+export const PROCEDURAL_CATEGORIES = new Set<string>(["patterns"]);
+
 /**
  * Check if a memory should be exempt from time decay.
  * Exempt entries keep their original score without time-based penalties.
  *
  * Exemption rules:
+ * 0. Procedural category → knowing-how doesn't fade with wall-clock time
  * 1. Core tier + high importance (≥ 0.95) → identity/correction, must not fade
  * 2. Recently accessed (within 7 days) → actively used, not stale
  * 3. Pinned → user explicitly marked as persistent
+ *
+ * @param category Optional entry category. Omitting it preserves the pre-Rule-0
+ *                 behaviour exactly, so existing callers stay valid.
  */
 export function isDecayExempt(
   metadata: string | undefined,
   importance: number,
+  category?: string,
 ): boolean {
+  // Rule 0: Procedural memory is exempt from *time* decay.
+  //
+  // Rules 1-3 all key off access statistics or explicit user action, which
+  // systematically punishes procedural memory: its defining trait is low access
+  // frequency + long validity ("restart launchd with bootout+sleep+bootstrap" may
+  // be needed once a quarter but is correct every time). Combined with `patterns`
+  // carrying the highest retrieval threshold in DEFAULT_CATEGORY_MIN_SCORES (0.45),
+  // that produced a feedback trap: ranked lower → read less → ranked lower still.
+  //
+  // Cognitive-science backing: procedural memory is non-declarative (Squire) and is
+  // the most decay-resistant human memory type — a different curve, not a slower one.
+  //
+  // NOTE: this exempts from *time* decay only. Procedural memory still expires, but
+  // by condition (its premise changed), not by age. Deliberately checked before the
+  // `!metadata` guard so entries without metadata are still covered.
+  if (category !== undefined && PROCEDURAL_CATEGORIES.has(category)) return true;
+
   if (!metadata) return false;
 
   try {
     const meta = JSON.parse(metadata) as Record<string, unknown>;
 
     // Rule 1: Core + very high importance
-    const tier = meta.tier ?? resolveTierFromMeta(meta);
+    // importance 是本函数的入参（来自 entry 列），一并传下去——否则 heuristic 读不到它。
+    const tier = meta.tier ?? resolveTierFromMeta(meta, importance);
     if (tier === "core" && importance >= 0.95) return true;
 
     // Rule 2: Accessed within last 7 days
@@ -158,12 +195,21 @@ export function isDecayExempt(
   }
 }
 
-/** Internal helper: resolve tier from parsed metadata (avoids re-parsing). */
-function resolveTierFromMeta(meta: Record<string, unknown>): MemoryTier {
+/**
+ * Internal helper: resolve tier from parsed metadata (avoids re-parsing).
+ *
+ * `entryImportance` 是 MemoryEntry 的列字段。必须由调用方传进来：importance 不存在
+ * 于 metadata（accessCount / lastAccessedAt / tier 才是 access-tracker 写在顶层的），
+ * 所以只读 meta.importance 会恒等于 0，让所有还没有显式 tier 的条目一律落到
+ * peripheral——2026-07 实测全库 3214 条走这个分支，顶层有 importance 的是 0 条。
+ */
+function resolveTierFromMeta(meta: Record<string, unknown>, entryImportance?: number): MemoryTier {
   if (meta.tier === "core" || meta.tier === "working" || meta.tier === "peripheral") {
     return meta.tier;
   }
-  const imp = typeof meta.importance === "number" ? meta.importance : 0;
+  const imp = typeof meta.importance === "number"
+    ? meta.importance
+    : (typeof entryImportance === "number" ? entryImportance : 0);
   const ac = typeof meta.accessCount === "number" ? meta.accessCount : 0;
   if (imp >= 0.95 || ac >= 10) return "core";
   if (imp >= 0.8 || ac >= 3) return "working";
@@ -178,13 +224,13 @@ function resolveTierFromMeta(meta: Record<string, unknown>): MemoryTier {
  * Determine a memory's current tier from its metadata.
  * Falls back to heuristic based on importance if no tier is stored.
  */
-export function resolveTier(metadata?: string): MemoryTier {
+export function resolveTier(metadata?: string, entryImportance?: number): MemoryTier {
   if (!metadata) return "peripheral";
 
   try {
     const meta = JSON.parse(metadata) as Record<string, unknown>;
 
-    // Explicit tier stored in metadata
+    // Explicit tier stored in metadata（access-tracker 算过一次就会写在这里）
     if (meta.tier === "core" || meta.tier === "working" || meta.tier === "peripheral") {
       return meta.tier;
     }
@@ -193,7 +239,13 @@ export function resolveTier(metadata?: string): MemoryTier {
     // - Pinned assets (importance ≥ 0.95) → core
     // - High importance (≥ 0.8) → working
     // - Everything else → peripheral
-    const importance = typeof meta.importance === "number" ? meta.importance : 0;
+    //
+    // importance 优先取调用方传入的 entry 列值。metadata 里没有这个字段——顶层住着的是
+    // accessCount / lastAccessedAt / tier（access-tracker 写的），importance 从来不在。
+    // 不传就只能退回 0，那会把所有还没被访问过的条目一律压成 peripheral。
+    const importance = typeof meta.importance === "number"
+      ? meta.importance
+      : (typeof entryImportance === "number" ? entryImportance : 0);
     const accessCount = typeof meta.accessCount === "number" ? meta.accessCount : 0;
 
     if (importance >= 0.95 || accessCount >= 10) return "core";

package/src/doctor.ts

@@ -14,7 +14,7 @@ import { existsSync, accessSync, constants, readFileSync } from "node:fs";
 import { resolve, join } from "node:path";
 import { homedir } from "node:os";
 import { metaDir } from "./compat.js";
-import { loadConfig, expandHome, resolveEnv, findConfigPath, loadDotEnv } from "./runtime-config.js";
+import { loadConfig, expandHome, resolveEnv, findConfigPath, loadDotEnv, resolveDbPath } from "./runtime-config.js";
 import { createEmbedder, type EmbeddingConfig } from "./embedder.js";
 import { extractCanonicalKey, normalizeCanonicalKey } from "./memory-boundaries.js";
 import {
@@ -356,7 +356,9 @@ export async function runDoctor(options: { ci?: boolean } = {}): Promise<CheckRe
   }
 
   // 5. LanceDB data directory
-  const dbPath = resolve(configPath ? join(configPath, "..") : process.cwd(), expandHome(config.dbPath));
+  // Must resolve exactly like the server does — a doctor that reports on a
+  // different directory than the one actually in use is worse than no doctor.
+  const dbPath = resolveDbPath(config);
   try {
     validateStoragePath(dbPath);
     results.push(pass("Data directory", dbPath));