recallnest 3.0.0 → 4.0.0

package/src/ingest.ts

@@ -13,6 +13,7 @@ import { join, basename, resolve, dirname } from "node:path";
 import { homedir } from "node:os";
 import { detectLang, tokenizeFts } from "./language-hook.js";
 import { redactSecrets } from "./pii-detector.js";
+import { normalizeDedupText } from "./text-fingerprint.js";
 import type { MemoryStore, MemoryEntry } from "./store.js";
 import type { Embedder } from "./embedder.js";
 import { chunkDocument, type ChunkerConfig } from "./chunker.js";
@@ -35,6 +36,8 @@ import {
 import { compressToolOutput } from "./tool-output-compressor.js";
 import { tagNarrativeIfEnabled } from "./narrative-tagger.js";
 
+export { normalizeDedupText };
+
 // ============================================================================
 // Types
 // ============================================================================
@@ -53,6 +56,8 @@ export interface IngestResult {
   chunksDeduped: number;
   dedupReasonCounts: DedupReasonCounts;
   errors: string[];
+  /** 子 agent 独立会话文件被整文件跳过的数量（目前只有 Codex 分支会产生；见 isCodexSubagentSessionFile）。 */
+  subagentFilesSkipped?: number;
 }
 
 interface ConversationTurn {
@@ -60,6 +65,29 @@ interface ConversationTurn {
   text: string;
   timestamp: string;
   sessionId: string;
+  /**
+   * 本条记忆所在 session 里用户亲手贴的图片总数——注意是整个 session 的，
+   * 不是本轮的张数。工具产的图（截图 / 读图，实测占全部图片九成）不计。
+   *
+   * 粒度取 session 而不是轮次，是有意的（2026-08-27 定）：图所在的那一轮
+   * 常常因为正文太短根本没进库，精确坐标挂不上去；而同 session 的别的轮次
+   * 进了库。打成 session 级的标，搜到那些轮次时才能顺藤摸到图。
+   *
+   * 代价是精度低：一个 session 里几十条记忆会带同一个标，图未必跟搜到的
+   * 这一条有关。这是粒度换覆盖，明知而为——判断值不值得看，回 Deja 按
+   * session 读原文，图本体不进库。
+   */
+  sessionImages?: number;
+  /**
+   * 本 session 里 AI 自己产的图片总数：工具截图、读进来的图片文件、模型生成的图。
+   * 实测它是用户贴图的三倍多（5812 vs 1629）。
+   *
+   * 跟 sessionImages 分开计，因为两者服务的检索意图不是一回事——人找「我发过的
+   * 那张截图」要的是前者；agent 回溯「我当时生成的示意图长什么样」「那个页面当时
+   * 渲染成什么样」要的是后者。混成一个数，两种意图都答不好；只留前者，则 agent
+   * 自己回溯时看不见任何线索。
+   */
+  sessionToolImages?: number;
 }
 
 // ============================================================================
@@ -88,19 +116,21 @@ export type DedupReason = "hard" | "exact" | "llm-skip" | "llm-merge" | "unique"
 
 export type DedupReasonCounts = Record<DedupReason, number>;
 
-/** Secondary action on an existing memory during dedup (e.g., delete outdated entries). */
-export interface DedupAction {
-  id: string;
-  action: "delete";
-  reason: string;
-}
-
+/**
+ * 去重结论只回答「这条进来的切片存不存」，不带任何指向已有记忆的动作。
+ *
+ * 2026-10-05 之前这里还有一个 `secondaryDeletes`：模型可以顺手标记「过时」的已有记忆，
+ * 导入调用点原样 `store.delete`——候选不分 scope，不写审计、不记日志、错误吞掉。
+ * 2026-09-22T16:38:03Z 记忆文件导入就这样删掉了当天手写进人工维护那一层的一条偏好，
+ * 11 秒后同一轮导入写入了内容相近的文档切片；到 10-05 核对时，显式存过、不在主表、又没有
+ * forget 记录的手写记忆有 17 条。导入只新增和跳过，删除一律走 forget_memory（有隐私级别
+ * 检查与审计）。经过与数字见 CHANGELOG「Ingest dedup can no longer delete existing memories」；
+ * 回归用例 `ingest-dedup-no-deletes.test.ts`。
+ */
 export interface DedupCheckResult {
   action: "store" | "skip";
   reason: DedupReason;
   existingText?: string;
-  /** Secondary actions on other existing memories (only populated with LLM dedup). */
-  secondaryDeletes?: DedupAction[];
 }
 
 function createDedupReasonCounts(): DedupReasonCounts {
@@ -120,26 +150,6 @@ function recordDedupDecision(result: IngestResult, decision: DedupCheckResult):
   }
 }
 
-/**
- * Execute secondary delete actions from a dedup decision.
- * Errors are isolated per-action to avoid cascading failures.
- */
-async function executeSecondaryDeletes(
-  store: MemoryStore,
-  deletes: DedupAction[],
-): Promise<number> {
-  let executed = 0;
-  for (const del of deletes) {
-    try {
-      await store.delete(del.id);
-      executed++;
-    } catch {
-      // Per-action error isolation: log and continue
-    }
-  }
-  return executed;
-}
-
 export function getDedupSkippedCount(result: IngestResult): number {
   return result.dedupReasonCounts.hard
     + result.dedupReasonCounts.exact
@@ -158,22 +168,6 @@ export function formatDedupReasonSummary(result: IngestResult): string {
   return `hard:${counts.hard}, exact:${counts.exact}, llm-skip:${counts["llm-skip"]}, llm-merge:${counts["llm-merge"]}`;
 }
 
-/**
- * Two-stage dedup: vector pre-filter + optional LLM semantic decision.
- *
- * Returns: "store" | "skip"
- *
- * Note: when the LLM says MERGE, we currently keep the new chunk instead of
- * dropping it. We do not have a structured ingest-time merge path yet, and
- * swallowing "same topic + new information" transcript chunks is worse for
- * recall fidelity than storing an incremental near-duplicate.
- */
-function normalizeDedupText(value: string): string {
-  return value
-    .replace(/^\[(用户|助手)\]\s*/gm, "")
-    .replace(/\s+/g, " ")
-    .trim();
-}
 
 /**
  * Detect content that carries temporal events, file operations, or explicit
@@ -283,6 +277,16 @@ function shouldForceCreateToolChoicePreference(
     : { shouldForceCreate: false };
 }
 
+/**
+ * Two-stage dedup: vector pre-filter + optional LLM semantic decision.
+ *
+ * Returns: "store" | "skip"
+ *
+ * Note: when the LLM says MERGE, we currently keep the new chunk instead of
+ * dropping it. We do not have a structured ingest-time merge path yet, and
+ * swallowing "same topic + new information" transcript chunks is worse for
+ * recall fidelity than storing an incremental near-duplicate.
+ */
 export async function dedupCheck(
   store: MemoryStore,
   vector: number[],
@@ -392,8 +396,6 @@ export async function dedupCheck(
         const hasMulti = typeof (llm as any).dedupDecisionMulti === "function";
 
         let primaryAction: "CREATE" | "MERGE" | "SKIP" = "CREATE";
-        let primaryReason = "";
-        const secondaryDeletes: DedupAction[] = [];
 
         if (hasMulti) {
           const candidates = results
@@ -401,48 +403,20 @@ export async function dedupCheck(
             .slice(0, DEDUP_CANDIDATE_LIMIT)
             .map(r => ({ id: r.entry.id, text: r.entry.text }));
 
+          // 只取「存 / 并 / 跳」这一个结论。候选来自全库（不分 scope），模型对它们没有处置权，
+          // 见 DedupCheckResult 上方的说明。
           const decision = await llm.dedupDecisionMulti(text, candidates);
           primaryAction = decision.action;
-          primaryReason = decision.reason;
-
-          // Build secondary deletes from validated actions (resolve IDs at parse time)
-          if (decision.actions) {
-            for (const act of decision.actions) {
-              const target = candidates[act.match_index - 1];
-              if (target) {
-                secondaryDeletes.push({
-                  id: target.id,
-                  action: "delete",
-                  reason: typeof act.reason === "string" ? act.reason : "",
-                });
-              }
-            }
-          }
         } else {
           const decision = await llm.dedupDecision(text, existingText);
           primaryAction = decision.action;
-          primaryReason = decision.reason;
         }
 
         if (primaryAction === "SKIP") {
-          return {
-            action: "skip",
-            reason: "llm-skip",
-            existingText,
-            ...(secondaryDeletes.length > 0 ? { secondaryDeletes } : {}),
-          };
+          return { action: "skip", reason: "llm-skip", existingText };
         }
         if (primaryAction === "MERGE") {
-          return {
-            action: "store",
-            reason: "llm-merge",
-            existingText,
-            ...(secondaryDeletes.length > 0 ? { secondaryDeletes } : {}),
-          };
-        }
-        // CREATE — still execute secondary deletes if any
-        if (secondaryDeletes.length > 0) {
-          return { action: "store", reason: "unique", secondaryDeletes };
+          return { action: "store", reason: "llm-merge", existingText };
         }
       } catch {
         // LLM failed, fall through to store
@@ -493,7 +467,7 @@ function fallbackExtraction(text: string): SmartExtraction {
  * Uses LLM 6-category extraction when available, falls back to heuristic.
  * Returns: category + L0 + L1 + importance for each text.
  */
-async function smartExtractBatch(
+export async function smartExtractBatch(
   texts: string[],
   llm?: LLMClient | null,
 ): Promise<SmartExtraction[]> {
@@ -522,7 +496,7 @@ function isCoreSummaryEnabled(): boolean {
  * Only runs when RECALLNEST_CORE_SUMMARY=true and LLM is available.
  * Returns null array when disabled (no overhead).
  */
-async function generateCoreSummaries(
+export async function generateCoreSummaries(
   texts: string[],
   llm?: LLMClient | null,
 ): Promise<(string | null)[]> {
@@ -649,13 +623,20 @@ export async function drainPendingQueue(
         const entryText = extractions[j].l1 || extractions[j].l0;
         const language = detectLang(entryText);
         const fts_text = tokenizeFts(entryText, language);
-        await store.store({
+        // 2026-08-24 修：回填路径此前直接 store.store()，绕过 buildIngestedEntry，
+        // 导致条目缺 boundary/layer/tier（transcript 碎片不降权）。改走同一构造器；
+        // 入队时未保留原文件路径，file 用 "pending-queue" 诚实标记回填来源。
+        const entry = buildIngestedEntry({
+          source: batch[j].scope.split(":")[0],
+          scope: batch[j].scope,
           text: entryText,
           vector: vectors[j],
-          category: extractions[j].category as any,
-          scope: batch[j].scope,
-          importance: extractions[j].importance,
-          metadata: JSON.stringify({ source: batch[j].scope.split(":")[0], l0_abstract: extractions[j].l0, l1_overview: extractions[j].l1, l2_content: extractions[j].l1 || extractions[j].l0 }),
+          extraction: extractions[j],
+          file: "pending-queue",
+        });
+        await store.store({
+          ...entry,
+          category: entry.category as any,
           language,
           fts_text,
         });
@@ -685,7 +666,7 @@ function initialTier(extraction: Pick<SmartExtraction, "category" | "importance"
   return "peripheral";
 }
 
-function buildIngestedEntry(params: {
+export function buildIngestedEntry(params: {
   source: string;
   scope: string;
   text: string;
@@ -696,6 +677,10 @@ function buildIngestedEntry(params: {
   heading?: string;
   /** Tier 3.1: optional core summary (≤200 chars) for token-efficient context output */
   coreSummary?: string | null;
+  /** 本条记忆所在 session 里用户亲手贴的图片总数；无图时不传 */
+  sessionImages?: number;
+  /** 本条记忆所在 session 里 AI 自己产的图片总数（截图 / 读图 / 生图）；无则不传 */
+  sessionToolImages?: number;
 }): {
   text: string;
   vector: number[];
@@ -739,6 +724,8 @@ function buildIngestedEntry(params: {
       l1_overview: params.extraction.l1,
       l2_content: params.text,
       ...(params.coreSummary ? { core_summary: params.coreSummary } : {}),
+      ...(params.sessionImages ? { sessionImages: params.sessionImages } : {}),
+      ...(params.sessionToolImages ? { sessionToolImages: params.sessionToolImages } : {}),
       tier,
       boundary: resolution.boundary,
       ...(narrative ? { narrative } : {}),
@@ -786,16 +773,77 @@ const MARKDOWN_CHUNK_CONFIG: ChunkerConfig = {
 // CC Transcript Parser
 // ============================================================================
 
-function parseCCTranscript(filePath: string): ConversationTurn[] {
+/**
+ * 数一条 transcript 记录里所有的图片信号，**不预设它们是什么用途、在什么位置**。
+ *
+ * 这是有意的宽口径：AI 产图的形态一直在长（工具截图、读进来的图片文件、模型生图、
+ * 写公众号时让它配的插图……），任何"列举有哪几类"的写法都注定漏掉下一类。所以这里
+ * 只回答一个问题——「这是不是一张图」，然后由调用方用**补集**去定义 AI 产图：
+ * 整条记录里的图 减去 用户在消息里亲手贴的，剩下的全算，不问出身。
+ *
+ * 判据是「携带图片的块」的三种通用形态，跨 Anthropic / OpenAI / Kimi 都成立：
+ *   - type 里含 image（image / input_image / image_url / image_generation_* …）
+ *   - 有 image_url / imageUrl 字段
+ *   - 有 media_type / mimeType 且以 image/ 开头
+ *
+ * ⚠️ 这是**信号计数不是精确张数**：一次生图可能同时留下 call 与 end 两条记录，
+ * 会被数成 2。这是刻意选的方向——宁可多算，不可漏报，因为它服务的问题是
+ * 「这附近有没有图」而不是「精确几张」。
+ */
+function countImageSignals(node: unknown, depth = 0): number {
+  if (depth > 10 || node === null || typeof node !== "object") return 0;
+  if (Array.isArray(node)) {
+    let sum = 0;
+    for (const item of node) sum += countImageSignals(item, depth + 1);
+    return sum;
+  }
+
+  const obj = node as Record<string, unknown>;
+  const type = obj.type;
+  const mediaType = obj.media_type ?? obj.mimeType;
+  const isImageBlock =
+    (typeof type === "string" && type.includes("image")) ||
+    typeof obj.image_url === "string" ||
+    (obj.imageUrl !== null && typeof obj.imageUrl === "object") ||
+    (typeof mediaType === "string" && mediaType.startsWith("image/"));
+
+  // 命中即计一次并停止下钻：一个图片块内部不会再嵌另一张独立的图，继续递归
+  // 只会把 {type:"image", source:{media_type:"image/png"}} 这种数成两张。
+  if (isImageBlock) return 1;
+
+  let count = 0;
+  for (const value of Object.values(obj)) {
+    if (value !== null && typeof value === "object") {
+      count += countImageSignals(value, depth + 1);
+    }
+  }
+  return count;
+}
+
+export function parseCCTranscript(filePath: string): ConversationTurn[] {
   const turns: ConversationTurn[] = [];
   const content = readFileSync(filePath, "utf-8");
   const lines = content.split("\n").filter((l) => l.trim());
 
   let sessionId = "";
+  // 整个 session 里的图片计数，扫完全文后统一盖到每个 turn 上。两类分开数：
+  // 用户亲手贴的 vs AI 自己产的（工具截图 / 读图 / 生图）。
+  // 数得到是因为本函数本来就逐行读完整个文件，顺带累加不额外花钱。
+  let sessionImages = 0;
+  let sessionToolImages = 0;
 
   for (const line of lines) {
     try {
       const obj = JSON.parse(line);
+      // 子 agent 侧链（isSidechain:true）的 user 行是主 agent 写给子 agent 的任务信封，不是人说的话。
+      // 今天 CC 把侧链分文件存在 <session>/subagents/agent-*.jsonl，而本函数的调用方只读项目目录顶层
+      // 的 .jsonl，所以这一行当前不会命中；留着是防 CC 哪天把侧链内联回主文件（2026-09-08 借鉴 ECC
+      // observe.sh 的「按结构字段认谁在说、不认 role」）。
+      if (obj.isSidechain === true) continue;
+      // 这一行里所有的图片信号。用户亲手贴的那部分在下面单独精确认，
+      // 其余的一律按补集归入 AI 产图——不枚举它是截图、读图、生图还是配图。
+      const lineImageSignals = countImageSignals(obj);
+      let lineUserImages = 0;
 
       if (!sessionId && obj.sessionId) {
         sessionId = obj.sessionId;
@@ -804,20 +852,39 @@ function parseCCTranscript(filePath: string): ConversationTurn[] {
       if (obj.type === "user" && obj.message) {
         const msg = obj.message;
         let text = "";
+        let turnImages = 0;
         if (typeof msg.content === "string") {
           text = msg.content;
         } else if (Array.isArray(msg.content)) {
-          // Extract text blocks, skip tool_use/tool_result/images
+          // 文本块照旧提取，tool_use / tool_result 仍然整块丢弃（架构决定，见 memory-boundaries）。
+          // 图片本体也不进库，只数一下：这里只认顶层的 image block，
+          // tool_result 里内嵌的不算——那是工具截图/读图，实测占全部图片九成。
           text = msg.content
             .filter((c: any) => c.type === "text")
             .map((c: any) => c.text || "")
             .join("\n");
+          turnImages = msg.content.filter((c: any) => c?.type === "image").length;
         }
-
-        if (text.trim().length > 10) {
+        sessionImages += turnImages;
+        lineUserImages = turnImages;
+
+        // 只贴图不配字的那一轮，此前会被长度闸整条丢掉——实测占含图轮次的 12.5%，
+        // 且丢掉的常是「操作步骤在这里」+ 截图这类正文全在图里的高价值轮次
+        // （最极端的样本是 0 字配 7 张图）。给它一个占位正文，让它能跟下一条
+        // 助手回复合成 chunk——助手的回复通常描述了图里是什么，那就是定位这些图的文字。
+        //
+        // 有配文时正文一个字都不改：文字本身已是检索入口，往里塞标记只会稀释 embedding。
+        const trimmed = text.trim();
+        const body = trimmed.length > 0
+          ? trimmed
+          : turnImages > 0
+            ? `[图片×${turnImages}]`
+            : "";
+
+        if (body.length > 10 || turnImages > 0) {
           turns.push({
             role: "user",
-            text: text.trim(),
+            text: body,
             timestamp: obj.timestamp || "",
             sessionId,
           });
@@ -846,11 +913,26 @@ function parseCCTranscript(filePath: string): ConversationTurn[] {
           });
         }
       }
+
+      // 补集：这一行里除用户亲手贴的之外的图，全算 AI 产的，不问出身。
+      // 用补集而不是列举，是因为 AI 产图的形态会一直长（生图、截图、读图、
+      // 写文章时的配图……），任何枚举都注定漏掉下一类。
+      sessionToolImages += Math.max(0, lineImageSignals - lineUserImages);
     } catch {
       // Skip malformed lines
     }
   }
 
+  // 整份 transcript 扫完才知道总数，统一盖到每个 turn 上——这条标记回答的是
+  // 「这条记忆所在的 session 里有没有图」，不是「这一轮有没有图」。图所在的那轮
+  // 常因正文太短进不了库，只有盖到同 session 的其他轮次上，才可能被搜到。
+  if (sessionImages > 0 || sessionToolImages > 0) {
+    for (const turn of turns) {
+      if (sessionImages > 0) turn.sessionImages = sessionImages;
+      if (sessionToolImages > 0) turn.sessionToolImages = sessionToolImages;
+    }
+  }
+
   return turns;
 }
 
@@ -872,12 +954,26 @@ export function groupTurnsIntoChunks(turns: ConversationTurn[]): Array<{
   text: string;
   timestamp: string;
   sessionId: string;
+  sessionImages?: number;
+  sessionToolImages?: number;
 }> {
   const filtered = filterNoiseTurns(turns);
-  const chunks: Array<{ text: string; timestamp: string; sessionId: string }> = [];
+  const chunks: Array<{
+    text: string;
+    timestamp: string;
+    sessionId: string;
+    sessionImages?: number;
+    sessionToolImages?: number;
+  }> = [];
 
   for (let i = 0; i < filtered.length; i++) {
     const turn = filtered[i];
+    // 同一 session 切出来的每个 chunk 都带同一个标——它说的是「这个 session 有图」，
+    // 跟这一片本身有没有图无关，这正是 session 粒度要的效果。
+    const imgMark = {
+      ...(turn.sessionImages ? { sessionImages: turn.sessionImages } : {}),
+      ...(turn.sessionToolImages ? { sessionToolImages: turn.sessionToolImages } : {}),
+    };
 
     // If this is a user turn followed by an assistant turn, merge them
     if (turn.role === "user" && i + 1 < filtered.length && filtered[i + 1].role === "assistant") {
@@ -896,10 +992,10 @@ export function groupTurnsIntoChunks(turns: ConversationTurn[]): Array<{
           if (seg.text.length > CONVERSATION_CHUNK_CONFIG.maxChunkSize) {
             const chunkResult = chunkDocument(seg.text, CONVERSATION_CHUNK_CONFIG);
             for (const chunk of chunkResult.chunks) {
-              chunks.push({ text: chunk, timestamp: turn.timestamp, sessionId: turn.sessionId });
+              chunks.push({ text: chunk, timestamp: turn.timestamp, sessionId: turn.sessionId, ...imgMark });
             }
           } else {
-            chunks.push({ text: seg.text, timestamp: turn.timestamp, sessionId: turn.sessionId });
+            chunks.push({ text: seg.text, timestamp: turn.timestamp, sessionId: turn.sessionId, ...imgMark });
           }
         }
       } else {
@@ -907,6 +1003,7 @@ export function groupTurnsIntoChunks(turns: ConversationTurn[]): Array<{
           text: merged,
           timestamp: turn.timestamp,
           sessionId: turn.sessionId,
+          ...imgMark,
         });
       }
 
@@ -925,10 +1022,10 @@ export function groupTurnsIntoChunks(turns: ConversationTurn[]): Array<{
           if (seg.text.length > CONVERSATION_CHUNK_CONFIG.maxChunkSize) {
             const chunkResult = chunkDocument(seg.text, CONVERSATION_CHUNK_CONFIG);
             for (const chunk of chunkResult.chunks) {
-              chunks.push({ text: chunk, timestamp: turn.timestamp, sessionId: turn.sessionId });
+              chunks.push({ text: chunk, timestamp: turn.timestamp, sessionId: turn.sessionId, ...imgMark });
             }
           } else {
-            chunks.push({ text: seg.text, timestamp: turn.timestamp, sessionId: turn.sessionId });
+            chunks.push({ text: seg.text, timestamp: turn.timestamp, sessionId: turn.sessionId, ...imgMark });
           }
         }
       } else {
@@ -936,6 +1033,7 @@ export function groupTurnsIntoChunks(turns: ConversationTurn[]): Array<{
           text,
           timestamp: turn.timestamp,
           sessionId: turn.sessionId,
+          ...imgMark,
         });
       }
     }
@@ -959,18 +1057,48 @@ export function groupTurnsIntoChunks(turns: ConversationTurn[]): Array<{
 // Codex Session Parser
 // ============================================================================
 
-function parseCodexSession(filePath: string): ConversationTurn[] {
+/**
+ * Codex multi_agent 派出的子 agent 会话是独立的 rollout 文件，首行 session_meta 带 parent_thread_id
+ * （另有 agent_nickname / agent_role / multi_agent_version）。文件里 role=user 的 input_text 是主 agent
+ * 派的任务，不是人说的话——2026-09-08 实测本机 5,597 个 Codex 会话文件里 2,555 个（45.6%）是子 agent 文件，
+ * 其 user turn 占全部 user turn 的 46.7%（近 7 天 63.7%）。ingest 前整文件跳过，与 Kimi 分支只读
+ * agents/main/wire.jsonl 同一个判据：按结构字段认「谁在说」，不认 role。只读首行，不整读文件。
+ */
+export function isCodexSubagentSessionFile(filePath: string): boolean {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const nl = content.indexOf("\n");
+    const first = (nl === -1 ? content : content.slice(0, nl)).trim();
+    if (!first) return false;
+    const obj = JSON.parse(first);
+    if (obj?.type !== "session_meta") return false;
+    const parent = obj.payload?.parent_thread_id;
+    return typeof parent === "string" && parent.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+export function parseCodexSession(filePath: string): ConversationTurn[] {
   const turns: ConversationTurn[] = [];
   const content = readFileSync(filePath, "utf-8");
   const lines = content.split("\n").filter((l) => l.trim());
 
   let sessionId = "";
+  // 同 parseCCTranscript：两类图片分开计数。
+  // Codex 的图片字段是 input_image（OpenAI 格式），不是 Anthropic 的 image；
+  // 用户贴的在 payload.content 里可以精确认；其余一律按补集归 AI 产图。
+  let sessionImages = 0;
+  let sessionToolImages = 0;
 
   for (const line of lines) {
     try {
       const obj = JSON.parse(line);
       const payload = obj.payload;
       const timestamp = obj.timestamp || "";
+      // 同 parseCCTranscript：整行图片信号，减去用户贴的，剩下全归 AI 产
+      const lineImageSignals = countImageSignals(obj);
+      let lineUserImages = 0;
 
       if (obj.type === "session_meta" && payload?.id) {
         sessionId = payload.id;
@@ -982,6 +1110,13 @@ function parseCodexSession(filePath: string): ConversationTurn[] {
         const content = payload.content;
 
         if (Array.isArray(content)) {
+          // 只精确认用户消息里的 input_image；Codex 自己生的图 / 读的图挂在
+          // payload.output 等别处，由下面的补集统一接住，这里不去枚举它们。
+          if (role === "user") {
+            const own = content.filter((c: any) => c?.type === "input_image").length;
+            sessionImages += own;
+            lineUserImages += own;
+          }
           for (const c of content) {
             if (c.type === "input_text" && c.text && c.text.length > 10) {
               // Skip system/developer prompts (usually very long instructions)
@@ -1023,11 +1158,21 @@ function parseCodexSession(filePath: string): ConversationTurn[] {
           }
         }
       }
+
+      // 补集：除用户亲手贴的之外，这一行里的图全算 AI 产的，不问出身。
+      sessionToolImages += Math.max(0, lineImageSignals - lineUserImages);
     } catch {
       // Skip malformed lines
     }
   }
 
+  if (sessionImages > 0 || sessionToolImages > 0) {
+    for (const turn of turns) {
+      if (sessionImages > 0) turn.sessionImages = sessionImages;
+      if (sessionToolImages > 0) turn.sessionToolImages = sessionToolImages;
+    }
+  }
+
   return turns;
 }
 
@@ -1099,6 +1244,14 @@ export async function ingestCodexSessions(
         continue;
       }
 
+      // 子 agent 独立会话整文件跳过（判据与理由见 isCodexSubagentSessionFile）。标记 processed 是为了
+      // 下一轮非 --recent 的增量不再重读它；子 agent 的结论本就该由主 agent 落盘，原文由 Deja 全量索引兜底。
+      if (isCodexSubagentSessionFile(filePath)) {
+        result.subagentFilesSkipped = (result.subagentFilesSkipped ?? 0) + 1;
+        markProcessed(filePath, stat.size, 0, stat.mtimeMs);
+        continue;
+      }
+
       const turns = parseCodexSession(filePath);
       if (turns.length === 0) {
         result.chunksSkipped++;
@@ -1133,9 +1286,6 @@ export async function ingestCodexSessions(
             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]);
@@ -1164,6 +1314,8 @@ export async function ingestCodexSessions(
                   sessionId: chunk.sessionId,
                   file: basename(filePath),
                   coreSummary: coreSummaries[j],
+                  sessionImages: chunk.sessionImages,
+                  sessionToolImages: chunk.sessionToolImages,
                 }));
               }
             }
@@ -1205,7 +1357,7 @@ export async function ingestCodexSessions(
 //   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[] {
+export function parseKimiSession(filePath: string): ConversationTurn[] {
   const turns: ConversationTurn[] = [];
   const content = readFileSync(filePath, "utf-8");
   const lines = content.split("\n").filter((l) => l.trim());
@@ -1215,6 +1367,11 @@ function parseKimiSession(filePath: string): ConversationTurn[] {
   const pathParts = filePath.split("/");
   const rawId = pathParts.length >= 4 ? pathParts[pathParts.length - 4] : basename(filePath, ".jsonl");
   const sessionId = rawId.replace(/^session_/, "");
+  // 同 parseCCTranscript：两类图片分开计数。
+  // Kimi 的图片字段是 image_url；用户贴的在 turn.prompt / context.append_message，
+  // AI 产的在 context.append_loop_event 的 tool.result 里。
+  let sessionImages = 0;
+  let sessionToolImages = 0;
 
   const pushTurn = (role: "user" | "assistant", text: string, timestamp: string) => {
     const trimmed = text.trim();
@@ -1231,6 +1388,23 @@ function parseKimiSession(filePath: string): ConversationTurn[] {
       const obj = JSON.parse(line);
       const timestamp = typeof obj.time === "number" ? new Date(obj.time).toISOString() : "";
 
+      // 图片统计在这里一次算完，不放进下面的分支——那些分支各自 continue，
+      // 放进去会被跳过。用户贴的精确认，其余按补集归 AI 产，不枚举出身。
+      {
+        const lineImageSignals = countImageSignals(obj);
+        let lineUserImages = 0;
+        if (obj.type === "turn.prompt" && obj.origin?.kind === "user" && Array.isArray(obj.input)) {
+          lineUserImages = obj.input.filter((c: any) => c?.type === "image_url").length;
+        } else if (obj.type === "context.append_message") {
+          const m = obj.message;
+          if (m?.role === "user" && m?.origin?.kind === "user" && Array.isArray(m.content)) {
+            lineUserImages = m.content.filter((c: any) => c?.type === "image_url").length;
+          }
+        }
+        sessionImages += lineUserImages;
+        sessionToolImages += Math.max(0, lineImageSignals - lineUserImages);
+      }
+
       if (obj.type === "turn.prompt") {
         if (obj.origin?.kind !== "user") continue;
         const parts = Array.isArray(obj.input) ? obj.input : [];
@@ -1271,6 +1445,13 @@ function parseKimiSession(filePath: string): ConversationTurn[] {
     }
   }
 
+  if (sessionImages > 0 || sessionToolImages > 0) {
+    for (const turn of turns) {
+      if (sessionImages > 0) turn.sessionImages = sessionImages;
+      if (sessionToolImages > 0) turn.sessionToolImages = sessionToolImages;
+    }
+  }
+
   return turns;
 }
 
@@ -1403,9 +1584,6 @@ export async function ingestKimiSessions(
             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]);
@@ -1434,6 +1612,8 @@ export async function ingestKimiSessions(
                   sessionId: chunk.sessionId,
                   file: basename(filePath),
                   coreSummary: coreSummaries[j],
+                  sessionImages: chunk.sessionImages,
+                  sessionToolImages: chunk.sessionToolImages,
                 }));
               }
             }
@@ -1606,9 +1786,6 @@ export async function ingestGeminiSessions(
             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]);
@@ -1676,7 +1853,7 @@ export async function ingestGeminiSessions(
  * Split a markdown file by headings (## or #) into chunks.
  * Each chunk includes the heading + content under it.
  */
-function parseMarkdown(filePath: string): Array<{ text: string; heading: string }> {
+export function parseMarkdown(filePath: string): Array<{ text: string; heading: string }> {
   const content = readFileSync(filePath, "utf-8");
   const chunks: Array<{ text: string; heading: string }> = [];
 
@@ -1758,6 +1935,12 @@ export async function ingestCCTranscripts(
   };
 
   const dir = expandHome(sourcePath);
+  // session-digest.py 摘要调用留下的会话记录不 ingest（2026-08-24 审计：这类
+  // transcript 是原始会话 8000 字符采样的副本，ingest 后 scope/metadata 指向
+  // 摘要任务自身 sid——内容是真的、坐标是假的，已产生 1,950 条 evidence 污染）。
+  if (dir.includes("session-digest")) {
+    return result;
+  }
   if (!existsSync(dir)) {
     result.errors.push(`Directory not found: ${dir}`);
     return result;
@@ -1836,9 +2019,6 @@ export async function ingestCCTranscripts(
             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;
             }
 
@@ -1879,6 +2059,8 @@ export async function ingestCCTranscripts(
               sessionId: chunk.sessionId,
               file,
               coreSummary: coreSummaries[j],
+              sessionImages: chunk.sessionImages,
+              sessionToolImages: chunk.sessionToolImages,
             }));
           }
 
@@ -1988,9 +2170,6 @@ export async function ingestMarkdownFiles(
             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]);
@@ -2122,9 +2301,6 @@ export async function ingestGenericText(
             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]);
@@ -2241,9 +2417,6 @@ export async function ingestConnectorFile(
         if (!options.noDedup) {
           const decision = await dedupCheck(store, vector, texts[j], options.llm);
           recordDedupDecision(result, decision);
-          if (decision.secondaryDeletes?.length) {
-            await executeSecondaryDeletes(store, decision.secondaryDeletes);
-          }
           if (decision.action === "skip") continue;
         }
         dedupedTexts.push(texts[j]);