recallnest 2.3.0 → 2.6.0

package/src/store.ts

@@ -5,11 +5,15 @@
 import type * as LanceDB from "@lancedb/lancedb";
 import { createHash, randomUUID } from "node:crypto";
 import { existsSync, accessSync, constants, mkdirSync, realpathSync, lstatSync } from "node:fs";
-import { dirname } from "node:path";
+import { dirname, join } from "node:path";
 import { logWarn } from "./stderr-log.js";
+import { readConsistencyInterval as envReadConsistencyInterval } from "./env-config.js";
 import type { DurableMemoryCategory } from "./memory-schema.js";
 import { matchesScopeFilter } from "./scope-policy.js";
 import { detectEmotionIfEnabled } from "./emotion-detector.js";
+import { withWriteLock } from "./distill-lock.js";
+import { incrementWriteCount } from "./activity-counter.js";
+import type { MemoryStorePort, MemoryStoreStats, MemoryStoreUpdate } from "./memory-store-port.js";
 
 // ============================================================================
 // Types
@@ -55,6 +59,13 @@ export interface MemorySearchResult {
 export interface StoreConfig {
   dbPath: string;
   vectorDim: number;
+  /**
+   * LanceDB readConsistencyInterval (seconds): 0 = strong consistency (external
+   * writes visible on every read), positive = bounded staleness window.
+   * Omitted → RECALLNEST_READ_CONSISTENCY_INTERVAL decides (default 0; "off"
+   * restores the legacy unchecked-handle behavior).
+   */
+  readConsistencyInterval?: number;
 }
 
 export type LegacyScopeIssueKind = "missing" | "empty" | "global";
@@ -211,11 +222,16 @@ export function validateStoragePath(dbPath: string): string {
 
 const TABLE_NAME = "memories";
 
-export class MemoryStore {
+export class MemoryStore implements MemoryStorePort {
   private db: LanceDB.Connection | null = null;
   private table: LanceDB.Table | null = null;
   private initPromise: Promise<void> | null = null;
   private ftsIndexCreated = false;
+  /** Per-id serial queues for patchMetadata; entries self-remove on settle. */
+  private readonly metadataPatchQueues = new Map<string, Promise<void>>();
+
+  /** Set when the init-time schema migration fails; surfaced in store error messages. */
+  private schemaMigrationError: string | null = null;
 
   constructor(private readonly config: StoreConfig) {}
 
@@ -243,7 +259,13 @@ export class MemoryStore {
 
     let db: LanceDB.Connection;
     try {
-      db = await lancedb.connect(this.config.dbPath);
+      // Without a consistency interval a long-lived handle pins its manifest
+      // version — resident MCP/API/UI servers would never see CLI or
+      // sibling-process writes. Explicit config wins so tests can pin behavior.
+      db = await lancedb.connect(this.config.dbPath, {
+        readConsistencyInterval:
+          this.config.readConsistencyInterval ?? envReadConsistencyInterval(),
+      });
     } catch (err: any) {
       const code = err.code || "";
       const message = err.message || String(err);
@@ -261,24 +283,24 @@ export class MemoryStore {
     try {
       table = await db.openTable(TABLE_NAME);
 
-      // Backward compatibility: add missing columns to existing tables
+      // Backward compatibility: add missing columns to existing tables.
+      // Read the schema definition, not sample rows — a row-sampling check can
+      // never fire on a 0-row table, which deadlocked every write with
+      // "Found field not in schema" on empty pre-language/fts_text tables.
       try {
-        const sample = await table.query().limit(1).toArray();
-        if (sample.length > 0) {
-          if (!("scope" in sample[0])) {
-            logWarn("Adding scope column for backward compatibility with existing data");
-          }
-          if (!("language" in sample[0])) {
-            logWarn("Adding language column for backward compatibility");
-            await table.addColumns([{ name: "language", valueSql: "'en'" }]);
-          }
-          if (!("fts_text" in sample[0])) {
-            logWarn("Adding fts_text column for backward compatibility");
-            await table.addColumns([{ name: "fts_text", valueSql: "text" }]);
-          }
+        const schema = await table.schema();
+        const fields = new Set(schema.fields.map((f) => f.name));
+        const missing: Array<{ name: string; valueSql: string }> = [];
+        if (!fields.has("language")) missing.push({ name: "language", valueSql: "'en'" });
+        if (!fields.has("fts_text")) missing.push({ name: "fts_text", valueSql: "text" });
+        if (missing.length > 0) {
+          logWarn(`Adding missing columns for backward compatibility: ${missing.map((c) => c.name).join(", ")}`);
+          await table.addColumns(missing);
         }
+        this.schemaMigrationError = null;
       } catch (err) {
-        logWarn("Could not check/migrate table schema:", err);
+        this.schemaMigrationError = err instanceof Error ? err.message : String(err);
+        logWarn("Could not check/migrate table schema — subsequent writes may fail:", err);
       }
     } catch (_openErr) {
       // Table doesn't exist yet — create it
@@ -375,28 +397,33 @@ export class MemoryStore {
     }
 
     try {
-      await this.table!.add([fullEntry]);
+      // P0-2: go through upsert (delete+add under the global store-write lock) rather
+      // than a bare table.add — with the deterministic id above, storing the same
+      // (scope,text) twice now yields one row, not a dup-id pair (fixes the append bug).
+      return await this.upsert(fullEntry);
     } catch (err: any) {
       const code = err.code || "";
       const message = err.message || String(err);
       throw new Error(
-        `Failed to store memory in "${this.config.dbPath}": ${code} ${message}`
+        `Failed to store memory in "${this.config.dbPath}": ${code} ${message}` +
+        (this.schemaMigrationError ? `\n  Schema migration failed at init: ${this.schemaMigrationError}` : "")
       );
     }
-    return fullEntry;
   }
 
   /**
    * Batch store multiple entries at once — much faster than individual store() calls.
    * LanceDB handles bulk inserts efficiently with a single index update.
    */
-  async storeBatch(entries: Omit<MemoryEntry, "id" | "timestamp">[]): Promise<number> {
+  async storeBatch(entries: (Omit<MemoryEntry, "id" | "timestamp"> & { id?: string })[]): Promise<number> {
     if (entries.length === 0) return 0;
     await this.ensureInitialized();
 
     const fullEntries: MemoryEntry[] = entries.map(entry => ({
       ...entry,
-      id: deterministicId(entry.scope, entry.text),
+      // P0-2: honor a caller-supplied id (consolidation insight/pattern idempotency),
+      // else the deterministic content id — unified with store() (was: always recompute).
+      id: entry.id ?? deterministicId(entry.scope, entry.text),
       timestamp: Date.now(),
       metadata: entry.metadata || "{}",
       language: entry.language || "en",
@@ -413,16 +440,66 @@ export class MemoryStore {
       return e;
     });
 
+    // P2: collapse in-batch duplicate ids (latest-wins) BEFORE writing. Two entries
+    // with the same (scope,text) → same deterministic id; adding both would create a
+    // fresh dup-id pair in one shot (delete-set was deduped but the add was not).
+    const dedupedById = new Map<string, MemoryEntry>();
+    for (const e of enrichedEntries) dedupedById.set(e.id, e); // later occurrence wins
+    const toWrite = [...dedupedById.values()];
+
     try {
-      await this.table!.add(enrichedEntries);
+      await withWriteLock("store-write", async () => {
+        // P0-1/P0-2/P1: atomic idempotent batch write via mergeInsert (no delete+add
+        // window a crash could tear). toWrite is already in-batch deduped by id above,
+        // so the merge key matches ≤1 existing row (given no pre-existing dup-id rows).
+        await this.table!.mergeInsert("id").whenMatchedUpdateAll().whenNotMatchedInsertAll().execute(toWrite);
+      }, { expireMs: 30_000 });
     } catch (err: any) {
       const code = err.code || "";
       const message = err.message || String(err);
       throw new Error(
-        `Failed to batch store ${entries.length} memories in "${this.config.dbPath}": ${code} ${message}`
+        `Failed to batch store ${entries.length} memories in "${this.config.dbPath}": ${code} ${message}` +
+        (this.schemaMigrationError ? `\n  Schema migration failed at init: ${this.schemaMigrationError}` : "")
       );
     }
-    return fullEntries.length;
+    // Per-scope write counts drive dream activation. Best-effort — never block writes.
+    try {
+      const statsPath = this.activityStatsPath();
+      const countByScope = new Map<string, number>();
+      for (const e of toWrite) countByScope.set(e.scope, (countByScope.get(e.scope) ?? 0) + 1);
+      for (const [scope, n] of countByScope) incrementWriteCount(scope, n, { statsPath });
+    } catch { /* activity tracking is best-effort */ }
+    return toWrite.length;
+  }
+
+  /**
+   * P0-1/P0-2/P1: Idempotent, crash-atomic write of a fully-formed entry, serialized
+   * across processes.
+   *
+   * Uses mergeInsert("id") (same primitive as update()) so the write is atomic — no
+   * delete+add window that a crash between the two steps could tear, losing the row
+   * (P1). The global `store-write` lock still serializes concurrent merges across the
+   * 11 mcp-server processes so two whenNotMatched inserts can't both fire for the same
+   * id (the P0-1 race). "Same id overwrites" gives content-addressed idempotency to
+   * every store()/storeBatch() caller whose id is deterministicId(scope,text).
+   * Precondition: no pre-existing dup-id rows in the table (run the dedup migration
+   * scripts/cleanup-duplicate-ids.ts first) — else the merge key match is ambiguous.
+   */
+  /** Path to this store's activity-counter stats file, beside the LanceDB dir. */
+  private activityStatsPath(): string {
+    return join(dirname(this.config.dbPath), "activity-stats.json");
+  }
+
+  async upsert(entry: MemoryEntry): Promise<MemoryEntry> {
+    await this.ensureInitialized();
+    await withWriteLock("store-write", async () => {
+      await this.table!.mergeInsert("id").whenMatchedUpdateAll().whenNotMatchedInsertAll().execute([entry]);
+    }, { expireMs: 30_000 });
+    // Per-scope write count drives dream activation. Best-effort — never block a write.
+    try {
+      incrementWriteCount(entry.scope, 1, { statsPath: this.activityStatsPath() });
+    } catch { /* activity tracking is best-effort */ }
+    return entry;
   }
 
   /**
@@ -617,11 +694,19 @@ export class MemoryStore {
     if (isFullId) {
       candidates = await this.table!.query().where(`id = '${id}'`).limit(1).toArray();
     } else {
-      // Prefix match: fetch candidates and filter in app layer
-      const all = await this.table!.query().select(["id", "scope"]).limit(1000).toArray();
-      candidates = all.filter((r: any) => (r.id as string).startsWith(id));
+      // v2.5.2 (2026-05-27): Use SQL LIKE for prefix lookup instead of app-layer scan
+      // with limit(1000) — the old `.select().limit(1000).filter()` pattern silently
+      // missed entries beyond row 1000 in 90K+ libraries (Codex trio review finding,
+      // ref: ~/Desktop/codex-v2.5.1-fix-review-20260527.md, store.delete limit 漏洞).
+      // Now mirrors getById prefix behavior: LIKE with limit(2) detects ambiguity.
+      const safeId = escapeSqlLiteral(id);
+      candidates = await this.table!.query()
+        .select(["id", "scope"])
+        .where(`id LIKE '${safeId}%'`)
+        .limit(2)
+        .toArray();
       if (candidates.length > 1) {
-        throw new Error(`Ambiguous prefix "${id}" matches ${candidates.length} memories. Use a longer prefix or full ID.`);
+        throw new Error(`Ambiguous prefix "${id}" matches ${candidates.length}+ memories. Use a longer prefix or full ID.`);
       }
     }
     if (candidates.length === 0) {
@@ -688,6 +773,72 @@ export class MemoryStore {
       .slice(offset, offset + limit);
   }
 
+  /**
+   * True DB-level pagination — where/limit/offset are pushed down to LanceDB,
+   * so unlike list() this never materializes the full match set in JS. Use for
+   * full-corpus maintenance sweeps (auto-gc, promotion scan, lint/checkup).
+   *
+   * Caveats:
+   * - No orderBy support in the LanceDB query API: rows come back in fragment
+   *   scan order, NOT timestamp order. Stable across pages for a read-only
+   *   sweep, but concurrent writes rewrite fragments and may shift rows
+   *   between pages (a missed row is picked up by the next sweep). Do not use
+   *   for user-facing ordered listings — that's what list() is for.
+   * - includeVector loads the embedding column; only request it when the
+   *   consumer actually needs vectors (they dominate row size).
+   */
+  async listPage(opts: {
+    scopeFilter?: string[];
+    category?: string;
+    limit?: number;
+    offset?: number;
+    includeVector?: boolean;
+  } = {}): Promise<MemoryEntry[]> {
+    await this.ensureInitialized();
+    const { scopeFilter, category, limit = 1000, offset = 0, includeVector = false } = opts;
+
+    let query = this.table!.query();
+
+    const conditions: string[] = [];
+    if (scopeFilter && scopeFilter.length > 0) {
+      const scopeConditions = scopeFilter
+        .map(scope => {
+          const safe = escapeSqlLiteral(scope);
+          return scope.includes(":")
+            ? `scope = '${safe}'`
+            : `scope LIKE '${safe}%'`;
+        })
+        .join(" OR ");
+      conditions.push(`((${scopeConditions}))`);
+    }
+    if (category) {
+      conditions.push(`category = '${escapeSqlLiteral(category)}'`);
+    }
+    if (conditions.length > 0) {
+      query = query.where(conditions.join(" AND "));
+    }
+
+    const columns = ["id", "text", "category", "scope", "importance", "timestamp", "metadata"];
+    if (includeVector) columns.push("vector");
+
+    const results = await query
+      .select(columns)
+      .limit(limit)
+      .offset(offset)
+      .toArray();
+
+    return results.map((row): MemoryEntry => ({
+      id: row.id as string,
+      text: row.text as string,
+      vector: includeVector ? Array.from(row.vector as Iterable<number>) : [],
+      category: row.category as MemoryEntry["category"],
+      scope: (row.scope as string | undefined) ?? "",
+      importance: Number(row.importance),
+      timestamp: Number(row.timestamp),
+      metadata: (row.metadata as string) || "{}",
+    }));
+  }
+
   async get(id: string, scopeFilter?: string[]): Promise<MemoryEntry | null> {
     await this.ensureInitialized();
 
@@ -741,18 +892,35 @@ export class MemoryStore {
   }
 
   /**
-   * Get a single entry by exact ID without scope filtering.
-   * Lightweight read used by AccessTracker for metadata updates.
+   * Get a single entry by ID (full UUID) or 8+ hex prefix.
+   * Lightweight read used by AccessTracker for metadata updates and by skill-engine
+   * for outcome recording.
+   *
+   * v2.5.1 (2026-05-27) — 加 prefix lookup support：和 update() / delete() 行为对齐，
+   * 让 agent 拿到 short id（如 store_skill 返回的 8 位前缀、人类粘贴的截断 id）也能
+   * resolve 到完整 entry。歧义 prefix（匹配 >1 条）返回 null 让 caller 处理。
+   * 现有 caller 全部传完整 UUID，向后兼容。
    */
   async getById(id: string): Promise<MemoryEntry | null> {
     await this.ensureInitialized();
+
+    // Support both full UUID and 8+ hex prefix (same pattern as update() / delete()).
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    const prefixRegex = /^[0-9a-f]{8,}$/i;
+    const isFullId = uuidRegex.test(id);
+    const isPrefix = !isFullId && prefixRegex.test(id);
+    if (!isFullId && !isPrefix) return null;
+
     const safeId = escapeSqlLiteral(id);
+    const whereClause = isFullId ? `id = '${safeId}'` : `id LIKE '${safeId}%'`;
+
     const rows = await this.table!.query()
       .select(["id", "text", "vector", "category", "scope", "importance", "timestamp", "metadata"])
-      .where(`id = '${safeId}'`)
-      .limit(1)
+      .where(whereClause)
+      .limit(2) // detect ambiguous prefix (matches >1)
       .toArray();
     if (rows.length === 0) return null;
+    if (isPrefix && rows.length > 1) return null; // ambiguous prefix
     const row = rows[0];
     return {
       id: row.id as string,
@@ -773,28 +941,28 @@ export class MemoryStore {
    */
   async getVectors(ids: string[]): Promise<Map<string, number[]>> {
     await this.ensureInitialized();
-    if (ids.length === 0) return new Map();
-
-    const conditions = ids.map(id => `id = '${escapeSqlLiteral(id)}'`).join(" OR ");
-    const rows = await this.table!.query()
-      .select(["id", "vector"])
-      .where(conditions)
-      .limit(ids.length)
-      .toArray();
-
     const result = new Map<string, number[]>();
-    for (const row of rows) {
-      const vec = Array.from(row.vector as Iterable<number>);
-      if (vec.length > 0) result.set(row.id as string, vec);
+    if (ids.length === 0) return result;
+
+    // 分批:避免 id 很多时 OR 链过长（如 data-checkup/memory-lint 一次补几千条向量）。
+    const BATCH = 500;
+    for (let i = 0; i < ids.length; i += BATCH) {
+      const batch = ids.slice(i, i + BATCH);
+      const conditions = batch.map(id => `id = '${escapeSqlLiteral(id)}'`).join(" OR ");
+      const rows = await this.table!.query()
+        .select(["id", "vector"])
+        .where(conditions)
+        .limit(batch.length)
+        .toArray();
+      for (const row of rows) {
+        const vec = Array.from(row.vector as Iterable<number>);
+        if (vec.length > 0) result.set(row.id as string, vec);
+      }
     }
     return result;
   }
 
-  async stats(scopeFilter?: string[]): Promise<{
-    totalCount: number;
-    scopeCounts: Record<string, number>;
-    categoryCounts: Record<string, number>
-  }> {
+  async stats(scopeFilter?: string[]): Promise<MemoryStoreStats> {
     await this.ensureInitialized();
 
     let query = this.table!.query();
@@ -874,7 +1042,7 @@ export class MemoryStore {
 
   async update(
     id: string,
-    updates: { text?: string; vector?: number[]; importance?: number; category?: MemoryEntry["category"]; metadata?: string; timestamp?: number; language?: string; fts_text?: string },
+    updates: MemoryStoreUpdate,
     scopeFilter?: string[]
   ): Promise<MemoryEntry | null> {
     await this.ensureInitialized();
@@ -916,7 +1084,10 @@ export class MemoryStore {
     const updated: MemoryEntry = {
       id: row.id as string,
       text: updates.text ?? (row.text as string),
-      vector: updates.vector ?? (Array.from(row.vector as Iterable<number>)),
+      // row.vector 可能为 null（历史病行，2026-07-23 dream/auto-gc 生产实锤：
+      // cc:82a919ea 连崩三轮 Array.from(null)）。null → [] 让 metadata-only update
+      // 不再被病行绊倒；空向量本就不可检索，语义不变。
+      vector: updates.vector ?? (row.vector ? Array.from(row.vector as Iterable<number>) : []),
       category: updates.category ?? (row.category as MemoryEntry["category"]),
       scope: rowScope,
       importance: updates.importance ?? Number(row.importance),
@@ -936,14 +1107,94 @@ export class MemoryStore {
       }
     }
 
-    // LanceDB doesn't support in-place update; delete + re-add
-    const resolvedId = escapeSqlLiteral(row.id as string);
-    await this.table!.delete(`id = '${resolvedId}'`);
-    await this.table!.add([updated]);
+    // Atomic upsert via mergeInsert — replaces the previous delete+add two-step,
+    // which could lose the row entirely on a crash between steps and exposed a
+    // window where concurrent reads saw the id momentarily vanish.
+    await this.table!
+      .mergeInsert("id")
+      .whenMatchedUpdateAll()
+      .whenNotMatchedInsertAll()
+      .execute([updated]);
 
     return updated;
   }
 
+  /**
+   * Serialized read-modify-write for the metadata column.
+   *
+   * Every direct `getById → mutate metadata → update` round-trip can lose
+   * concurrent increments (last write wins). This method funnels metadata
+   * patches for the same id through a per-id promise queue so each patch
+   * reads the result of the previous one.
+   *
+   * patchFn receives the parsed metadata object plus the freshly-read entry
+   * (for callers that need importance/timestamp context) and returns the new
+   * metadata object. A throwing patchFn abandons that patch — the error
+   * propagates to the caller, later queued patches still run.
+   *
+   * Scope of guarantee: in-process only. Cross-process writers (multiple
+   * mcp-server instances) and the remaining direct update() callers
+   * (consolidation/capture/forget/prospective/conflict engines, auto-gc)
+   * are NOT serialized by this queue. Long-term direction: make this the
+   * only legal metadata write path.
+   */
+  async patchMetadata(
+    id: string,
+    patchFn: (meta: Record<string, unknown>, entry: MemoryEntry) => Record<string, unknown>,
+    scopeFilter?: string[],
+  ): Promise<MemoryEntry | null> {
+    await this.ensureInitialized();
+
+    // Queue key must be the resolved full UUID — otherwise a prefix caller and
+    // a full-id caller targeting the same row would race on separate queues.
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    let fullId: string;
+    if (uuidRegex.test(id)) {
+      fullId = id;
+    } else {
+      const resolved = await this.getById(id);
+      if (!resolved) return null;
+      fullId = resolved.id;
+    }
+
+    const run = async (): Promise<MemoryEntry | null> => {
+      const entry = await this.getById(fullId);
+      if (!entry) return null;
+      let meta: Record<string, unknown>;
+      try {
+        const parsed: unknown = JSON.parse(entry.metadata || "{}");
+        meta = parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)
+          ? (parsed as Record<string, unknown>)
+          : {};
+      } catch {
+        meta = {};
+      }
+      const patched = patchFn(meta, entry);
+      return this.update(fullId, { metadata: JSON.stringify(patched) }, scopeFilter);
+    };
+
+    const prev = this.metadataPatchQueues.get(fullId) ?? Promise.resolve();
+    // Isolate prior failures so one rejected patch can't wedge the queue.
+    const result = prev.then(run, run);
+    // The stored tail settles regardless of outcome; the caller keeps the real
+    // rejection via `result`. Only the current tail removes itself.
+    const tail = result.then(
+      () => undefined,
+      () => undefined,
+    ).then(() => {
+      if (this.metadataPatchQueues.get(fullId) === tail) {
+        this.metadataPatchQueues.delete(fullId);
+      }
+    });
+    this.metadataPatchQueues.set(fullId, tail);
+    return result;
+  }
+
+  /** Number of ids with in-flight metadata patches (test/diagnostic hook). */
+  get pendingMetadataPatchCount(): number {
+    return this.metadataPatchQueues.size;
+  }
+
   async bulkDelete(scopeFilter: string[], beforeTimestamp?: number): Promise<number> {
     await this.ensureInitialized();
 
@@ -983,6 +1234,19 @@ export class MemoryStore {
     return deleteCount;
   }
 
+  /**
+   * Force lazy initialization to complete.
+   *
+   * `hasFtsSupport` is meaningless before init: `ftsIndexCreated` starts false and
+   * only flips once `doInitialize()` has attempted to build the FTS index. Any caller
+   * that *branches* on `hasFtsSupport` must await this first, or it will read the
+   * pre-init false and take the wrong branch. Cheap to call repeatedly —
+   * `ensureInitialized()` returns immediately once the table exists.
+   */
+  async ready(): Promise<void> {
+    await this.ensureInitialized();
+  }
+
   get hasFtsSupport(): boolean {
     return this.ftsIndexCreated;
   }

package/src/term-registry.ts

@@ -272,12 +272,24 @@ export const TASK_RESULT_SPECIFICITY_GROUPS = [
       "managed continuity rules",
       "global instruction file",
     ],
+    // ⚠️ 上面的 resultTerms 是**一次历史事件的专名**（2026 年那轮三端连续性触发验证），
+    // 不是端清单 —— 端接入时不要往里加端名：resultTerms 是「谁被这个组认领」，
+    // 加了 "kimi" 等于断言"任何提到 kimi 的记忆都是那次三端验证的结论"，
+    // 会让大批 kimi 记忆在无关任务下被这个组滤掉。同款判断见 932ec37：
+    // ROADMAP 里 `✅ managed continuity rules installed by setup` 那处也按"历史"原样保留。
+    //
+    // taskTerms 是「什么问法下这条历史仍然相关」，所以只补她真实的问法：
+    // 表里原有 "three-terminal" / "三终端"，但她写的是"三端"/"四端"（"三端"不是"三终端"的子串，
+    // 今天真的匹配不上）。**同样不补端名** —— 补了会让「kimi 挂了」这种无关任务
+    // 也解除过滤、把这条三端历史塞进 context；真正相关的问法已被 触发/接入/规则 覆盖。
     taskTerms: [
       "claude code",
       "codex",
       "gemini cli",
       "three-terminal",
       "三终端",
+      "三端",
+      "四端",
       "trigger",
       "触发",
       "setup",
@@ -462,6 +474,18 @@ export const TASK_RESULT_SPECIFICITY_GROUPS = [
   },
 ];
 
+// 「某个端的验收 / 独立验证视角」这一簇。判据（context-composer-stable-selection.ts:154-157）：
+//   resultTerms 命中记忆正文 && taskTerms 全不命中任务  →  丢弃这条记忆
+// 两个字段方向相反，接入新端时**不要两边对称地加**：
+//   · taskTerms 加词 = 放宽豁免，召回变多 —— 端接入时要补的是这一侧
+//   · resultTerms 加词 = 扩大被滤对象，召回变少 —— 这里**有意不补端名**：
+//     概念词（smoke / integration / 验收 / 验证视角 / 独立验证 / sidecar）本就是端无关的，
+//     已经覆盖了"kimi 的验收视角"这类记忆；而裸词是子串匹配，补进去会把"顺带提了一句 kimi"
+//     的无关偏好整条变成可滤对象，爆炸半径远大于收益。
+//     实证：现有的裸词 "codex" 已经在误认领 —— 记忆 b8731a81（讲规则该放 home 级还是项目级）
+//     只因正文里有 `.codex/AGENTS.md` 这个**路径片段**就被本组claim，
+//     于是"四端的触发规则都装好了吗"这一问反而把最对题的那条滤掉了（shadow 实测）。
+//     再往 resultTerms 加端名 = 把这个已知缺陷复制三份。
 export const PREFERENCE_SPECIFICITY_GROUPS = [
   {
     resultTerms: [
@@ -480,6 +504,17 @@ export const PREFERENCE_SPECIFICITY_GROUPS = [
       "claude code",
       "codex",
       "gemini cli",
+      // 在栈四端 = Claude Code / Codex / Kimi / AGY。AGY 是一个端，
+      // "antigravity" 与 "agy" 是它的两类写法（scope 前缀写 antigravity:，
+      // 她口头和 MEMORY.md 里写 agy），两个都要，不是两个端。
+      "kimi",
+      "antigravity",
+      "agy",
+      // 问端拓扑本身（不点名某一端）时也该解除：shadow 实测
+      // "四端的触发规则都装好了吗"会把 b8731a81（规则该放 home 级还是项目级，
+      // 正文写着"shared-behaviors.md 放三端通用底线"）这条最对题的记忆滤掉。
+      "三端",
+      "四端",
       "smoke",
       "integration",
       "验收",

package/src/tool-output-compressor.ts

@@ -59,7 +59,9 @@ const RULES: CompressionRule[] = [
 
 // Patterns that identify tool output blocks in conversation text.
 // Claude Code / Codex format: command on one line, output follows.
-const TOOL_OUTPUT_BLOCK = /^(?:\$\s+|❯\s+|>\s+)(.+)\n([\s\S]*?)(?=\n(?:\$\s+|❯\s+|>\s+)|\n\n[A-Z]|\n##|\z)/gm;
+// 末项用 (?![\s\S]) 表示「字符串绝对结尾」。不能用 \z（JS 无此锚点，会被当字面字符 z →
+// 在输出里第一个 z 处误截断），也不能用 $（gm 模式下匹配每行尾，惰性 [\s\S]*? 会在第一行就停）。
+const TOOL_OUTPUT_BLOCK = /^(?:\$\s+|❯\s+|>\s+)(.+)\n([\s\S]*?)(?=\n(?:\$\s+|❯\s+|>\s+)|\n\n[A-Z]|\n##|(?![\s\S]))/gm;
 
 // Base64 image data (screenshots, etc.)
 const BASE64_BLOCK = /(?:data:image\/[^;]+;base64,)?[A-Za-z0-9+/]{500,}={0,2}/g;

package/src/ui-server.ts

@@ -12,6 +12,8 @@ import { archiveDirtyBriefAsset, assetSummaryLine, buildBriefAsset, buildPinAsse
 import { indexAsset, indexPinnedAsset } from "./asset-sync.js";
 import { createComponentResolver, loadConfig, loadDotEnv } from "./runtime-config.js";
 import { buildRetrievalContext, resolveScopeSelection } from "./scope-policy.js";
+import { enforceLocalHttpRequestPolicy, LOCAL_HTTP_HOSTNAME } from "./http-request-policy.js";
+import * as envConfig from "./env-config.js";
 const config = (loadDotEnv(), loadConfig());
 const getComponents = createComponentResolver(config);
 
@@ -186,9 +188,15 @@ async function handleSearch(mode: "search" | "explain" | "distill", body: Record
 }
 
 const server = Bun.serve({
-  port: readLimit(process.env.RECALLNEST_UI_PORT, 4317, 1, 65535),
+  port: readLimit(envConfig.uiPortRaw(), 4317, 1, 65535),
+  hostname: LOCAL_HTTP_HOSTNAME,
   async fetch(request) {
     try {
+      const policy = await enforceLocalHttpRequestPolicy(request);
+      if (!policy.allowed) {
+        return textResponse(policy.message, { status: policy.status });
+      }
+
       const url = new URL(request.url);
 
       if (request.method === "GET" && (url.pathname === "/" || url.pathname.startsWith("/ui/"))) {