@circuitwall/jarela 2.2.1 → 2.4.0

package/lib/agents/thread-compaction.test.ts

@@ -5,6 +5,10 @@ const state = vi.hoisted(() => ({
   movedSeq: null as number | null,
   movedTo: null as string | null,
   alignTopicBoundary: false,
+  context: undefined as unknown,
+  archived: [] as Array<{ summary: string; message_count: number }>,
+  manualRunning: false,
+  timeout: false,
 }));
 
 vi.mock("@/lib/stores/agent-configs", () => ({
@@ -16,14 +20,26 @@ vi.mock("@/lib/stores/threads", () => ({
   getThread: () => ({ hot_since: state.movedTo, warm_summary: "summary", warm_summary_before: state.movedTo }),
   pruneThreadMessages: () => 0,
 }));
-vi.mock("@/lib/stores/memory", () => ({ putMemory: () => {}, listMemory: () => [], deleteMemory: () => false }));
+vi.mock("@/lib/stores/memory", () => ({
+  putMemory: (_ns: string, _key: string, value: { summary: string; message_count: number }) => { state.archived.push(value); },
+  listMemory: () => [],
+  deleteMemory: () => false,
+}));
 vi.mock("@/lib/agents/warm-summary-background", () => ({
-  trackManualCompaction: async <T,>(_threadId: string, _seq: number, run: () => Promise<T>) => run(),
+  isManualCompactionRunning: () => state.manualRunning,
+  trackManualCompaction: async <T,>(_threadId: string, _seq: number, run: (a: { isCurrent(): boolean }) => Promise<T>) => {
+    if (state.timeout) {
+      const { CompactionTimeoutError } = await import("./thread-compaction-state");
+      throw new CompactionTimeoutError("thread-1", "manual", 1000);
+    }
+    return run({ isCurrent: () => true });
+  },
   compactThreadWarmContext: async (_threadId: string, boundarySeq: number, options: { alignTopicBoundary: boolean }) => {
     state.movedSeq = boundarySeq;
     state.movedTo = state.rows.at(-1)?.created_at ?? null;
     state.alignTopicBoundary = options.alignTopicBoundary;
-    return { boundary: state.movedTo, boundarySeq, summary: "summary", sourceMessages: state.rows.length, sourceChars: 42, topics: [] };
+    if (state.context !== undefined) return state.context;
+    return { boundary: state.movedTo, boundarySeq, summary: "summary", sourceMessages: state.rows.length, sourceChars: 42, topics: [], channels: [] };
   },
 }));
 vi.mock("@/lib/env/config", () => ({ getConfig: () => ({ maxThreadMessages: 1000, maxSessionArchives: 20 }) }));
@@ -77,4 +93,67 @@ describe("autoCompactionKeepLast", () => {
     expect(state.movedSeq).toBe(4);
     expect(state.alignTopicBoundary).toBe(false);
   });
-});
+
+  it("archives channel recaps and counts their messages when the thread only has bridge activity", async () => {
+    state.archived = [];
+    state.rows = [
+      { seq: 1, role: "user", content: "bridge in", created_at: "2026-09-25T12:00:00.000Z" },
+      { seq: 2, role: "assistant", content: "bridge out", created_at: "2026-09-25T12:00:01.000Z" },
+    ];
+    state.context = {
+      boundary: "2026-09-25T12:00:01.000Z",
+      boundarySeq: 3,
+      summary: "",
+      sourceMessages: 0,
+      sourceChars: 0,
+      topics: [],
+      channels: [
+        { channel: "scheduled_task", summary: "", sourceMessages: 0 },
+        { channel: "bridge", summary: "--- bridge activity summary ---\nbooked a table", sourceMessages: 2 },
+      ],
+    };
+
+    const result = await compactAgentThread("agent-1", 1000, true);
+    state.context = undefined;
+
+    expect(result.compacted).toBe(true);
+    if (result.compacted) expect(result.message_count).toBe(2);
+    expect(state.archived.at(-1)?.summary).toBe("--- bridge activity summary ---\nbooked a table");
+    expect(state.archived.at(-1)?.message_count).toBe(2);
+  });
+
+  it("reports a distinct reason when messages exist but no summary was produced", async () => {
+    state.rows = [{ seq: 1, role: "user", content: "hi", created_at: "2026-09-25T12:00:00.000Z" }];
+    state.context = null;
+
+    const result = await compactAgentThread("agent-1", 1000, true);
+    state.context = undefined;
+
+    expect(result).toEqual({ compacted: false, reason: "no summary produced" });
+  });
+
+  it("reports nothing to compact for an empty thread", async () => {
+    state.rows = [];
+    expect(await compactAgentThread("agent-1")).toEqual({ compacted: false, reason: "nothing to compact" });
+  });
+
+  it("refuses a second manual compaction while one is running", async () => {
+    state.rows = [{ seq: 1, role: "user", content: "hi", created_at: "2026-09-25T12:00:00.000Z" }];
+    state.manualRunning = true;
+    try {
+      expect(await compactAgentThread("agent-1")).toEqual({ compacted: false, reason: "already compacting" });
+    } finally {
+      state.manualRunning = false;
+    }
+  });
+
+  it("reports a timed-out compaction instead of throwing", async () => {
+    state.rows = [{ seq: 1, role: "user", content: "hi", created_at: "2026-09-25T12:00:00.000Z" }];
+    state.timeout = true;
+    try {
+      expect(await compactAgentThread("agent-1")).toEqual({ compacted: false, reason: "timed out" });
+    } finally {
+      state.timeout = false;
+    }
+  });
+});

package/lib/agents/thread-compaction.ts

@@ -6,11 +6,18 @@ import {
   pruneThreadMessages,
 } from "@/lib/stores/threads";
 import { putMemory, listMemory, deleteMemory } from "@/lib/stores/memory";
-import { compactThreadWarmContext, trackManualCompaction } from "@/lib/agents/warm-summary-background";
+import { compactThreadWarmContext, isManualCompactionRunning, trackManualCompaction } from "@/lib/agents/warm-summary-background";
+import { CompactionTimeoutError } from "@/lib/agents/thread-compaction-state";
 import { getConfig } from "@/lib/env/config";
 
+export type ThreadCompactionFailureReason =
+  | "nothing to compact"
+  | "no summary produced"
+  | "already compacting"
+  | "timed out";
+
 export type ThreadCompactionResult =
-  | { compacted: false; reason: string }
+  | { compacted: false; reason: ThreadCompactionFailureReason }
   | {
       compacted: true;
       summary: string;
@@ -73,18 +80,34 @@ export async function compactAgentThread(
   const lastRow = rows[rows.length - 1];
   const boundaryRow = fullSessionReset ? null : rows[Math.max(0, rows.length - keepLast)] ?? lastRow;
   const boundarySeq = fullSessionReset ? lastRow.seq + 1 : boundaryRow!.seq;
-  const context = await trackManualCompaction(thread.thread_id, boundarySeq, () =>
-    compactThreadWarmContext(thread.thread_id, boundarySeq, {
-      expectedHotSinceSeq: thread.hot_since_seq ?? null,
-      alignTopicBoundary: !fullSessionReset,
-    }));
-  if (!context) return { compacted: false, reason: "summary was not committed" };
+  if (isManualCompactionRunning(thread.thread_id)) {
+    return { compacted: false, reason: "already compacting" };
+  }
+  let context: Awaited<ReturnType<typeof compactThreadWarmContext>>;
+  try {
+    context = await trackManualCompaction(thread.thread_id, boundarySeq, (attempt) =>
+      compactThreadWarmContext(thread.thread_id, boundarySeq, {
+        expectedHotSinceSeq: thread.hot_since_seq ?? null,
+        alignTopicBoundary: !fullSessionReset,
+        attempt,
+      }));
+  } catch (err) {
+    if (err instanceof CompactionTimeoutError) return { compacted: false, reason: "timed out" };
+    throw err;
+  }
+  if (!context) return { compacted: false, reason: "no summary produced" };
+
+  // Automation channels (bridge, watcher, scheduled task) are compacted at the
+  // same boundary; a bridge-only agent has nothing but channel recaps.
+  const channelRecaps = context.channels.filter((c) => !!c.summary);
+  const archivedSummary = [context.summary, ...channelRecaps.map((c) => c.summary)].filter(Boolean).join("\n\n");
+  const messageCount = context.sourceMessages + channelRecaps.reduce((n, c) => n + c.sourceMessages, 0);
 
   putMemory("sessions", `${agentId}/${Date.now()}`, {
-    summary: context.summary,
+    summary: archivedSummary,
     agent_id: agentId,
     agent_name: agent.name,
-    message_count: context.sourceMessages,
+    message_count: messageCount,
     compacted_at: new Date().toISOString(),
   });
   const archivePruned = pruneSessionArchives(agentId, maxSessionArchives());
@@ -95,7 +118,7 @@ export async function compactAgentThread(
   return {
     compacted: true,
     summary: context.summary,
-    message_count: context.sourceMessages,
+    message_count: messageCount,
     context_chars: context.sourceChars,
     pruned,
     archive_pruned: archivePruned,

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

@@ -19,8 +19,9 @@ const state = vi.hoisted(() => ({
   commits: [] as Array<{ hotSince: string; summary: string }>,
   rows: [] as unknown[],
   automationRows: {} as Record<string, unknown[]>,
-  channelSummaries: {} as Record<string, { thread_id: string; channel: string; summary: string; summary_before: string | null; summary_before_seq: number | null; computed_at: string }>,
+  channelSummaries: {} as Record<string, { thread_id: string; channel: string; summary: string; summary_before: string | null; summary_before_seq: number | null; computed_at: string; topics?: string | null }>,
   topicSegments: [] as unknown[],
+  provider: {} as unknown,
 }));
 state.rows = DEFAULT_ROWS;
 
@@ -31,7 +32,7 @@ vi.mock("@/lib/stores/threads", () => ({
     ...state.rows as Array<{ seq: number; created_at: string }>,
     ...Object.values(state.automationRows).flat() as Array<{ seq: number; created_at: string }>,
   ].find((row) => row.seq === seq) ?? null,
-  commitThreadWarmContext: (_threadId: string, input: { hotSince: string; hotSinceSeq?: number; summary: string; channelSummaries?: Array<{ channel: string; summary: string }> }) => {
+  commitThreadWarmContext: (_threadId: string, input: { hotSince: string; hotSinceSeq?: number; summary: string; channelSummaries?: Array<{ channel: string; summary: string; topics?: string | null }> }) => {
     state.commits.push({ hotSince: input.hotSince, summary: input.summary });
     state.thread = {
       ...state.thread,
@@ -49,13 +50,15 @@ vi.mock("@/lib/stores/threads", () => ({
         summary_before: input.hotSince,
         summary_before_seq: input.hotSinceSeq ?? 1,
         computed_at: "2026-09-25T10:00:00.000Z",
+        topics: channelSummary.topics ?? null,
       };
     }
     return state.thread;
   },
   getMessagesByAutomationCategory: (threadId: string, channel: string) => state.automationRows[channel] ?? [],
   getThreadChannelSummary: (threadId: string, channel: string) => state.channelSummaries[channel] ?? null,
-  commitThreadChannelSummary: (threadId: string, channel: string, input: { summary: string; summaryBefore: string | null; summaryBeforeSeq?: number | null }) => {
+  listThreadChannelSummaries: () => Object.values(state.channelSummaries),
+  commitThreadChannelSummary: (threadId: string, channel: string, input: { summary: string; summaryBefore: string | null; summaryBeforeSeq?: number | null; topics?: string | null }) => {
     state.channelSummaries[channel] = {
       thread_id: threadId,
       channel,
@@ -63,6 +66,7 @@ vi.mock("@/lib/stores/threads", () => ({
       summary_before: input.summaryBefore,
       summary_before_seq: input.summaryBeforeSeq ?? null,
       computed_at: "2026-09-25T10:00:00.000Z",
+      topics: input.topics ?? null,
     };
   },
 }));
@@ -74,7 +78,7 @@ vi.mock("@/lib/stores/model-config", () => ({
   resolveRunnableModelConfig: () => ({ name: "model-1", provider: "mock", model_id: "mock-1" }),
   getModelParams: () => ({}),
 }));
-vi.mock("@/lib/providers", () => ({ getProvider: () => ({}) }));
+vi.mock("@/lib/providers", () => ({ getProvider: () => state.provider }));
 vi.mock("@/lib/stores/memory", () => ({ putMemory: () => {} }));
 vi.mock("@/lib/agents/prepare/history-window", () => ({
   unwrapWarmSummary: (s: string) => ({ scope: "foreground", content: s }),
@@ -94,7 +98,7 @@ vi.mock("@/lib/agents/conversation-summary", async (importOriginal) => {
   };
 });
 
-import { kickBoundaryCompaction, compactThreadWarmContext, pendingCompactionBoundary, pendingCompactionBoundarySeq, compactAutomationChannelWarmContext, isChannelSummaryFresh, trackManualCompaction } from "./warm-summary-background";
+import { kickBoundaryCompaction, compactThreadWarmContext, pendingCompactionBoundary, pendingCompactionBoundarySeq, compactAutomationChannelWarmContext, currentChannelSummaries, isChannelSummaryFresh, isManualCompactionRunning, trackManualCompaction } from "./warm-summary-background";
 import { summarizeTranscript } from "@/lib/agents/conversation-summary";
 
 describe("trackManualCompaction", () => {
@@ -102,9 +106,16 @@ describe("trackManualCompaction", () => {
     let release!: () => void;
     const done = trackManualCompaction("thread-manual", 42, () => new Promise<void>((r) => { release = r; }));
     expect(pendingCompactionBoundarySeq("thread-manual")).toBe(42);
+    expect(isManualCompactionRunning("thread-manual")).toBe(true);
     release();
     await done;
     expect(pendingCompactionBoundarySeq("thread-manual")).toBeNull();
+    expect(isManualCompactionRunning("thread-manual")).toBe(false);
+  });
+
+  it("does not report automatic boundary compactions as manual", () => {
+    kickBoundaryCompaction("thread-auto-only", 5);
+    expect(isManualCompactionRunning("thread-auto-only")).toBe(false);
   });
 });
 
@@ -210,6 +221,66 @@ describe("compactThreadWarmContext — seq-exact boundary (ADR-0088)", () => {
       state.automationRows = previousAutomationRows;
     }
   });
+
+  it("folds only messages that aged out since the last pass into the stored topics, via the compaction pipeline", async () => {
+    const storedTopics = [{
+      title: "Earlier topic",
+      start_seq: 1,
+      end_seq: 2,
+      start_at: "2026-09-25T09:00:00.000Z",
+      end_at: "2026-09-25T09:00:01.000Z",
+      recap: "earlier recap",
+      facts: [],
+      message_count: 2,
+      source_chars: 20,
+    }];
+    const previousRows = state.rows;
+    const previousProvider = state.provider;
+    const previousLimit = state.warmSummaryLimit;
+    state.warmSummaryLimit = 50;
+    state.thread = {
+      thread_id: "thread-1",
+      hot_since: null,
+      hot_since_seq: 3,
+      warm_summary: "previous",
+      warm_summary_before: null,
+      warm_summary_before_seq: 3,
+      warm_summary_topics: JSON.stringify(storedTopics),
+      message_count: 6,
+    } as typeof state.thread;
+    state.rows = [
+      { seq: 1, role: "user", content: "already summarized question", created_at: "2026-09-25T09:00:00.000Z" },
+      { seq: 2, role: "assistant", content: "already summarized answer", created_at: "2026-09-25T09:00:01.000Z" },
+      { seq: 3, role: "user", content: "newly aged-out question", created_at: "2026-09-25T09:01:00.000Z" },
+      { seq: 4, role: "assistant", content: "newly aged-out answer", created_at: "2026-09-25T09:01:01.000Z" },
+      { seq: 5, role: "user", content: "hot question", created_at: "2026-09-25T09:02:00.000Z" },
+    ];
+    const prompts: string[] = [];
+    state.provider = {
+      chat: async (_model: string, messages: Array<{ content: string }>) => {
+        prompts.push(messages[1].content);
+        const text = messages[0].content.includes("step 1 of 3")
+          ? JSON.stringify({ groups: [{ start_seq: 3, end_seq: 4, continues: "t1", title: "Earlier topic" }] })
+          : JSON.stringify({ recap: "newest detail first; earlier recap compressed", facts: [] });
+        return { stream: (async function* () { yield text; })() };
+      },
+    };
+
+    try {
+      const context = await compactThreadWarmContext("thread-1", 5);
+      expect(prompts).toHaveLength(2);
+      expect(prompts.join("\n")).toContain("newly aged-out question");
+      expect(prompts.join("\n")).not.toContain("already summarized question");
+      expect(prompts.join("\n")).not.toContain("hot question");
+      expect(context?.topics).toMatchObject([{ title: "Earlier topic", start_seq: 1, end_seq: 4, message_count: 4 }]);
+      expect(context?.summary).toContain("newest detail first; earlier recap compressed");
+      expect(context?.sourceMessages).toBe(4);
+    } finally {
+      state.rows = previousRows;
+      state.provider = previousProvider;
+      state.warmSummaryLimit = previousLimit;
+    }
+  });
 });
 
 describe("kickBoundaryCompaction", () => {
@@ -385,6 +456,87 @@ describe("compactAutomationChannelWarmContext (ADR-0044)", () => {
     expect(transcript).toContain("before cursor");
     expect(transcript).not.toContain("at cursor, stays hot");
   });
+
+  it("runs the channel through the compaction pipeline with source-aware prompts, stores topics, and keeps only agent-saved facts", async () => {
+    const previousProvider = state.provider;
+    state.automationRows = {
+      scheduled_task: [
+        { seq: 1, role: "user", content: "run nightly backup task", created_at: "2026-09-25T09:00:00.000Z" },
+        { seq: 2, role: "assistant", content: "backup finished, 3 files copied", created_at: "2026-09-25T09:00:05.000Z" },
+      ],
+    };
+    state.rows = DEFAULT_ROWS;
+    state.channelSummaries = {};
+    const systems: string[] = [];
+    state.provider = {
+      chat: async (_model: string, messages: Array<{ content: string }>) => {
+        systems.push(messages[0].content);
+        const text = messages[0].content.includes("step 1 of 3")
+          ? JSON.stringify({ groups: [{ start_seq: 1, end_seq: 2, continues: null, title: "Nightly backup" }] })
+          : JSON.stringify({ recap: "backup copied 3 files", facts: [{ subject: "Backup target", content: "NAS", confidence: "inferred" }] });
+        return { stream: (async function* () { yield text; })() };
+      },
+    };
+    try {
+      const built = await compactAutomationChannelWarmContext("thread-1", "scheduled_task", 10);
+      expect(systems).toHaveLength(2);
+      expect(systems.every((system) => system.includes("scheduled tasks"))).toBe(true);
+      expect(systems[1]).toContain('Leave "facts" as []');
+      expect(built?.summary).toContain("--- scheduled_task activity summary ---");
+      expect(built?.summary).toContain("backup copied 3 files");
+      expect(built?.topics).toMatchObject([{ title: "Nightly backup", start_seq: 1, end_seq: 2, message_count: 2, facts: [] }]);
+      const stored = JSON.parse(state.channelSummaries.scheduled_task.topics!) as Array<{ title: string }>;
+      expect(stored.map((topic) => topic.title)).toEqual(["Nightly backup"]);
+    } finally {
+      state.provider = previousProvider;
+    }
+  });
+
+  it("folds only newly aged-out channel rows into the channel's stored topics", async () => {
+    const previousProvider = state.provider;
+    const previousLimit = state.warmSummaryLimit;
+    state.warmSummaryLimit = 50;
+    state.automationRows = {
+      watcher: [
+        { seq: 1, role: "assistant", content: "already summarized fire", created_at: "2026-09-25T09:00:00.000Z" },
+        { seq: 2, role: "assistant", content: "already summarized handling", created_at: "2026-09-25T09:00:01.000Z" },
+        { seq: 5, role: "assistant", content: "new inbox fire", created_at: "2026-09-25T09:05:00.000Z" },
+        { seq: 6, role: "assistant", content: "new inbox handled", created_at: "2026-09-25T09:05:01.000Z" },
+      ],
+    };
+    state.rows = DEFAULT_ROWS;
+    state.channelSummaries = {
+      watcher: {
+        thread_id: "thread-1",
+        channel: "watcher",
+        summary: "old",
+        summary_before: null,
+        summary_before_seq: 3,
+        computed_at: "2026-09-25T09:00:02.000Z",
+        topics: JSON.stringify([{ title: "Inbox watcher", start_seq: 1, end_seq: 2, start_at: "a", end_at: "b", recap: "old recap", facts: [], message_count: 2, source_chars: 40 }]),
+      },
+    };
+    const userPrompts: string[] = [];
+    state.provider = {
+      chat: async (_model: string, messages: Array<{ content: string }>) => {
+        userPrompts.push(messages[1].content);
+        const text = messages[0].content.includes("step 1 of 3")
+          ? JSON.stringify({ groups: [{ start_seq: 5, end_seq: 6, continues: "t1", title: "Inbox watcher" }] })
+          : JSON.stringify({ recap: "new fire handled; earlier fires handled too", facts: [] });
+        return { stream: (async function* () { yield text; })() };
+      },
+    };
+    try {
+      const built = await compactAutomationChannelWarmContext("thread-1", "watcher", 10);
+      expect(userPrompts.join("\n")).toContain("new inbox fire");
+      expect(userPrompts.join("\n")).not.toContain("already summarized fire");
+      expect(built?.topics).toMatchObject([{ title: "Inbox watcher", start_seq: 1, end_seq: 6, message_count: 4 }]);
+      expect(built?.sourceMessages).toBe(4);
+    } finally {
+      state.provider = previousProvider;
+      state.warmSummaryLimit = previousLimit;
+    }
+  });
 });
 
 describe("kickBoundaryCompaction refreshes automation channels alongside chat (ADR-0044)", () => {
@@ -428,3 +580,65 @@ describe("kickBoundaryCompaction refreshes automation channels alongside chat (A
     expect(state.channelSummaries.scheduled_task.summary_before).toBe(state.commits[0].hotSince);
   });
 });
+
+describe("compactThreadWarmContext — automation-only threads", () => {
+  function resetThread() {
+    state.thread = {
+      thread_id: "thread-1",
+      hot_since: null,
+      hot_since_seq: null,
+      warm_summary: null,
+      warm_summary_before: null,
+      warm_summary_before_seq: null,
+      message_count: 2,
+    };
+    state.commits = [];
+    state.channelSummaries = {};
+    state.topicSegments = [];
+  }
+
+  it("commits a manual compaction when only the bridge channel has activity", async () => {
+    resetThread();
+    state.rows = [];
+    state.automationRows = {
+      bridge: [
+        { seq: 1, role: "user", content: "whatsapp: can you book the table for friday", created_at: "2026-09-25T09:00:00.000Z" },
+        { seq: 2, role: "assistant", content: "booked the table for friday at 8pm", created_at: "2026-09-25T09:00:05.000Z" },
+      ],
+    };
+    vi.mocked(summarizeTranscript).mockReset();
+    vi.mocked(summarizeTranscript).mockResolvedValue("table booked for friday");
+
+    const context = await compactThreadWarmContext("thread-1", 3);
+
+    expect(context).not.toBeNull();
+    expect(context?.summary).toBe("");
+    const bridge = context?.channels.find((c) => c.channel === "bridge");
+    expect(bridge?.summary).toContain("table booked for friday");
+    expect(bridge?.sourceMessages).toBe(2);
+    expect(state.commits).toHaveLength(1);
+    expect(state.channelSummaries.bridge.summary).toContain("--- bridge activity summary ---");
+
+    // The UI reads exactly these recaps back for the committed boundary, so
+    // a bridge-only card shows the bridge recap rather than "pending".
+    const visible = currentChannelSummaries("thread-1", state.thread.hot_since_seq);
+    expect(visible.map((c) => c.channel)).toEqual(["bridge"]);
+    expect(visible[0].summary).toContain("table booked for friday");
+    expect(currentChannelSummaries("thread-1", (state.thread.hot_since_seq ?? 0) + 1)).toEqual([]);
+    expect(currentChannelSummaries("thread-1", null)).toEqual([]);
+  });
+
+  it("still declines a manual compaction when neither chat nor any channel produced a summary", async () => {
+    resetThread();
+    state.rows = [];
+    state.automationRows = {
+      bridge: [{ seq: 1, role: "user", content: "hi", created_at: "2026-09-25T09:00:00.000Z" }],
+    };
+    vi.mocked(summarizeTranscript).mockReset();
+
+    const context = await compactThreadWarmContext("thread-1", 2);
+
+    expect(context).toBeNull();
+    expect(state.commits).toHaveLength(0);
+  });
+});