recallnest 2.5.4 → 2.6.0

package/src/ingest.ts

@@ -24,6 +24,7 @@ import { isProcessed, markProcessed } from "./tracker.js";
 import * as envConfig from "./env-config.js";
 import type { LLMClient, SmartExtraction } from "./llm-client.js";
 import { resolveIngestBoundary } from "./memory-boundaries.js";
+import { isActiveMemory } from "./memory-evolution.js";
 import { isNoise } from "./noise-filter.js";
 import {
   inferReplyStylePreferenceSlot,
@@ -289,8 +290,12 @@ export async function dedupCheck(
   llm?: LLMClient | null,
 ): Promise<DedupCheckResult> {
   try {
-    // Stage 1: vector similarity check
-    const results = await store.vectorSearch(vector, DEDUP_CANDIDATE_LIMIT, DEDUP_SOFT_THRESHOLD);
+    // Stage 1: vector similarity check. store.vectorSearch() has no status filter, so
+    // superseded belief-history rows surface here — dedupe against one and incoming
+    // content gets dropped as a duplicate of a belief that is no longer held (returning
+    // to an earlier position would be silently discarded).
+    const results = (await store.vectorSearch(vector, DEDUP_CANDIDATE_LIMIT, DEDUP_SOFT_THRESHOLD))
+      .filter((result) => isActiveMemory(result.entry.metadata));
     if (results.length === 0) {
       return { action: "store", reason: "unique" }; // Clearly unique
     }
@@ -1190,6 +1195,276 @@ export async function ingestCodexSessions(
   return result;
 }
 
+// ============================================================================
+// Kimi Code Session Parser
+// ============================================================================
+// Kimi Code 的 wire.jsonl 是事件流（非 role/content 行），对话内容只在三类事件里：
+//   turn.prompt (origin.kind="user")          → 用户输入，.input 是 text part 数组
+//   context.append_message                    → 消息；用户消息只收 origin.kind="user"
+//                                               （injection/skill_activation 等是系统注入，跳过）
+//   context.append_loop_event content.part    → 助手文本（part.type==="text"；think 跳过）
+// 其余类型（llm.tools_snapshot / mcp.tools_discovered / config.update / llm.request /
+// usage.record / permission.* 等，约占 86% 体积）是运行事件，一律跳过。
+function parseKimiSession(filePath: string): ConversationTurn[] {
+  const turns: ConversationTurn[] = [];
+  const content = readFileSync(filePath, "utf-8");
+  const lines = content.split("\n").filter((l) => l.trim());
+
+  // sessionId 从路径取：.../sessions/<workDirKey>/<sessionId>/agents/main/wire.jsonl
+  // 去掉 "session_" 前缀，否则 scope 统一变成 kimi:session_
+  const pathParts = filePath.split("/");
+  const rawId = pathParts.length >= 4 ? pathParts[pathParts.length - 4] : basename(filePath, ".jsonl");
+  const sessionId = rawId.replace(/^session_/, "");
+
+  const pushTurn = (role: "user" | "assistant", text: string, timestamp: string) => {
+    const trimmed = text.trim();
+    // 中文 8 字符已是完整句；用户阈值与 codex/cc 对齐
+    if (trimmed.length <= (role === "user" ? 10 : 8)) return;
+    // turn.prompt 与随后的 context.append_message 重复记录同一用户输入（同 codex 相邻去重）
+    const lastTurn = turns[turns.length - 1];
+    if (lastTurn && lastTurn.role === role && lastTurn.text === trimmed) return;
+    turns.push({ role, text: trimmed, timestamp, sessionId });
+  };
+
+  for (const line of lines) {
+    try {
+      const obj = JSON.parse(line);
+      const timestamp = typeof obj.time === "number" ? new Date(obj.time).toISOString() : "";
+
+      if (obj.type === "turn.prompt") {
+        if (obj.origin?.kind !== "user") continue;
+        const parts = Array.isArray(obj.input) ? obj.input : [];
+        const text = parts
+          .filter((c: any) => c?.type === "text")
+          .map((c: any) => c.text || "")
+          .join("\n");
+        if (text) pushTurn("user", text, timestamp);
+        continue;
+      }
+
+      if (obj.type === "context.append_message") {
+        const msg = obj.message;
+        if (!msg || (msg.role !== "user" && msg.role !== "assistant")) continue;
+        // 系统注入（system-reminder、skill 激活、后台任务通知）不是用户对话内容
+        if (msg.role === "user" && msg.origin?.kind !== "user") continue;
+        let text = "";
+        if (typeof msg.content === "string") {
+          text = msg.content;
+        } else if (Array.isArray(msg.content)) {
+          text = msg.content
+            .filter((c: any) => c.type === "text")
+            .map((c: any) => c.text || "")
+            .join("\n");
+        }
+        if (text) pushTurn(msg.role, text, timestamp);
+        continue;
+      }
+
+      if (obj.type === "context.append_loop_event") {
+        const part = obj.event?.type === "content.part" ? obj.event.part : null;
+        if (part?.type === "text" && typeof part.text === "string") {
+          pushTurn("assistant", part.text, timestamp);
+        }
+      }
+    } catch {
+      // Skip malformed lines
+    }
+  }
+
+  return turns;
+}
+
+export async function ingestKimiSessions(
+  store: MemoryStore,
+  embedder: Embedder,
+  options: { limit?: number; verbose?: boolean; noDedup?: boolean; llm?: LLMClient | null; recentHours?: number } = {},
+): Promise<IngestResult> {
+  const result: IngestResult = {
+    source: "kimi",
+    filesProcessed: 0,
+    chunksIngested: 0,
+    chunksSkipped: 0,
+    chunksDeduped: 0,
+    dedupReasonCounts: createDedupReasonCounts(),
+    errors: [],
+  };
+
+  const baseDir = expandHome("~/.kimi-code/sessions");
+  const indexPath = expandHome("~/.kimi-code/session_index.jsonl");
+
+  // 文件发现：优先 session_index.jsonl（精确），再 walk sessions 目录兜底（索引缺漏时）。
+  // 只收 agents/main/wire.jsonl，子 agent 的 agents/agent-N/wire.jsonl 与主对话重复，不采。
+  const seen = new Set<string>();
+  const allFiles: string[] = [];
+  const addFile = (p: string) => {
+    if (!seen.has(p) && existsSync(p)) {
+      seen.add(p);
+      allFiles.push(p);
+    }
+  };
+
+  if (existsSync(indexPath)) {
+    try {
+      for (const line of readFileSync(indexPath, "utf-8").split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          const entry = JSON.parse(line);
+          if (typeof entry.sessionDir === "string" && entry.sessionDir) {
+            addFile(join(entry.sessionDir, "agents", "main", "wire.jsonl"));
+          }
+        } catch {
+          // Skip malformed index lines
+        }
+      }
+    } catch {
+      // 索引读不出来就走下面的目录扫描
+    }
+  }
+
+  if (existsSync(baseDir)) {
+    const mainWireSuffix = join("agents", "main", "wire.jsonl");
+    const walk = (dir: string) => {
+      for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          walk(full);
+        } else if (full.endsWith(mainWireSuffix)) {
+          addFile(full);
+        }
+      }
+    };
+    walk(baseDir);
+  }
+
+  if (allFiles.length === 0) {
+    result.errors.push(`Kimi Code sessions not found: ${baseDir} (index: ${indexPath})`);
+    return result;
+  }
+  allFiles.sort();
+
+  const recentMode = options.recentHours !== undefined;
+  const cutoffMs = recentMode ? Date.now() - options.recentHours! * 3600_000 : 0;
+
+  // --recent: only keep files modified within N hours
+  const filteredFiles = recentMode
+    ? allFiles.filter((f) => { try { return statSync(f).mtimeMs >= cutoffMs; } catch { return false; } })
+    : allFiles;
+
+  const filesToProcess = options.limit ? filteredFiles.slice(0, options.limit) : filteredFiles;
+  const total = filesToProcess.length;
+
+  for (let fi = 0; fi < filesToProcess.length; fi++) {
+    const filePath = filesToProcess[fi];
+
+    try {
+      const stat = statSync(filePath);
+      if (stat.size < 200) {
+        result.chunksSkipped++;
+        continue;
+      }
+
+      // In --recent mode, skip ingested-files check — files may have new content appended
+      if (!recentMode && isProcessed(filePath, stat.size, stat.mtimeMs)) {
+        result.chunksSkipped++;
+        continue;
+      }
+
+      const turns = parseKimiSession(filePath);
+      if (turns.length === 0) {
+        result.chunksSkipped++;
+        markProcessed(filePath, stat.size, 0, stat.mtimeMs);
+        continue;
+      }
+
+      const chunks = groupTurnsIntoChunks(turns);
+      const texts = chunks.map((c) => c.text);
+      const batchSize = 32;
+      let fileChunks = 0;
+
+      for (let i = 0; i < texts.length; i += batchSize) {
+        const batch = texts.slice(i, i + batchSize);
+        const batchChunks = chunks.slice(i, i + batchSize);
+
+        try {
+          const vectors = await embedder.embedBatchPassage(batch);
+          const toStore: Array<{text: string; vector: number[]; category: string; scope: string; importance: number; metadata: string}> = [];
+
+          // Dedup + L0 batch
+          const dedupedTexts: string[] = [];
+          const dedupedVectors: number[][] = [];
+          const dedupedChunks: typeof batchChunks = [];
+
+          for (let j = 0; j < batch.length; j++) {
+            const vector = vectors[j];
+            if (!vector || vector.length === 0) {
+              result.chunksSkipped++;
+              continue;
+            }
+            if (!options.noDedup) {
+              const decision = await dedupCheck(store, vector, batch[j], options.llm);
+              recordDedupDecision(result, decision);
+              if (decision.secondaryDeletes?.length) {
+                await executeSecondaryDeletes(store, decision.secondaryDeletes);
+              }
+              if (decision.action === "skip") continue;
+            }
+            dedupedTexts.push(batch[j]);
+            dedupedVectors.push(vector);
+            dedupedChunks.push(batchChunks[j]);
+          }
+
+          if (dedupedTexts.length > 0) {
+            if (!options.llm) {
+              queueForLaterExtraction(
+                dedupedChunks.map(c => ({ text: c.text, scope: `kimi:${c.sessionId.slice(0, 8)}` }))
+              );
+              result.chunksSkipped += dedupedTexts.length;
+            } else {
+              const extractions = await smartExtractBatch(dedupedTexts, options.llm);
+              const coreSummaries = await generateCoreSummaries(dedupedTexts, options.llm);
+              for (let j = 0; j < dedupedTexts.length; j++) {
+                const chunk = dedupedChunks[j];
+                const ext = extractions[j];
+                toStore.push(buildIngestedEntry({
+                  source: "kimi",
+                  scope: `kimi:${chunk.sessionId.slice(0, 8)}`,
+                  text: dedupedTexts[j],
+                  vector: dedupedVectors[j],
+                  extraction: ext,
+                  sessionId: chunk.sessionId,
+                  file: basename(filePath),
+                  coreSummary: coreSummaries[j],
+                }));
+              }
+            }
+          }
+
+          if (toStore.length > 0) {
+            await store.storeBatch(toStore);
+            result.chunksIngested += toStore.length;
+            fileChunks += toStore.length;
+          }
+        } catch (err: any) {
+          result.errors.push(`Embedding batch error: ${err.message}`);
+        }
+      }
+
+      markProcessed(filePath, stat.size, fileChunks, stat.mtimeMs);
+      result.filesProcessed++;
+
+      if ((fi + 1) % 10 === 0 || fi + 1 === total) {
+        console.log(
+          `  Kimi: ${fi + 1}/${total} files, ${result.chunksIngested} chunks ingested`,
+        );
+      }
+    } catch (err: any) {
+      result.errors.push(`Error processing ${basename(filePath)}: ${err.message}`);
+    }
+  }
+
+  return result;
+}
+
 // ============================================================================
 // Gemini Session Parser
 // ============================================================================

package/src/kg-extractor.ts

@@ -96,7 +96,13 @@ const DEFAULT_KG_SYSTEM = `You are a knowledge graph extraction assistant. Extra
 const DEFAULT_KG_USER_TEMPLATE = `Extract knowledge graph triples from the following text.
 Rules:
 - Use simple predicates: uses, created_by, works_with, is_a, part_of, has, located_in, belongs_to, depends_on, implements, extends, related_to, caused_by, results_in, precedes, follows
-- Assign confidence 0.0-1.0
+- confidence must be EXACTLY one of these five values (models collapse continuous ranges — pick the one matching the evidence):
+  1.0  = stated explicitly in the text
+  0.85 = strong inference (clearly implied, never stated)
+  0.75 = reasonable inference (requires interpretation)
+  0.65 = weak inference (thematic association only)
+  0.55 = speculative (surface co-occurrence)
+  Never use 0.5 or any value outside this list. If unsure between two tiers, pick the lower.
 - Extract 3-8 triples
 - Return JSON: { "triples": [{ "subject": "", "predicate": "", "object": "", "confidence": 0.0 }] }
 

package/src/llm-client.ts

@@ -106,12 +106,57 @@ export interface LLMConfig {
   apiKey: string;
   model: string;
   baseURL: string;
+  /** SDK-level retries. Undefined preserves the OpenAI SDK default. */
+  maxRetries?: number;
   /** Request timeout in ms (default: 15000) */
   timeoutMs?: number;
   /** Temperature (default: 0.1 for consistency) */
   temperature?: number;
 }
 
+export type DetailedChatTokenLimit =
+  | { parameter: "max_tokens"; value: number }
+  | { parameter: "max_completion_tokens"; value: number };
+
+export interface DetailedChatOptions {
+  /** Per-request temperature override. Defaults to the client configuration. */
+  temperature?: number;
+  /** OpenAI-compatible JSON object response mode. */
+  responseFormat?: { type: "json_object" };
+  /** Provider extension used by Qwen-compatible endpoints. */
+  enableThinking?: boolean;
+  /** Explicitly records both the token-limit field name and its value. */
+  tokenLimit?: DetailedChatTokenLimit;
+}
+
+export interface DetailedChatUsage {
+  promptTokens: number;
+  completionTokens: number;
+  totalTokens: number;
+  cachedPromptTokens?: number;
+  reasoningTokens?: number;
+}
+
+export interface DetailedChatResult {
+  content: string | null;
+  finishReason: string | null;
+  responseModel: string;
+  usage: DetailedChatUsage | null;
+}
+
+interface OpenAICompatibleLongChatRequest {
+  model: string;
+  messages: [
+    { role: "system"; content: string },
+    { role: "user"; content: string },
+  ];
+  temperature: number;
+  max_tokens?: number;
+  max_completion_tokens?: number;
+  response_format?: { type: "json_object" };
+  enable_thinking?: boolean;
+}
+
 export interface DedupDecision {
   action: "CREATE" | "MERGE" | "SKIP";
   reason: string;
@@ -190,9 +235,13 @@ export class LLMClient {
 
   constructor(config: LLMConfig, breakerConfig?: Partial<CircuitBreakerConfig>) {
     const apiKey = resolveEnvVars(config.apiKey);
+    if (config.maxRetries !== undefined && (!Number.isInteger(config.maxRetries) || config.maxRetries < 0)) {
+      throw new Error("LLM maxRetries must be a non-negative integer");
+    }
     this.client = new OpenAI({
       apiKey,
       baseURL: config.baseURL,
+      ...(config.maxRetries !== undefined ? { maxRetries: config.maxRetries } : {}),
     });
     this.model = config.model;
     this.temperature = config.temperature ?? 0.1;
@@ -696,29 +745,68 @@ export class LLMClient {
     }
   }
 
-  async chatLong(system: string, user: string, maxTokens = 2000): Promise<string | null> {
+  async chatLongDetailed(
+    system: string,
+    user: string,
+    options: DetailedChatOptions = {},
+  ): Promise<DetailedChatResult | null> {
     if (!this.breaker.canAttempt()) {
       return null;
     }
 
+    const tokenLimit = options.tokenLimit ?? { parameter: "max_tokens", value: 2000 };
+    if (!Number.isInteger(tokenLimit.value) || tokenLimit.value <= 0) {
+      throw new Error("Detailed chat token limit must be a positive integer");
+    }
+    const temperature = options.temperature ?? this.temperature;
+    if (!Number.isFinite(temperature)) {
+      throw new Error("Detailed chat temperature must be finite");
+    }
+    const request: OpenAICompatibleLongChatRequest = {
+      model: this.model,
+      messages: [
+        { role: "system", content: system },
+        { role: "user", content: user },
+      ],
+      temperature,
+    };
+    if (tokenLimit.parameter === "max_tokens") {
+      request.max_tokens = tokenLimit.value;
+    } else {
+      request.max_completion_tokens = tokenLimit.value;
+    }
+    if (options.responseFormat) request.response_format = options.responseFormat;
+    if (options.enableThinking !== undefined) request.enable_thinking = options.enableThinking;
+
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), this.timeoutMs * 2);
 
     try {
       const response = await this.client.chat.completions.create(
-        {
-          model: this.model,
-          messages: [
-            { role: "system", content: system },
-            { role: "user", content: user },
-          ],
-          temperature: this.temperature,
-          max_tokens: maxTokens,
-        },
+        request,
         { signal: controller.signal },
       );
 
-      const result = response.choices[0]?.message?.content?.trim() || null;
+      const choice = response.choices[0];
+      const usage = response.usage
+        ? {
+            promptTokens: response.usage.prompt_tokens,
+            completionTokens: response.usage.completion_tokens,
+            totalTokens: response.usage.total_tokens,
+            ...(response.usage.prompt_tokens_details?.cached_tokens !== undefined
+              ? { cachedPromptTokens: response.usage.prompt_tokens_details.cached_tokens }
+              : {}),
+            ...(response.usage.completion_tokens_details?.reasoning_tokens !== undefined
+              ? { reasoningTokens: response.usage.completion_tokens_details.reasoning_tokens }
+              : {}),
+          }
+        : null;
+      const result: DetailedChatResult = {
+        content: choice?.message?.content?.trim() || null,
+        finishReason: choice?.finish_reason ?? null,
+        responseModel: response.model,
+        usage,
+      };
       this.breaker.recordSuccess();
       return result;
     } catch (err) {
@@ -729,6 +817,13 @@ export class LLMClient {
     }
   }
 
+  async chatLong(system: string, user: string, maxTokens = 2000): Promise<string | null> {
+    const result = await this.chatLongDetailed(system, user, {
+      tokenLimit: { parameter: "max_tokens", value: maxTokens },
+    });
+    return result?.content ?? null;
+  }
+
   // --------------------------------------------------------------------------
   // Constructive Retrieval — public wrappers for reconstruction pipeline
   // --------------------------------------------------------------------------

package/src/mcp-server.ts

@@ -33,6 +33,7 @@ import { registerCoreTools } from "./mcp-tools-core.js";
 import { registerAdvancedTools } from "./mcp-tools-advanced.js";
 import { registerGovernanceTools } from "./mcp-tools-governance.js";
 import type { ToolRegistryDeps } from "./mcp-tool-deps.js";
+import { PACKAGE_VERSION } from "./version.js";
 
 // ============================================================================
 // Tier Configuration
@@ -152,7 +153,7 @@ function ensureComponents(): Promise<void> {
 
 const server = new McpServer({
   name: "recallnest",
-  version: "1.4.0",
+  version: PACKAGE_VERSION,
 });
 
 // ============================================================================

package/src/mcp-tools-advanced.ts

@@ -3,6 +3,7 @@ import { indexAsset, indexPinnedAsset } from "./asset-sync.js";
 import { createAuditLogger } from "./audit-log.js";
 import { persistCaseMemory, persistMemoryBatch, persistWorkflowPattern, promoteMemory } from "./capture-engine.js";
 import { autoCapture } from "./capture-heuristic.js";
+import { computeSynthesisUptake } from "./consolidation-engine.js";
 import { runDataCheckup, formatCheckupReport } from "./data-checkup.js";
 import { runDream, formatDreamResult } from "./dream-pipeline.js";
 import { forgetMemory } from "./forget-engine.js";
@@ -550,6 +551,14 @@ registerTool(
       sourceCounts[prefix] = (sourceCounts[prefix] || 0) + count;
     }
 
+    // Synthesis uptake（Artel 借鉴）：升华产物被读回的比例——长期 0% = 升华管线
+    // 在产无人消费的内容或读打点断链，是能报警的健康度数字。
+    // cap 取 totalCount 自适应库大小（2026-07-23 实测库已 117K，固定 cap 追不上增长）。
+    const uptake = await computeSynthesisUptake(store, stats.totalCount + 1_000);
+    const uptakeLine = uptake.uptakeRate === null
+      ? "  uptake: n/a (no derived insights found)"
+      : `  uptake: ${(uptake.uptakeRate * 100).toFixed(1)}% (${uptake.derivedRead}/${uptake.derivedTotal} read ≥1)`;
+
     const lines = [
       `Total entries: ${stats.totalCount}`,
       "",
@@ -562,6 +571,10 @@ registerTool(
       ...Object.entries(stats.categoryCounts || {})
         .sort((a, b) => b[1] - a[1])
         .map(([cat, count]) => `  ${cat}: ${count}`),
+      "",
+      `Synthesis uptake${uptake.truncated ? ` (scan capped at ${uptake.scanned})` : ""}:`,
+      `  derived insights: ${uptake.derivedTotal}`,
+      uptakeLine,
     ];
 
     return {

package/src/mcp-tools-core.ts

@@ -16,6 +16,7 @@ import { buildManagedCheckpointObservation, buildManagedResumeObservation } from
 import { buildWorkflowObservationRecord } from "./workflow-observation-engine.js";
 import type { ToolRegistryDeps } from "./mcp-tool-deps.js";
 import type { RetrievalResult } from "./retriever.js";
+import { DependsOnSchema } from "./freshness.js";
 
 export function registerCoreTools(deps: ToolRegistryDeps): void {
   const { registerTool, getComponents, config, checkpointStore, conflictStore, workflowObservationStore, getKGExtractor, getKGStore, auditLogger } = deps;
@@ -93,8 +94,9 @@ registerTool(
         reliability: z.enum(["direct", "inferred", "hearsay"]).optional(),
       }),
     ]).optional().describe("Optional confidence override: number (0-1) or {score, reliability}. Auto-assigned from source if omitted."),
+    dependsOn: DependsOnSchema.optional().describe("Optional freshness dependencies (borrowed). Declare what this memory depends on so recall shows a cheap validity verdict (exact/compatible/uncertain/invalid). Items: {kind:'file'|'git-rev', ref, expected?}. file → ref=path, expected=mtime-ms string; git-rev → ref=repo path, expected=commit hash (short ok). expected may be an array: first=exact, rest=compatible set. Omit expected for existence-only checks."),
   },
-  async ({ text, category, importance, scope, source, tags, canonicalKey, topicTag, privacyTier, validUntil, eventTime, confidence }) => {
+  async ({ text, category, importance, scope, source, tags, canonicalKey, topicTag, privacyTier, validUntil, eventTime, confidence, dependsOn }) => {
     const { store, embedder } = getComponents();
     const kgExtractor = getKGExtractor();
     const stored = await persistMemory({
@@ -118,6 +120,8 @@ registerTool(
       eventTime,
       // F1: Pass confidence override (extracted by persistMemory before Zod parse)
       confidence,
+      // Freshness: pass dependsOn (extracted by persistMemory before Zod parse)
+      dependsOn,
     });
 
     return {

package/src/memory-boundaries.ts

@@ -61,8 +61,29 @@ export interface IngestBoundaryResolution {
   boundary: MemoryBoundaryMetadata;
 }
 
-const TRANSCRIPT_SOURCES = new Set(["cc", "codex", "gemini"]);
-const TRANSCRIPT_SCOPE_PREFIXES = ["cc:", "codex:", "gemini:"];
+// 在栈各端的 transcript 来源与 scope 前缀。
+// ⚠️ 接入新的 AI 端时必须同步这两处 —— 漏掉的端不会被认成 evidence 层，
+// 其会话碎片既不会被降权，也会被 layer admission 当成 durable 结论放行。
+// （kimi / antigravity 就漏了：kimi 2026-07-19 进栈、antigravity 07-29 进栈，
+//   直到 08-01 才发现库里的 `kimi:` scope 一直被当结论对待。）
+//
+// minis（2026-08-12 加，iPhone 上的 Minis agent，经 iCloud 文件信箱回流对话记录）：
+// 这一次是**接入前先补**，不是事后发现——补的动机值得记下来，因为 Minis 比前面几端更危险。
+// 它的 CLI 把 agent 自己的工具调用回传也标成 `type:"user"` / `role:"user"`（实测一场对话
+// 137 条里 69 条 user，其中仅 11 条是真人发言，另外 58 条是 `[Tool result: ...]`）。
+// 所以漏掉它不只是"碎片被当结论"，而是**把 shell 输出提炼成用户说过的话**——
+// 例如 `ssh: connect to host ... timed out` 会变成一条"用户说过"的记忆。
+// 导出侧已在上游过滤（只导真人对话），这里是第二道闸：即使某次导出没过滤干净，
+// 走 ingest 的内容也会被正确降权到 evidence 层，而不是当成 durable 结论。
+const TRANSCRIPT_SOURCES = new Set(["cc", "codex", "gemini", "kimi", "antigravity", "minis"]);
+const TRANSCRIPT_SCOPE_PREFIXES = [
+  "cc:",
+  "codex:",
+  "gemini:",
+  "kimi:",
+  "antigravity:",
+  "minis:",
+];
 
 export function getConflictPolicyForCategory(category: DurableMemoryCategory): MemoryConflictPolicy {
   return category === "events" || category === "cases"

package/src/memory-health-rebalance.ts

@@ -125,6 +125,10 @@ function computeTierAccessSignal(
   }
 }
 
+// ⚠️ 约束（2026-07-21 通用Wiki上下文记忆Agent方案借鉴审计 P1-4）：本函数用 accessCount 参与
+// importance 计算（importance←accessSignal，越常访问 importance 越高的马太逻辑）。当前为孤儿代码——
+// 全树仅测试引用、生产侧零 import。接线前须评估与「usage 只进检索先验、绝不抬 importance/事实置信」
+// 立场的冲突：频次抬 importance 会自增强（越常召回越权威），违反该立场。接线须 Alice 明确批准。
 export function computeRebalancedImportance(
   currentImportance: number,
   tier: MemoryTier,

package/src/memory-output.ts

@@ -6,6 +6,7 @@ import { extractMultiVectorText } from "./multi-vector.js";
 import { parseNarrative } from "./narrative-schema.js";
 import { getConfidence, getConfidenceMetadata } from "./confidence-tracker.js";
 import { estimateTokens } from "./context-collapse-renderer.js";
+import { evaluateEntryFreshness, createFreshnessCache } from "./freshness.js";
 
 interface MemoryMetadata {
   source?: string;
@@ -348,11 +349,15 @@ export function formatBriefResults(
   context: { query: string },
 ): string {
   if (results.length === 0) return "No results found.";
+  const freshnessCache = createFreshnessCache();
   const lines = [`Query: ${context.query}`, `Hits: ${results.length}`, ""];
   for (let i = 0; i < results.length; i++) {
     const r = results[i];
     const excerpt = extractBriefExcerpt(r);
-    lines.push(`#${i + 1} ${r.entry.id.slice(0, 8)} ${(r.score * 100).toFixed(1)}% — ${excerpt}`);
+    // Freshness suffix: only for memories that declared dependsOn (opt-in, cheap check).
+    const fresh = evaluateEntryFreshness(r.entry.metadata, freshnessCache);
+    const freshTag = fresh ? ` [fresh:${fresh}]` : "";
+    lines.push(`#${i + 1} ${r.entry.id.slice(0, 8)} ${(r.score * 100).toFixed(1)}% — ${excerpt}${freshTag}`);
   }
   return lines.join("\n");
 }
@@ -363,6 +368,7 @@ export function formatFullResults(
 ): string {
   if (results.length === 0) return "No results found.";
 
+  const freshnessCache = createFreshnessCache();
   const lines = [
     `Query   : ${context.query}`,
     `Profile : ${context.profile}`,
@@ -380,6 +386,7 @@ export function formatFullResults(
     const meta = parseMetadata(results[i].entry);
     const evolution = typeof meta.evolutionStatus === "string" ? meta.evolutionStatus : "-";
     const accessCount = typeof meta.accessCount === "number" ? String(meta.accessCount) : "-";
+    const readers = typeof meta.distinctReaderCount === "number" ? String(meta.distinctReaderCount) : "-";
     const importance = results[i].entry.importance.toFixed(2);
     const tags = Array.isArray(meta.tags) ? (meta.tags as string[]).join(", ") : "-";
     // Emotion metadata (from emotion-detector)
@@ -396,7 +403,10 @@ export function formatFullResults(
     const confPart = confMeta
       ? ` confidence=${confMeta.score.toFixed(2)}(${confMeta.reliability})`
       : "";
-    lines.push(`   meta : evolution=${evolution} accessCount=${accessCount} importance=${importance} tags=[${tags}]${confPart}${emotionPart}${narrativePart}`);
+    lines.push(`   meta : evolution=${evolution} accessCount=${accessCount} readers=${readers} importance=${importance} tags=[${tags}]${confPart}${emotionPart}${narrativePart}`);
+    // Freshness: only shown for memories that declared dependsOn (opt-in, cheap check).
+    const fresh = evaluateEntryFreshness(results[i].entry.metadata, freshnessCache);
+    if (fresh) lines.push(`   fresh: ${fresh}`);
   }
 
   return lines.join("\n");
@@ -408,6 +418,7 @@ export function formatSearchResults(
 ): string {
   if (results.length === 0) return "No results found.";
 
+  const freshnessCache = createFreshnessCache();
   const lines = [
     `Query   : ${context.query}`,
     `Profile : ${context.profile}`,
@@ -421,6 +432,9 @@ export function formatSearchResults(
     const row = buildSearchRow(i, context.query, results[i]);
     lines.push(`${row[0]} ${row[1]} ${row[2]} ${row[3]} ${row[4]} ${row[5]} ${row[6]} ${row[7]} ${row[8]} | ${row[9]}`);
     lines.push(`   prov : ${getProvenanceSummary(results[i])}`);
+    // Freshness: only shown for memories that declared dependsOn (opt-in, cheap check).
+    const fresh = evaluateEntryFreshness(results[i].entry.metadata, freshnessCache);
+    if (fresh) lines.push(`   fresh: ${fresh}`);
   }
 
   return lines.join("\n");