@memtensor/memos-local-openclaw-plugin 0.3.20 → 1.0.0

package/src/ingest/task-processor.ts

@@ -30,13 +30,16 @@ const SKIP_REASONS = {
 export class TaskProcessor {
   private summarizer: Summarizer;
   private processing = false;
+  private pendingEvents: Array<{ sessionKey: string; latestTimestamp: number; owner: string }> = [];
+  private drainPromise: Promise<void> | null = null;
   private onTaskCompletedCallback?: (task: Task) => void;
 
   constructor(
     private store: SqliteStore,
     private ctx: PluginContext,
   ) {
-    this.summarizer = new Summarizer(ctx.config.summarizer, ctx.log);
+    const strongCfg = ctx.config.skillEvolution?.summarizer;
+    this.summarizer = new Summarizer(ctx.config.summarizer, ctx.log, strongCfg);
   }
 
   onTaskCompleted(cb: (task: Task) => void): void {
@@ -48,25 +51,37 @@ export class TaskProcessor {
    * Determines if a new task boundary was crossed and handles transition.
    */
   async onChunksIngested(sessionKey: string, latestTimestamp: number, owner?: string): Promise<void> {
-    this.ctx.log.debug(`TaskProcessor.onChunksIngested called session=${sessionKey} ts=${latestTimestamp} owner=${owner ?? "agent:main"} processing=${this.processing}`);
-    if (this.processing) {
-      this.ctx.log.debug("TaskProcessor.onChunksIngested skipped — already processing");
-      return;
+    const resolvedOwner = owner ?? "agent:main";
+    this.ctx.log.debug(`TaskProcessor.onChunksIngested called session=${sessionKey} ts=${latestTimestamp} owner=${resolvedOwner} processing=${this.processing}`);
+    this.pendingEvents.push({ sessionKey, latestTimestamp, owner: resolvedOwner });
+
+    if (!this.drainPromise) {
+      this.drainPromise = this.drainPending();
     }
+
+    await this.drainPromise;
+  }
+
+  private async drainPending(): Promise<void> {
     this.processing = true;
     try {
-      await this.detectAndProcess(sessionKey, latestTimestamp, owner ?? "agent:main");
-    } catch (err) {
-      this.ctx.log.error(`TaskProcessor error: ${err}`);
+      while (this.pendingEvents.length > 0) {
+        const next = this.pendingEvents.shift()!;
+        try {
+          await this.detectAndProcess(next.sessionKey, next.latestTimestamp, next.owner);
+        } catch (err) {
+          this.ctx.log.error(`TaskProcessor error: ${err}`);
+        }
+      }
     } finally {
       this.processing = false;
+      this.drainPromise = null;
     }
   }
 
   private async detectAndProcess(sessionKey: string, latestTimestamp: number, owner: string): Promise<void> {
     this.ctx.log.debug(`TaskProcessor.detectAndProcess session=${sessionKey} owner=${owner}`);
 
-    // Finalize any active tasks from OTHER sessions for the SAME owner (session change = task boundary)
     const allActive = this.store.getAllActiveTasks(owner);
     for (const t of allActive) {
       if (t.sessionKey !== sessionKey) {
@@ -75,83 +90,177 @@ export class TaskProcessor {
       }
     }
 
-    const activeTask = this.store.getActiveTask(sessionKey, owner);
+    let activeTask = this.store.getActiveTask(sessionKey, owner);
     this.ctx.log.debug(`TaskProcessor.detectAndProcess activeTask=${activeTask?.id ?? "none"} owner=${owner}`);
 
     if (!activeTask) {
-      await this.createNewTask(sessionKey, latestTimestamp, owner);
-      return;
+      // Create a new empty task — do NOT assign all chunks yet.
+      // processChunksIncrementally will assign them one turn at a time with boundary checks.
+      activeTask = await this.createNewTaskReturn(sessionKey, latestTimestamp, owner);
     }
 
-    const isNewTask = await this.isTaskBoundary(activeTask, sessionKey, latestTimestamp);
+    await this.processChunksIncrementally(activeTask, sessionKey, latestTimestamp, owner);
+  }
 
-    if (isNewTask) {
-      await this.finalizeTask(activeTask);
-      await this.createNewTask(sessionKey, latestTimestamp, owner);
-    } else {
-      this.assignUnassignedChunks(sessionKey, activeTask.id);
-      this.store.updateTask(activeTask.id, { endedAt: undefined });
+  /**
+   * Process unassigned chunks one user-turn at a time.
+   *
+   * Strategy:
+   * - Need at least 1 user turn in the current task before starting LLM judgment
+   *   (0 turns = no reference point for comparison).
+   * - Each subsequent user turn is individually checked against the full task context.
+   * - Time gap > 2h always triggers a split regardless of topic.
+   */
+  private async processChunksIncrementally(
+    activeTask: Task,
+    sessionKey: string,
+    latestTimestamp: number,
+    owner: string,
+  ): Promise<void> {
+    const unassigned = this.store.getUnassignedChunks(sessionKey);
+    if (unassigned.length === 0) return;
+
+    const taskChunks = this.store.getChunksByTask(activeTask.id);
+
+    // Time gap check against the earliest unassigned chunk
+    if (taskChunks.length > 0) {
+      const lastTaskTs = Math.max(...taskChunks.map((c) => c.createdAt));
+      const firstUnassignedTs = Math.min(...unassigned.map((c) => c.createdAt));
+      const gap = firstUnassignedTs - lastTaskTs;
+      if (gap > DEFAULTS.taskIdleTimeoutMs) {
+        this.ctx.log.info(
+          `Task boundary: time gap ${Math.round(gap / 60000)}min > ${Math.round(DEFAULTS.taskIdleTimeoutMs / 60000)}min`,
+        );
+        await this.finalizeTask(activeTask);
+        const newTask = await this.createNewTaskReturn(sessionKey, latestTimestamp, owner);
+        // Recurse with the new empty task so remaining unassigned chunks get boundary-checked too
+        return this.processChunksIncrementally(newTask, sessionKey, latestTimestamp, owner);
+      }
     }
-  }
 
-  private async isTaskBoundary(activeTask: Task, sessionKey: string, latestTimestamp: number): Promise<boolean> {
-    if (activeTask.sessionKey !== sessionKey) return true;
+    const turns = this.groupIntoTurns(unassigned);
+    if (turns.length === 0) {
+      this.assignChunksToTask(unassigned, activeTask.id);
+      return;
+    }
 
-    const chunks = this.store.getChunksByTask(activeTask.id);
-    if (chunks.length === 0) return false;
+    let currentTask = activeTask;
+    let currentTaskChunks = [...taskChunks];
 
-    const lastChunkTs = Math.max(...chunks.map((c) => c.createdAt));
-    const gap = latestTimestamp - lastChunkTs;
+    for (let i = 0; i < turns.length; i++) {
+      const turn = turns[i];
+      const userChunk = turn.find((c) => c.role === "user");
 
-    // Hard timeout: always split after 2h regardless of topic
-    if (gap > DEFAULTS.taskIdleTimeoutMs) {
-      this.ctx.log.info(
-        `Task boundary: time gap ${Math.round(gap / 60000)}min > ${Math.round(DEFAULTS.taskIdleTimeoutMs / 60000)}min`,
-      );
-      return true;
-    }
+      if (!userChunk) {
+        this.assignChunksToTask(turn, currentTask.id);
+        currentTaskChunks = currentTaskChunks.concat(turn);
+        continue;
+      }
 
-    // LLM topic judgment: build context from existing task and compare with new message
-    const newUserChunks = this.store.getUnassignedChunks(sessionKey).filter((c) => c.role === "user");
-    if (newUserChunks.length === 0) return false;
+      // Time gap check per turn
+      if (currentTaskChunks.length > 0) {
+        const lastTs = Math.max(...currentTaskChunks.map((c) => c.createdAt));
+        if (userChunk.createdAt - lastTs > DEFAULTS.taskIdleTimeoutMs) {
+          this.ctx.log.info(`Task boundary at turn ${i}: time gap ${Math.round((userChunk.createdAt - lastTs) / 60000)}min`);
+          await this.finalizeTask(currentTask);
+          currentTask = await this.createNewTaskReturn(sessionKey, userChunk.createdAt, owner);
+          currentTaskChunks = [];
+          this.assignChunksToTask(turn, currentTask.id);
+          currentTaskChunks = currentTaskChunks.concat(turn);
+          continue;
+        }
+      }
 
-    const existingUserChunks = chunks.filter((c) => c.role === "user");
-    if (existingUserChunks.length === 0) return false;
+      // Need at least 1 user turn before we can meaningfully judge topic shifts
+      const existingUserCount = currentTaskChunks.filter((c) => c.role === "user").length;
+      if (existingUserCount < 1) {
+        this.assignChunksToTask(turn, currentTask.id);
+        currentTaskChunks = currentTaskChunks.concat(turn);
+        continue;
+      }
 
-    const currentContext = this.buildContextSummary(chunks);
-    const newMessage = newUserChunks.map((c) => c.content).join("\n");
+      // LLM topic judgment — check this single user message against full task context
+      const context = this.buildContextSummary(currentTaskChunks);
+      const newMsg = userChunk.content.slice(0, 500);
+      this.ctx.log.info(`Topic judge: "${newMsg.slice(0, 60)}" vs ${existingUserCount} user turns`);
+      const isNew = await this.summarizer.judgeNewTopic(context, newMsg);
+      this.ctx.log.info(`Topic judge result: ${isNew === null ? "null(fallback)" : isNew ? "NEW" : "SAME"}`);
+
+      if (isNew === null) {
+        this.assignChunksToTask(turn, currentTask.id);
+        currentTaskChunks = currentTaskChunks.concat(turn);
+        continue;
+      }
 
-    const isNew = await this.summarizer.judgeNewTopic(currentContext, newMessage);
+      if (isNew) {
+        this.ctx.log.info(`Task boundary at turn ${i}: LLM judged new topic. Msg: "${newMsg.slice(0, 80)}..."`);
+        await this.finalizeTask(currentTask);
+        currentTask = await this.createNewTaskReturn(sessionKey, userChunk.createdAt, owner);
+        currentTaskChunks = [];
+      }
 
-    if (isNew === null) {
-      this.ctx.log.debug("Topic judge unavailable (no LLM configured), keeping current task");
-      return false;
+      this.assignChunksToTask(turn, currentTask.id);
+      currentTaskChunks = currentTaskChunks.concat(turn);
     }
 
-    if (isNew) {
-      this.ctx.log.info(`Task boundary: LLM judged new topic. New message: "${newMessage.slice(0, 80)}..."`);
-    } else {
-      this.ctx.log.debug(`LLM judged SAME topic, continuing task=${activeTask.id}`);
-    }
+    this.store.updateTask(currentTask.id, { endedAt: undefined });
+  }
 
-    return isNew;
+  /**
+   * Group chunks into user-turns: each turn starts with a user message
+   * and includes all subsequent non-user messages until the next user message.
+   */
+  private groupIntoTurns(chunks: Chunk[]): Chunk[][] {
+    const turns: Chunk[][] = [];
+    let current: Chunk[] = [];
+
+    for (const c of chunks) {
+      if (c.role === "user" && current.length > 0) {
+        turns.push(current);
+        current = [];
+      }
+      current.push(c);
+    }
+    if (current.length > 0) turns.push(current);
+    return turns;
   }
 
   /**
-   * Build a concise context string from existing task chunks for the LLM topic judge.
-   * Takes recent user/assistant summaries to keep token usage low.
+   * Build context from existing task chunks for the LLM topic judge.
+   * Includes both the task's opening topic and recent exchanges,
+   * so the LLM understands both what the task was originally about
+   * and where the conversation currently is.
+   *
+   * For user messages, include full content (up to 500 chars) since
+   * they carry the topic signal. For assistant messages, use summary
+   * or truncated content since they mostly elaborate.
    */
   private buildContextSummary(chunks: Chunk[]): string {
-    const relevant = chunks
-      .filter((c) => c.role === "user" || c.role === "assistant")
-      .slice(-6);
+    const conversational = chunks.filter((c) => c.role === "user" || c.role === "assistant");
+    if (conversational.length === 0) return "";
+
+    const formatChunk = (c: Chunk) => {
+      const label = c.role === "user" ? "User" : "Assistant";
+      const maxLen = c.role === "user" ? 500 : 200;
+      const text = c.summary || c.content.slice(0, maxLen);
+      return `[${label}]: ${text}`;
+    };
 
-    return relevant
-      .map((c) => `[${c.role === "user" ? "User" : "Assistant"}]: ${c.summary || c.content.slice(0, 150)}`)
-      .join("\n");
+    if (conversational.length <= 10) {
+      return conversational.map(formatChunk).join("\n");
+    }
+
+    const opening = conversational.slice(0, 6).map(formatChunk);
+    const recent = conversational.slice(-4).map(formatChunk);
+    return [
+      "--- Task opening ---",
+      ...opening,
+      "--- Recent exchanges ---",
+      ...recent,
+    ].join("\n");
   }
 
-  private async createNewTask(sessionKey: string, timestamp: number, owner: string = "agent:main"): Promise<void> {
+  private async createNewTaskReturn(sessionKey: string, timestamp: number, owner: string = "agent:main"): Promise<Task> {
     const taskId = uuid();
     const task: Task = {
       id: taskId,
@@ -165,20 +274,29 @@ export class TaskProcessor {
       updatedAt: timestamp,
     };
     this.store.insertTask(task);
-    this.assignUnassignedChunks(sessionKey, taskId);
     this.ctx.log.info(`Created new task=${taskId} session=${sessionKey}`);
+    return task;
   }
 
-  private assignUnassignedChunks(sessionKey: string, taskId: string): void {
-    const unassigned = this.store.getUnassignedChunks(sessionKey);
-    for (const chunk of unassigned) {
+  private async createNewTask(sessionKey: string, timestamp: number, owner: string = "agent:main"): Promise<void> {
+    const task = await this.createNewTaskReturn(sessionKey, timestamp, owner);
+    this.assignUnassignedChunks(sessionKey, task.id);
+  }
+
+  private assignChunksToTask(chunks: Chunk[], taskId: string): void {
+    for (const chunk of chunks) {
       this.store.setChunkTaskId(chunk.id, taskId);
     }
-    if (unassigned.length > 0) {
-      this.ctx.log.debug(`Assigned ${unassigned.length} chunks to task=${taskId}`);
+    if (chunks.length > 0) {
+      this.ctx.log.debug(`Assigned ${chunks.length} chunks to task=${taskId}`);
     }
   }
 
+  private assignUnassignedChunks(sessionKey: string, taskId: string): void {
+    const unassigned = this.store.getUnassignedChunks(sessionKey);
+    this.assignChunksToTask(unassigned, taskId);
+  }
+
   async finalizeTask(task: Task): Promise<void> {
     const chunks = this.store.getChunksByTask(task.id);
     const fallbackTitle = chunks.length > 0 ? this.extractTitle(chunks) : "";

package/src/ingest/worker.ts

@@ -19,7 +19,8 @@ export class IngestWorker {
     private embedder: Embedder,
     private ctx: PluginContext,
   ) {
-    this.summarizer = new Summarizer(ctx.config.summarizer, ctx.log);
+    const strongCfg = ctx.config.skillEvolution?.summarizer;
+    this.summarizer = new Summarizer(ctx.config.summarizer, ctx.log, strongCfg);
     this.taskProcessor = new TaskProcessor(store, ctx);
   }
 
@@ -45,73 +46,79 @@ export class IngestWorker {
 
   private async processQueue(): Promise<void> {
     this.processing = true;
-    const t0 = performance.now();
-
-    let lastSessionKey: string | undefined;
-    let lastOwner: string | undefined;
-    let lastTimestamp = 0;
-    let stored = 0;
-    let skipped = 0;
-    let merged = 0;
-    let duplicated = 0;
-    let errors = 0;
-    const resultLines: string[] = [];
-    const inputLines: string[] = [];
-    const totalMessages = this.queue.length;
-
-    while (this.queue.length > 0) {
-      const msg = this.queue.shift()!;
-      inputLines.push(`[${msg.role}] ${msg.content}`);
-      try {
-        const result = await this.ingestMessage(msg);
-        lastSessionKey = msg.sessionKey;
-        lastOwner = msg.owner ?? "agent:main";
-        lastTimestamp = Math.max(lastTimestamp, msg.timestamp);
-        if (result === "skipped") {
-          skipped++;
-          resultLines.push(`[${msg.role}] ⏭ exact-dup → ${msg.content}`);
-        } else if (result.action === "stored") {
-          stored++;
-          resultLines.push(`[${msg.role}] ✅ stored → ${result.summary ?? msg.content}`);
-        } else if (result.action === "duplicate") {
-          duplicated++;
-          resultLines.push(`[${msg.role}] 🔁 dedup(${result.reason ?? "similar"}) → ${msg.content}`);
-        } else if (result.action === "merged") {
-          merged++;
-          resultLines.push(`[${msg.role}] 🔀 merged → ${msg.content}`);
+
+    try {
+      while (this.queue.length > 0) {
+        const t0 = performance.now();
+        const batchSize = this.queue.length;
+        let lastSessionKey: string | undefined;
+        let lastOwner: string | undefined;
+        let lastTimestamp = 0;
+        let stored = 0;
+        let skipped = 0;
+        let merged = 0;
+        let duplicated = 0;
+        let errors = 0;
+        const resultLines: string[] = [];
+        const inputLines: string[] = [];
+
+        while (this.queue.length > 0) {
+          const msg = this.queue.shift()!;
+          inputLines.push(`[${msg.role}] ${msg.content}`);
+          try {
+            const result = await this.ingestMessage(msg);
+            lastSessionKey = msg.sessionKey;
+            lastOwner = msg.owner ?? "agent:main";
+            lastTimestamp = Math.max(lastTimestamp, msg.timestamp);
+            if (result === "skipped") {
+              skipped++;
+              resultLines.push(`[${msg.role}] ⏭ exact-dup → ${msg.content}`);
+            } else if (result.action === "stored") {
+              stored++;
+              resultLines.push(`[${msg.role}] ✅ stored → ${result.summary ?? msg.content}`);
+            } else if (result.action === "duplicate") {
+              duplicated++;
+              resultLines.push(`[${msg.role}] 🔁 dedup(${result.reason ?? "similar"}) → ${msg.content}`);
+            } else if (result.action === "merged") {
+              merged++;
+              resultLines.push(`[${msg.role}] 🔀 merged → ${msg.content}`);
+            }
+          } catch (err) {
+            errors++;
+            resultLines.push(`[${msg.role}] ❌ error → ${msg.content}`);
+            this.ctx.log.error(`Failed to ingest message turn=${msg.turnId}: ${err}`);
+          }
         }
-      } catch (err) {
-        errors++;
-        resultLines.push(`[${msg.role}] ❌ error → ${msg.content}`);
-        this.ctx.log.error(`Failed to ingest message turn=${msg.turnId}: ${err}`);
-      }
-    }
 
-    const dur = performance.now() - t0;
-
-    if (stored + merged > 0 || skipped > 0 || duplicated > 0) {
-      this.store.recordToolCall("memory_add", dur, errors === 0);
-      try {
-        const inputInfo = {
-          session: lastSessionKey,
-          messages: totalMessages,
-          details: inputLines,
-        };
-        const stats = [`stored=${stored}`, skipped > 0 ? `skipped=${skipped}` : null, duplicated > 0 ? `dedup=${duplicated}` : null, merged > 0 ? `merged=${merged}` : null, errors > 0 ? `errors=${errors}` : null].filter(Boolean).join(", ");
-        this.store.recordApiLog("memory_add", inputInfo, `${stats}\n${resultLines.join("\n")}`, dur, errors === 0);
-      } catch (_) { /* best-effort */ }
-    }
+        const dur = performance.now() - t0;
 
-    if (lastSessionKey) {
-      this.ctx.log.debug(`Calling TaskProcessor.onChunksIngested session=${lastSessionKey} ts=${lastTimestamp} owner=${lastOwner}`);
-      this.taskProcessor
-        .onChunksIngested(lastSessionKey, lastTimestamp, lastOwner)
-        .catch((err) => this.ctx.log.error(`TaskProcessor post-ingest error: ${err}`));
-    }
+        if (stored + merged > 0 || skipped > 0 || duplicated > 0) {
+          this.store.recordToolCall("memory_add", dur, errors === 0);
+          try {
+            const inputInfo = {
+              session: lastSessionKey,
+              messages: batchSize,
+              details: inputLines,
+            };
+            const stats = [`stored=${stored}`, skipped > 0 ? `skipped=${skipped}` : null, duplicated > 0 ? `dedup=${duplicated}` : null, merged > 0 ? `merged=${merged}` : null, errors > 0 ? `errors=${errors}` : null].filter(Boolean).join(", ");
+            this.store.recordApiLog("memory_add", inputInfo, `${stats}\n${resultLines.join("\n")}`, dur, errors === 0);
+          } catch (_) { /* best-effort */ }
+        }
 
-    this.processing = false;
-    for (const resolve of this.flushResolvers) resolve();
-    this.flushResolvers = [];
+        if (lastSessionKey) {
+          this.ctx.log.debug(`Calling TaskProcessor.onChunksIngested session=${lastSessionKey} ts=${lastTimestamp} owner=${lastOwner}`);
+          try {
+            await this.taskProcessor.onChunksIngested(lastSessionKey, lastTimestamp, lastOwner);
+          } catch (err) {
+            this.ctx.log.error(`TaskProcessor post-ingest error: ${err}`);
+          }
+        }
+      }
+    } finally {
+      this.processing = false;
+      for (const resolve of this.flushResolvers) resolve();
+      this.flushResolvers = [];
+    }
   }
 
   private async ingestMessage(msg: ConversationMessage): Promise<
@@ -133,7 +140,7 @@ export class IngestWorker {
     seq: number,
   ): Promise<{ action: "stored" | "duplicate" | "merged"; chunkId?: string; summary?: string; targetChunkId?: string; reason?: string }> {
     const chunkId = uuid();
-    const summary = await this.summarizer.summarize(content);
+    let summary = await this.summarizer.summarize(content);
 
     let embedding: number[] | null = null;
     try {
@@ -145,11 +152,23 @@ export class IngestWorker {
     let dedupStatus: "active" | "duplicate" | "merged" = "active";
     let dedupTarget: string | null = null;
     let dedupReason: string | null = null;
+    let mergedFromOld: string | null = null;
+
+    // Fast path: exact content_hash match within same owner (agent dimension)
+    const chunkOwner = msg.owner ?? "agent:main";
+    const existingByHash = this.store.findActiveChunkByHash(content, chunkOwner);
+    if (existingByHash) {
+      this.ctx.log.debug(`Exact-dup (owner=${chunkOwner}): hash match → existing=${existingByHash}`);
+      this.store.recordMergeHit(existingByHash, "DUPLICATE", "exact content hash match");
+      dedupStatus = "duplicate";
+      dedupTarget = existingByHash;
+      dedupReason = "exact content hash match";
+    }
 
     // Smart dedup: find Top-5 similar chunks, then ask LLM to judge
-    if (embedding) {
-      const similarThreshold = this.ctx.config.dedup?.similarityThreshold ?? 0.75;
-      const dedupOwnerFilter = msg.owner ? [msg.owner, "public"] : undefined;
+    if (dedupStatus === "active" && embedding) {
+      const similarThreshold = this.ctx.config.dedup?.similarityThreshold ?? 0.60;
+      const dedupOwnerFilter = msg.owner ? [msg.owner] : undefined;
       const topSimilar = findTopSimilar(this.store, embedding, similarThreshold, 5, this.ctx.log, dedupOwnerFilter);
 
       if (topSimilar.length > 0) {
@@ -182,19 +201,21 @@ export class IngestWorker {
               const oldChunk = this.store.getChunk(targetChunkId);
               const oldSummary = oldChunk?.summary ?? "";
               this.store.recordMergeHit(targetChunkId, "UPDATE", dedupResult.reason, oldSummary, dedupResult.mergedSummary);
-              this.store.updateChunkSummaryAndContent(targetChunkId, dedupResult.mergedSummary, content);
 
+              summary = dedupResult.mergedSummary;
               try {
-                const [newEmb] = await this.embedder.embed([dedupResult.mergedSummary]);
-                if (newEmb) this.store.upsertEmbedding(targetChunkId, newEmb);
+                const [newEmb] = await this.embedder.embed([summary]);
+                if (newEmb) embedding = newEmb;
               } catch (err) {
-                this.ctx.log.warn(`Re-embed after UPDATE failed: ${err}`);
+                this.ctx.log.warn(`Re-embed after merge failed: ${err}`);
               }
 
-              dedupStatus = "merged";
-              dedupTarget = targetChunkId;
+              this.store.markDedupStatus(targetChunkId, "merged", chunkId, dedupResult.reason);
+              this.store.deleteEmbedding(targetChunkId);
+
+              mergedFromOld = targetChunkId;
               dedupReason = dedupResult.reason;
-              this.ctx.log.debug(`Smart dedup: UPDATE → merged into chunk=${targetChunkId}, storing with status=merged, reason: ${dedupResult.reason}`);
+              this.ctx.log.debug(`Smart dedup: UPDATE → old chunk=${targetChunkId} retired, new chunk=${chunkId} gets merged summary, reason: ${dedupResult.reason}`);
             }
           }
 
@@ -237,8 +258,8 @@ export class IngestWorker {
     if (dedupStatus === "duplicate") {
       return { action: "duplicate", summary, targetChunkId: dedupTarget ?? undefined, reason: dedupReason ?? undefined };
     }
-    if (dedupStatus === "merged") {
-      return { action: "merged", summary, targetChunkId: dedupTarget ?? undefined, reason: dedupReason ?? undefined };
+    if (mergedFromOld) {
+      return { action: "merged", chunkId, summary, targetChunkId: mergedFromOld, reason: dedupReason ?? undefined };
     }
     return { action: "stored", chunkId, summary };
   }