@circuitwall/jarela 2.3.0 → 2.5.0

package/lib/agents/run-thread.auto-boundary.test.ts

@@ -10,6 +10,7 @@ process.env.JARELA_MAX_THREAD_MESSAGES = "4";
 
 const streamWithConfigMock = vi.fn();
 let providerSummary = "AUTO-COMPACT-RECAP";
+let providerCalls = 0;
 
 vi.mock("@/lib/agents/llm", () => ({
   streamWithConfig: (...args: unknown[]) => streamWithConfigMock(...args),
@@ -21,7 +22,7 @@ vi.mock("@/lib/scheduler", () => ({
 
 vi.mock("@/lib/providers", () => ({
   getProvider: () => ({
-    chat: async () => ({
+    chat: async () => (providerCalls++, {
       stream: (async function* () { yield providerSummary; })(),
     }),
   }),
@@ -164,7 +165,6 @@ describe("prepareThreadRun auto context boundary", () => {
       thread_id: thread.thread_id,
       message: "Persist this before the assistant draft.",
       _user_message_persisted: true,
-      _message_count_before_user: persisted.messageCountBefore,
       _idle_ms_before_user: persisted.idleMsBefore,
       context_profile: { include_hot: true, include_warm: false, include_facts: false, include_recall: false },
     });
@@ -271,7 +271,6 @@ describe("prepareThreadRun auto context boundary", () => {
         .run(new Date(Date.UTC(2026, 0, 1, 0, 0, index)).toISOString(), message.msg_id);
     });
     const orderedSeeded = getMessages(thread.thread_id);
-    const messageCountBefore = getThread(thread.thread_id)!.message_count;
     const activePrompt = addMessage(thread.thread_id, "user", "topic 3 question");
     providerSummary = [
       "AUTO-COMPACT-RECAP",
@@ -292,7 +291,6 @@ describe("prepareThreadRun auto context boundary", () => {
       thread_id: thread.thread_id,
       message: "topic 3 question",
       _user_message_persisted: true,
-      _message_count_before_user: messageCountBefore,
       _idle_ms_before_user: null,
       context_profile: {
         include_hot: true,
@@ -374,4 +372,126 @@ describe("prepareThreadRun auto context boundary", () => {
       "continue after retention guard",
     ]);
   });
-});
+
+  async function seedBridgeHeavyAgent(agentId: string, foregroundTurns: number) {
+    upsertModelConfig("default", "openai", "gpt-4o-mini", { api_key: "sk-test" }, true);
+    upsertAgentConfig({
+      id: agentId,
+      name: agentId,
+      identity: "helper",
+      instructions: "Be helpful.",
+      tools: [],
+      model_config_name: null,
+    });
+    const thread = createThread(agentId);
+    const metadata = { bridge_conversation: { key: "wa:chat-1" } };
+    for (let i = 0; i < 20; i++) {
+      addMessage(thread.thread_id, i % 2 === 0 ? "user" : "assistant", `bridge turn ${i}`, undefined, "bridge", metadata);
+    }
+    for (let i = 0; i < foregroundTurns; i++) {
+      addMessage(thread.thread_id, "user", `chat question ${i}`);
+      addMessage(thread.thread_id, "assistant", `chat answer ${i}`);
+    }
+    return { thread, metadata };
+  }
+
+  it("does not start size compaction for bridge rows that compaction can never prune", async () => {
+    const { thread, metadata } = await seedBridgeHeavyAgent("agent-bridge-only", 0);
+    const onCompacting = vi.fn();
+    await prepareThreadRun({
+      thread_id: thread.thread_id,
+      message: "new bridge message",
+      user_category: "bridge",
+      message_metadata: metadata,
+      history_bridge_key: "wa:chat-1",
+      context_profile: { history_scope: "bridge", include_hot: true, include_warm: false, include_facts: false, include_recall: false },
+      _onCompacting: onCompacting,
+    });
+    expect(onCompacting).not.toHaveBeenCalled();
+    expect(getMessages(thread.thread_id).filter((m) => m.category === "bridge")).toHaveLength(21);
+  });
+
+  it("does not report compacting on a short chat just because the bridge history is long", async () => {
+    const { thread } = await seedBridgeHeavyAgent("agent-bridge-mixed", 1);
+    const onCompacting = vi.fn();
+    await prepareThreadRun({
+      thread_id: thread.thread_id,
+      message: "quick chat question",
+      context_profile: { include_hot: true, include_warm: false, include_facts: false, include_recall: false },
+      _onCompacting: onCompacting,
+    });
+    expect(onCompacting).not.toHaveBeenCalled();
+  });
+
+  it("still size-compacts once the chat itself outgrows the cap alongside bridge rows", async () => {
+    const { thread } = await seedBridgeHeavyAgent("agent-bridge-busy-chat", 6);
+    const onCompacting = vi.fn();
+    await prepareThreadRun({
+      thread_id: thread.thread_id,
+      message: "long chat question",
+      context_profile: { include_hot: true, include_warm: false, include_facts: false, include_recall: false },
+      _onCompacting: onCompacting,
+    });
+    expect(onCompacting).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not re-run hot-turn compaction on the very next turn after a commit", async () => {
+    upsertModelConfig("default", "openai", "gpt-4o-mini", { api_key: "sk-test" }, true);
+    upsertAgentConfig({
+      id: "agent-hot-turn-rolling",
+      name: "Rolling Hot Turn Agent",
+      identity: "helper",
+      instructions: "Be helpful.",
+      tools: [],
+      model_config_name: null,
+      history_window_hours: 0,
+      hot_turn_limit: 2,
+    });
+    const thread = createThread("agent-hot-turn-rolling");
+    for (let i = 0; i < 4; i += 1) {
+      addMessage(thread.thread_id, "user", `topic ${i} question`);
+      addMessage(thread.thread_id, "assistant", `topic ${i} answer`);
+    }
+    const seeded = getMessages(thread.thread_id);
+    seeded.forEach((message, index) => {
+      getDb().prepare("UPDATE messages SET created_at=? WHERE msg_id=?")
+        .run(new Date(Date.UTC(2026, 0, 1, 0, 0, index)).toISOString(), message.msg_id);
+    });
+    const rows = getMessages(thread.thread_id);
+    providerSummary = [
+      "AUTO-COMPACT-RECAP",
+      "```jarela-topics",
+      JSON.stringify([{
+        title: "later topic",
+        start_seq: rows[4].seq,
+        end_seq: rows[7].seq,
+        start_at: rows[4].created_at,
+        end_at: rows[7].created_at,
+        recap: "Topics 2 and 3.",
+        facts: [],
+      }]),
+      "```",
+    ].join("\n");
+    const turn = (message: string) => prepareThreadRun({
+      thread_id: thread.thread_id,
+      message,
+      context_profile: { include_hot: true, include_warm: false, include_facts: false, include_recall: false },
+    });
+
+    await turn("topic 4 question");
+    await waitForCondition(() => getThread(thread.thread_id)?.hot_since_seq === rows[4].seq);
+    addMessage(thread.thread_id, "assistant", "topic 4 answer");
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    providerCalls = 0;
+    await turn("topic 5 question");
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    expect(providerCalls).toBe(0);
+    addMessage(thread.thread_id, "assistant", "topic 5 answer");
+
+    // The cooldown is half the turn limit; the turn after it re-evaluates.
+    await turn("topic 6 question");
+    await waitForCondition(() => providerCalls > 0);
+    expect(getThread(thread.thread_id)?.hot_since_seq).toBe(rows[4].seq);
+  });
+});

package/lib/agents/run-thread.ts

@@ -13,7 +13,7 @@ import { autoCompactionKeepLast, compactAgentThread } from "@/lib/agents/thread-
 import { kickBoundaryCompaction, kickWarmSummaryRefresh, pendingCompactionBoundarySeq } from "@/lib/agents/warm-summary-background";
 import { moveThreadContextBoundary } from "@/lib/agents/context-boundary";
 import { getForegroundTabPresence } from "@/lib/api/foreground-presence";
-import { addMessage, capToolEventPayload, countThreadMessagesFromSeq, getMessagesPage, isValidThreadContextCursor, pruneThreadMessages, getRecentlyUsedToolNames, getRecentMessagesWindow, getThread, getThreadMessageBySeq, mergeMessageMetadata, touchThread, updateMessageContent, type MessageTranscriptStatus, type PersistedToolEvent } from "@/lib/stores/threads";
+import { addMessage, capToolEventPayload, countForegroundThreadMessages, getMessagesPage, isValidThreadContextCursor, pruneThreadMessages, getRecentlyUsedToolNames, getRecentMessagesWindow, getThread, getThreadMessageBySeq, mergeMessageMetadata, touchThread, updateMessageContent, type MessageTranscriptStatus, type PersistedToolEvent } from "@/lib/stores/threads";
 import { transcriptText } from "@/lib/agents/conversation-summary";
 import { getMaskRunContext } from "@/lib/redaction/context";
 import { recordToolUsage } from "@/lib/stores/tool-stats";
@@ -170,10 +170,19 @@ function hotTurnBoundary(
   return boundary?.seq ?? null;
 }
 
+// The topic-aware boundary keeps the whole active topic hot, so user turns
+// since the pin usually still exceed the limit right after a commit. Without a
+// cooldown every following turn re-runs the topic LLM pass only to land on the
+// same pin. Skip the next half-limit turns (2 rows per turn) before re-checking.
+export function hotTurnCooldownUntil(messageCount: number, hotTurnLimit: number | null | undefined): number {
+  const turnLimit = hotTurnLimit ?? DEFAULT_HOT_TURN_LIMIT;
+  const skipTurns = Math.max(1, Math.ceil(Math.max(1, turnLimit) / 2));
+  return messageCount + skipTurns * 2 + 1;
+}
+
 async function maybeAutoCompactOversizedThread(
   agentId: string,
   threadId: string,
-  messageCount: number,
   onCompacting?: () => void,
   preserveNewestMessages = 0,
 ): Promise<void> {
@@ -181,12 +190,17 @@ async function maybeAutoCompactOversizedThread(
   const keepLast = autoCompactionKeepLast(cap);
   const retainedMessages = keepLast + preserveNewestMessages;
   const triggerAt = cap + (cap - keepLast);
-  if (!Number.isFinite(cap) || cap <= 0 || messageCount < triggerAt) return;
+  if (!Number.isFinite(cap) || cap <= 0) return;
+  // Only foreground rows are ever pruned; counting bridge/watcher/scheduled
+  // rows would re-trigger an LLM compaction on every turn of a busy bridge
+  // agent without ever bringing the count back under the cap.
+  const messageCount = countForegroundThreadMessages(threadId);
+  if (messageCount < triggerAt) return;
   try {
     // A pin that already keeps the hot tier within the retained range must not
     // be pulled back to the cutoff, nor re-summarised by an LLM on every turn.
     const pinSeq = getThread(threadId)?.hot_since_seq ?? null;
-    if (pinSeq !== null && countThreadMessagesFromSeq(threadId, pinSeq) <= retainedMessages) {
+    if (pinSeq !== null && countForegroundThreadMessages(threadId, pinSeq) <= retainedMessages) {
       pruneThreadMessages(threadId, retainedMessages, pinSeq);
       return;
     }
@@ -237,7 +251,6 @@ export class RunThreadError extends Error {
 
 export interface PersistedThreadRunUserMessage {
   attachments?: ContentPart[];
-  messageCountBefore: number;
   idleMsBefore: number | null;
   userMessageId: string;
   storedContent: string;
@@ -256,7 +269,6 @@ export async function persistThreadRunUserMessage(
     throw new RunThreadError(400, "message required", "message_required");
   }
 
-  const messageCountBefore = thread.message_count;
   const autoBoundaryScope = req.context_profile?.history_scope
     ?? (req.user_category === "bridge" ? "bridge" : "foreground");
   const idleMsBefore = isAutoBoundaryEligibleCategory(req.user_category)
@@ -287,7 +299,6 @@ export async function persistThreadRunUserMessage(
 
   return {
     attachments: spilledAttachments,
-    messageCountBefore,
     idleMsBefore,
     userMessageId: userMessage.msg_id,
     storedContent: stored,
@@ -486,8 +497,8 @@ export async function prepareThreadRun(req: ThreadRunRequest): Promise<PreparedT
     await maybeAutoCompactOversizedThread(
       agentCfg.id,
       req.thread_id,
-      req._message_count_before_user ?? thread.message_count,
       req._onCompacting,
+
       req._user_message_persisted ? 2 : 0,
     );
   }
@@ -552,7 +563,11 @@ export async function prepareThreadRun(req: ThreadRunRequest): Promise<PreparedT
         && latestThread.message_count < (latestThread.auto_boundary_locked_until_msg_count ?? 0);
       if (!locked) {
         const boundary = hotTurnBoundary(req.thread_id, agentCfg, autoBoundaryScope);
-        if (boundary !== null) kickBoundaryCompaction(req.thread_id, boundary);
+        if (boundary !== null) {
+          kickBoundaryCompaction(req.thread_id, boundary, {
+            autoBoundaryLockedUntilMessageCount: hotTurnCooldownUntil(latestThread?.message_count ?? 0, agentCfg.hot_turn_limit),
+          });
+        }
       }
     }
   }

package/lib/agents/sqlite-checkpoint-saver.test.ts

@@ -165,3 +165,94 @@ describe("NodeSqliteSaver", () => {
     expect(tuple).toBeUndefined();
   });
 });
+
+describe("NodeSqliteSaver edge cases", () => {
+  async function chain(saver: NodeSqliteSaver, thread: string, count: number, ns = ""): Promise<string[]> {
+    const ids: string[] = [];
+    let parent: string | undefined;
+    for (let i = 0; i < count; i++) {
+      const ck = newCheckpoint();
+      await saver.put(
+        { configurable: { thread_id: thread, checkpoint_ns: ns, ...(parent ? { checkpoint_id: parent } : {}) } },
+        ck,
+        { ...META_BASE, step: i },
+      );
+      ids.push(ck.id);
+      parent = ck.id;
+    }
+    return ids;
+  }
+
+  it("links each checkpoint to its parent and returns no parent for the first one", async () => {
+    const saver = newSaver();
+    const [first, second] = await chain(saver, "t-parent", 2);
+    const latest = await saver.getTuple(cfg("t-parent"));
+    expect(latest?.checkpoint.id).toBe(second);
+    expect(latest?.parentConfig?.configurable?.checkpoint_id).toBe(first);
+    expect((await saver.getTuple(cfg("t-parent", first)))?.parentConfig).toBeUndefined();
+  });
+
+  it("keeps checkpoint namespaces (subgraphs) isolated within one thread", async () => {
+    const saver = newSaver();
+    const [root] = await chain(saver, "t-ns", 1, "");
+    const [child] = await chain(saver, "t-ns", 1, "sub:1");
+    const rootLatest = await saver.getTuple({ configurable: { thread_id: "t-ns", checkpoint_ns: "" } });
+    const childLatest = await saver.getTuple({ configurable: { thread_id: "t-ns", checkpoint_ns: "sub:1" } });
+    expect(rootLatest?.checkpoint.id).toBe(root);
+    expect(childLatest?.checkpoint.id).toBe(child);
+    expect(childLatest?.config.configurable?.checkpoint_ns).toBe("sub:1");
+  });
+
+  it("pages list() with before, newest first, without repeating the cursor", async () => {
+    const saver = newSaver();
+    const ids = await chain(saver, "t-before", 4);
+    const page = [];
+    for await (const tuple of saver.list(cfg("t-before"), { before: cfg("t-before", ids[2]), limit: 10 })) page.push(tuple.checkpoint.id);
+    expect(page).toEqual([ids[1], ids[0]]);
+  });
+
+  it("returns pending writes for the checkpoint they belong to, and replaces a retried task's writes", async () => {
+    const saver = newSaver();
+    const [first, second] = await chain(saver, "t-writes", 2);
+    await saver.putWrites(cfg("t-writes", second), [["messages", { text: "draft" }], ["status", "running"]], "task-1");
+    await saver.putWrites(cfg("t-writes", second), [["messages", { text: "final" }], ["status", "done"]], "task-1");
+    await saver.putWrites(cfg("t-writes", first), [["messages", { text: "old" }]], "task-0");
+
+    const latest = await saver.getTuple(cfg("t-writes"));
+    expect(latest?.pendingWrites).toEqual([
+      ["task-1", "messages", { text: "final" }],
+      ["task-1", "status", "done"],
+    ]);
+    const older = await saver.getTuple(cfg("t-writes", first));
+    expect(older?.pendingWrites).toEqual([["task-0", "messages", { text: "old" }]]);
+  });
+
+  it("round-trips non-ASCII and large channel values", async () => {
+    const saver = newSaver();
+    const ck = newCheckpoint();
+    const text = `你好 👋 ${"x".repeat(200_000)}`;
+    (ck.channel_values as Record<string, unknown>).messages = [{ text }];
+    await saver.put(cfg("t-big"), ck, META_BASE);
+    await saver.putWrites(cfg("t-big", ck.id), [["note", text]], "task");
+    const tuple = await saver.getTuple(cfg("t-big"));
+    expect((tuple?.checkpoint.channel_values as Record<string, unknown>).messages).toEqual([{ text }]);
+    expect(tuple?.pendingWrites?.[0][2]).toBe(text);
+  });
+
+  it("rejects writes without a checkpoint_id and puts without a thread_id", async () => {
+    const saver = newSaver();
+    await expect(saver.putWrites(cfg("t-x"), [["c", 1]], "task")).rejects.toThrow(/checkpoint_id/);
+    await expect(saver.put({ configurable: {} }, newCheckpoint(), META_BASE)).rejects.toThrow(/thread_id/);
+  });
+
+  it("deleteThread leaves other threads untouched", async () => {
+    const saver = newSaver();
+    const [keep] = await chain(saver, "t-keep", 1);
+    const [drop] = await chain(saver, "t-drop", 1);
+    await saver.putWrites(cfg("t-keep", keep), [["c", 1]], "task");
+    await saver.putWrites(cfg("t-drop", drop), [["c", 2]], "task");
+    await saver.deleteThread("t-drop");
+    expect(await saver.getTuple(cfg("t-drop"))).toBeUndefined();
+    expect((await saver.getTuple(cfg("t-keep")))?.pendingWrites).toEqual([["task", "c", 1]]);
+  });
+});

package/lib/agents/warm-summary-background.ts

@@ -16,6 +16,7 @@ import {
   getThreadMessageBySeq,
   getThreadChannelSummary,
   listThreadChannelSummaries,
+  setAutoBoundaryLock,
 } from "@/lib/stores/threads";
 import { getOrCreateGlobal } from "@/lib/utils/global-state";
 import {
@@ -163,9 +164,10 @@ function runBoundaryCompaction(
 ): void {
   const baseThread = getThread(threadId);
   const basePinSeq = baseThread?.hot_since_seq ?? null;
+  const baseLock = baseThread?.auto_boundary_locked_until_msg_count ?? 0;
   void runTrackedCompaction(threadId, "auto", boundarySeq, async (attempt) => {
     await Promise.resolve();
-    await commitBoundaryCompaction(threadId, boundarySeq, basePinSeq, options, attempt);
+    await commitBoundaryCompaction(threadId, boundarySeq, basePinSeq, baseLock, options, attempt);
   })
     .catch((err) => console.warn(`[context-boundary:auto] compaction failed thread=${threadId}: ${String(err)}`))
     .finally(() => drainQueuedBoundary(threadId));
@@ -174,6 +176,7 @@ async function commitBoundaryCompaction(
   threadId: string,
   boundarySeq: number,
   basePinSeq: number | null,
+  baseLock: number,
   options: Pick<WarmContextCompactionOptions, "autoBoundaryLockedUntilMessageCount">,
   attempt?: CompactionAttempt,
 ): Promise<void> {
@@ -184,7 +187,24 @@ async function commitBoundaryCompaction(
     ...options,
     attempt,
   });
-  if (!committed) return;
+  if (!committed) {
+    // A pass that resolved to no change (the active topic still starts at the
+    // current pin) must not be retried on every following turn either. Skip
+    // it when the boundary or lock changed mid-pass (e.g. the user cleared or
+    // moved the boundary): that newer state wins over this stale pass.
+    const lockUntil = options.autoBoundaryLockedUntilMessageCount;
+    const current = getThread(threadId);
+    if (
+      lockUntil !== undefined &&
+      current &&
+      (current.hot_since_seq ?? null) === basePinSeq &&
+      (current.auto_boundary_locked_until_msg_count ?? 0) === baseLock &&
+      lockUntil > baseLock
+    ) {
+      setAutoBoundaryLock(threadId, lockUntil);
+    }
+    return;
+  }
   console.info(
     `[context-boundary:auto] thread=${threadId} committed boundary_seq=${committed.boundarySeq} warm_msgs=${committed.sourceMessages}`,
   );

package/lib/agents/warm-topics.test.ts

@@ -1,5 +1,14 @@
 import { describe, expect, it } from "vitest";
-import { canMergeIntoTopics, savedMemoryFacts } from "./warm-topics";
+import type { SummaryTopicFact, SummaryTopicSegment } from "./conversation-summary";
+import {
+  canMergeIntoTopics,
+  finalizeTopic,
+  foldSingleMessageTopics,
+  mergeTopicFacts,
+  mergeWarmTopics,
+  savedMemoryFacts,
+  slugifyForMemoryKey,
+} from "./warm-topics";
 
 const events = (...list: unknown[]) => JSON.stringify(list);
 
@@ -35,3 +44,148 @@ describe("canMergeIntoTopics", () => {
     expect(canMergeIntoTopics([topic], null, 9)).toBe(false);
   });
 });
+
+const fact = (subject: string, key?: string, content = subject): SummaryTopicFact => ({
+  subject, content, tags: [], confidence: "explicit", ...(key ? { key } : {}),
+});
+
+const topic = (start: number, end: number, extra: Partial<SummaryTopicSegment> = {}): SummaryTopicSegment => ({
+  title: `T${start}-${end}`,
+  start_seq: start,
+  end_seq: end,
+  start_at: null,
+  end_at: null,
+  recap: `recap ${start}-${end}`,
+  facts: [],
+  ...extra,
+} as SummaryTopicSegment);
+
+const rowsFor = (...seqs: number[]) => seqs.map((seq) => ({ seq, content: `message ${seq}` }));
+
+describe("slugifyForMemoryKey", () => {
+  it("keeps non-Latin subjects distinct instead of collapsing them to an empty key", () => {
+    const a = slugifyForMemoryKey("发布节奏");
+    const b = slugifyForMemoryKey("部署目标");
+    expect(a).not.toBe("");
+    expect(b).not.toBe("");
+    expect(a).not.toBe(b);
+    expect(slugifyForMemoryKey("Café Öffnungszeiten")).toBe("café-öffnungszeiten");
+  });
+
+  it("falls back to a stable non-empty key for subjects with no letters or digits", () => {
+    const key = slugifyForMemoryKey("🚀🚀");
+    expect(key).toMatch(/^fact-[0-9a-f]+$/);
+    expect(slugifyForMemoryKey("🚀🚀")).toBe(key);
+    expect(slugifyForMemoryKey("🎉")).not.toBe(key);
+  });
+
+  it("caps the key length and trims separators", () => {
+    expect(slugifyForMemoryKey("  --Release   Cadence!!  ")).toBe("release-cadence");
+    expect(slugifyForMemoryKey("x".repeat(200))).toHaveLength(80);
+  });
+});
+
+describe("mergeTopicFacts", () => {
+  it("merges by subject case-insensitively, later lists winning", () => {
+    const merged = mergeTopicFacts([fact("Editor", undefined, "old")], [fact("editor", undefined, "new")]);
+    expect(merged).toHaveLength(1);
+    expect(merged[0].content).toBe("new");
+  });
+
+  it("replaces a fact saved under the same key even when the subject was reworded", () => {
+    const merged = mergeTopicFacts([fact("Editor", "facts/editor", "VS Code")], [fact("Preferred editor", "facts/editor", "Zed")]);
+    expect(merged.map((f) => f.content)).toEqual(["Zed"]);
+  });
+
+  it("does not drop an unrelated fact through a key the subject no longer uses", () => {
+    const merged = mergeTopicFacts(
+      [fact("Region", "facts/region-old")],
+      [fact("Region", "facts/region")],
+      [fact("Old region alias", "facts/region-old")],
+    );
+    expect(merged.map((f) => f.key)).toEqual(["facts/region", "facts/region-old"]);
+  });
+
+  it("keeps the newest 16 facts", () => {
+    const merged = mergeTopicFacts(Array.from({ length: 20 }, (_, i) => fact(`s${i}`)));
+    expect(merged).toHaveLength(16);
+    expect(merged[0].subject).toBe("s4");
+    expect(merged[15].subject).toBe("s19");
+  });
+});
+
+describe("foldSingleMessageTopics", () => {
+  it("folds a leading single-message topic forward and a later one backward", () => {
+    const folded = foldSingleMessageTopics(
+      [topic(1, 1, { recap: "a" }), topic(2, 4, { recap: "b" }), topic(5, 5, { recap: "c" })],
+      rowsFor(1, 2, 3, 4, 5),
+    );
+    expect(folded).toHaveLength(1);
+    expect(folded[0]).toMatchObject({ start_seq: 1, end_seq: 5, recap: "a b c" });
+  });
+
+  it("counts rows, not seq width, so gaps from pruned rows still fold", () => {
+    const folded = foldSingleMessageTopics([topic(1, 3), topic(4, 9)], rowsFor(1, 2, 3, 9));
+    expect(folded).toHaveLength(1);
+    expect(folded[0]).toMatchObject({ start_seq: 1, end_seq: 9 });
+  });
+
+  it("leaves a lone topic alone even when it covers one message", () => {
+    expect(foldSingleMessageTopics([topic(1, 1)], rowsFor(1))).toHaveLength(1);
+  });
+
+  it("does not mutate its input", () => {
+    const input = [topic(1, 1, { facts: [fact("a")] }), topic(2, 3, { facts: [fact("b")] })];
+    const snapshot = structuredClone(input);
+    foldSingleMessageTopics(input, rowsFor(1, 2, 3));
+    expect(input).toEqual(snapshot);
+  });
+});
+
+describe("finalizeTopic", () => {
+  it("derives keys and counts in code and merges memory the agent saved in range", () => {
+    const covered = [
+      { seq: 1, content: "hello" },
+      {
+        seq: 2,
+        content: "saved",
+        tool_events: events(
+          { id: "m", phase: "call", name: "memory_write", payload: { namespace: "facts", key: "tz", value: "Europe/Amsterdam" } },
+          { id: "m", phase: "result", name: "memory_write", payload: JSON.stringify({ ok: true, key: "tz" }) },
+        ),
+      },
+    ];
+    const out = finalizeTopic(topic(1, 2, { facts: [fact("Release cadence")] }), covered);
+    expect(out.message_count).toBe(2);
+    expect(out.source_chars).toBe("hello".length + "saved".length);
+    expect(out.facts).toEqual([
+      expect.objectContaining({ key: "facts/release-cadence", origin: "compaction" }),
+      expect.objectContaining({ key: "facts/tz", origin: "agent", content: "Europe/Amsterdam" }),
+    ]);
+  });
+});
+
+describe("mergeWarmTopics", () => {
+  it("updates a continued topic in place, keeps its start, sums counts and re-sorts by recency", () => {
+    const prior = [topic(1, 4, { message_count: 4, source_chars: 40 }), topic(5, 8, { message_count: 4, source_chars: 40 })];
+    const fresh = [topic(9, 12, { continues: "t1", recap: "newer", message_count: 4, source_chars: 10 })];
+    const merged = mergeWarmTopics(prior, fresh, 100);
+    expect(merged.topics.map((t) => [t.start_seq, t.end_seq])).toEqual([[5, 8], [1, 12]]);
+    expect(merged.topics[1]).toMatchObject({ recap: "newer", message_count: 8, source_chars: 50 });
+    expect(merged.topics[1]).not.toHaveProperty("continues");
+  });
+
+  it("appends a fresh topic whose continues id does not exist", () => {
+    const merged = mergeWarmTopics([topic(1, 4, { message_count: 4 })], [topic(5, 8, { continues: "t9", message_count: 4 })], 100);
+    expect(merged.topics).toHaveLength(2);
+    expect(merged.topics[1]).not.toHaveProperty("continues");
+  });
+
+  it("evicts the least recently active topics until within the limit, keeping at least one", () => {
+    const prior = [topic(1, 4, { message_count: 4 }), topic(5, 8, { message_count: 4 })];
+    const merged = mergeWarmTopics(prior, [topic(9, 20, { message_count: 12 })], 10);
+    expect(merged.evicted).toBe(2);
+    expect(merged.topics.map((t) => t.start_seq)).toEqual([9]);
+    expect(merged.sourceMessages).toBe(10);
+  });
+});

package/lib/agents/warm-topics.ts

@@ -24,12 +24,26 @@ function rowsInRange<T extends WarmTopicSourceRow>(rows: readonly T[], topic: Su
   return rows.filter((row) => row.seq >= (topic.start_seq ?? Infinity) && row.seq <= (topic.end_seq ?? -Infinity));
 }
 
+// Unicode-aware so non-Latin subjects get distinct keys; an ASCII-only slug
+// collapsed them all to "" and the uplift skipped them. Subjects with no
+// letters or digits fall back to a stable hash.
 export function slugifyForMemoryKey(subject: string): string {
-  return subject
+  const slug = subject
+    .normalize("NFC")
     .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, 80);
+    .replace(/[^\p{L}\p{M}\p{N}]+/gu, "-")
+    .replace(/^-+|-+$/g, "");
+  const capped = Array.from(slug).slice(0, 80).join("").replace(/-+$/, "");
+  return capped || `fact-${fnv1a(subject)}`;
+}
+
+function fnv1a(text: string): string {
+  let hash = 0x811c9dc5;
+  for (let i = 0; i < text.length; i++) {
+    hash ^= text.charCodeAt(i);
+    hash = Math.imul(hash, 0x01000193);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
 }
 
 /**
@@ -43,9 +57,15 @@ export function mergeTopicFacts(...lists: readonly (readonly SummaryTopicFact[])
   for (const list of lists) {
     for (const fact of list) {
       const subjectId = fact.subject.trim().toLowerCase();
-      const existingSubject = fact.key ? keyToSubject.get(fact.key) : undefined;
-      if (existingSubject && existingSubject !== subjectId) merged.delete(existingSubject);
-      merged.delete(subjectId);
+      const sameKeySubject = fact.key ? keyToSubject.get(fact.key) : undefined;
+      for (const replaced of [sameKeySubject, subjectId]) {
+        if (replaced === undefined) continue;
+        // Drop the replaced fact's key mapping too, so a later fact reusing
+        // that key cannot delete whatever now lives under this subject.
+        const previousKey = merged.get(replaced)?.key;
+        if (previousKey) keyToSubject.delete(previousKey);
+        merged.delete(replaced);
+      }
       merged.set(subjectId, fact);
       if (fact.key) keyToSubject.set(fact.key, subjectId);
     }

package/lib/bridges/dispatcher.ts

@@ -87,6 +87,7 @@ export async function handleInboundMessage(
       role: msg.role,
       sender_id: senderJid,
       sender_name: senderName,
+      chat_link: adapter.chatLink?.(msg.remote_jid) ?? null,
       text: msg.text,
       silent,
       event: msg.event,