@circuitwall/jarela 2.2.1 → 2.3.0

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

@@ -1,6 +1,8 @@
 import { getProvider } from "@/lib/providers";
 import type { ModelProvider, ProviderParams } from "@/lib/providers/types";
-import { summarizeTranscript, transcriptText, extractTopicSegments, validateTopicSegments, type SummaryTopicSegment } from "@/lib/agents/conversation-summary";
+import { summarizeTranscript, transcriptText, extractTopicSegments, validateTopicSegments, parseStoredTopics, type SummaryTopicSegment } from "@/lib/agents/conversation-summary";
+import { canMergeIntoTopics, finalizeFreshTopics, mergeWarmTopics, renderTopicRecaps, slugifyForMemoryKey } from "@/lib/agents/warm-topics";
+import { formatTranscriptRow, runCompactionPipeline, type CompactionSource, type PipelineSourceRow } from "@/lib/agents/compaction-pipeline";
 import { takeRecentWarmMessages, warmSummaryMessageLimit, wrapWarmSummary, AUTOMATION_CHANNEL_ORDER } from "@/lib/agents/prepare/history-window";
 import { getAgentConfig, getAgentTierProportions } from "@/lib/stores/agent-configs";
 import { getModelParams, resolveRunnableModelConfig } from "@/lib/stores/model-config";
@@ -13,15 +15,42 @@ import {
   getThread,
   getThreadMessageBySeq,
   getThreadChannelSummary,
+  listThreadChannelSummaries,
 } from "@/lib/stores/threads";
+import { getOrCreateGlobal } from "@/lib/utils/global-state";
+import {
+  getCompactionAttempt,
+  isCompactionRunning,
+  runTrackedCompaction,
+  type CompactionAttempt,
+} from "@/lib/agents/thread-compaction-state";
+
+/** Automation-channel recaps committed at the thread's current boundary. */
+export function currentChannelSummaries(
+  threadId: string,
+  hotSinceSeq: number | null | undefined,
+): Array<{ channel: string; summary: string; computed_at: string; topics: SummaryTopicSegment[] | null }> {
+  if (hotSinceSeq == null) return [];
+  const order: readonly string[] = AUTOMATION_CHANNEL_ORDER;
+  return listThreadChannelSummaries(threadId)
+    .filter((row) => row.summary_before_seq === hotSinceSeq && row.summary.trim().length > 0)
+    .sort((a, b) => order.indexOf(a.channel) - order.indexOf(b.channel))
+    .map((row) => ({
+      channel: row.channel,
+      summary: row.summary,
+      computed_at: row.computed_at,
+      topics: parseStoredTopics(row.topics),
+    }));
+}
 
 const MAX_TOPIC_PREVIEW_CHARS = 24_000;
 
-const activeRefreshes = new Set<string>();
-// Boundaries an automatic compaction has proposed but not yet committed.
-// The pin only moves once the recap that replaces the cut-off messages is
-// stored, so the turn that proposes it still runs on the old boundary.
-const pendingBoundaries = new Map<string, number>();
+// Automatic ("auto"), summary-refresh ("refresh") and manual /compact
+// ("manual") attempts are tracked per thread in thread-compaction-state, so
+// every route bundle reports the same compaction and each one has a deadline.
+// An auto boundary is proposed but not committed until its recap is stored,
+// so the turn that proposes it still runs on the old boundary.
+//
 // A boundary request that arrived while a prior one for the same thread was
 // still in flight. Last-write-wins: kickBoundaryCompaction used to silently
 // drop any request that arrived while one was already running (dragging
@@ -31,19 +60,23 @@ const pendingBoundaries = new Map<string, number>();
 // later request was ignored. Queuing the latest one and re-running it once
 // the in-flight commit settles makes the boundary always converge on what
 // the caller most recently asked for.
-const queuedBoundaries = new Map<string, {
+const queuedBoundaries = getOrCreateGlobal("__jarela_queued_compaction_boundaries", () => new Map<string, {
   boundarySeq: number;
   options: Pick<WarmContextCompactionOptions, "autoBoundaryLockedUntilMessageCount">;
-}>();
+}>());
+
+function backgroundCompactionRunning(threadId: string): boolean {
+  return isCompactionRunning(threadId, "auto") || isCompactionRunning(threadId, "refresh");
+}
 
 export function kickWarmSummaryRefresh(threadId: string): void {
-  if (!threadId || activeRefreshes.has(threadId)) return;
-  activeRefreshes.add(threadId);
-  queueMicrotask(() => {
-    void refreshWarmSummary(threadId).finally(() => {
-      activeRefreshes.delete(threadId);
-    });
-  });
+  if (!threadId || backgroundCompactionRunning(threadId)) return;
+  const thread = getThread(threadId);
+  void runTrackedCompaction(threadId, "refresh", thread?.hot_since_seq ?? null, async (attempt) => {
+    await Promise.resolve();
+    await refreshWarmSummary(threadId, attempt);
+  }).catch((err) => console.warn(`[warm-summary] refresh failed thread=${threadId}: ${String(err)}`))
+    .finally(() => drainQueuedBoundary(threadId));
 }
 
 /**
@@ -59,26 +92,27 @@ export function pendingCompactionBoundary(threadId: string): string | null {
 
 export function pendingCompactionBoundarySeq(threadId: string): number | null {
   return queuedBoundaries.get(threadId)?.boundarySeq
-    ?? pendingBoundaries.get(threadId)
-    ?? manualBoundaries.get(threadId)
+    ?? getCompactionAttempt(threadId, "auto")?.boundarySeq
+    ?? getCompactionAttempt(threadId, "manual")?.boundarySeq
     ?? null;
 }
 
-// Manual /compact runs outside the auto-compaction queue; track it so a
-// client that reloads the thread mid-compaction still sees it pending.
-const manualBoundaries = new Map<string, number>();
+/** A manual /compact holds the thread (the UI queues sends); auto ones don't. */
+export function isManualCompactionRunning(threadId: string): boolean {
+  return isCompactionRunning(threadId, "manual");
+}
 
-export async function trackManualCompaction<T>(
+/**
+ * Run a manual /compact as the thread's single manual attempt. Pass the
+ * attempt to compactThreadWarmContext so a result that arrives after the
+ * deadline is discarded rather than committed.
+ */
+export function trackManualCompaction<T>(
   threadId: string,
   boundarySeq: number,
-  run: () => Promise<T>,
+  run: (attempt: CompactionAttempt) => Promise<T>,
 ): Promise<T> {
-  manualBoundaries.set(threadId, boundarySeq);
-  try {
-    return await run();
-  } finally {
-    if (manualBoundaries.get(threadId) === boundarySeq) manualBoundaries.delete(threadId);
-  }
+  return runTrackedCompaction(threadId, "manual", boundarySeq, run);
 }
 
 /**
@@ -99,13 +133,29 @@ export function kickBoundaryCompaction(
   options: Pick<WarmContextCompactionOptions, "autoBoundaryLockedUntilMessageCount"> = {},
 ): void {
   if (!threadId || !Number.isSafeInteger(boundarySeq) || boundarySeq <= 0) return;
-  if (activeRefreshes.has(threadId) || pendingBoundaries.has(threadId)) {
+  if (backgroundCompactionRunning(threadId)) {
     queuedBoundaries.set(threadId, { boundarySeq, options });
     return;
   }
   runBoundaryCompaction(threadId, boundarySeq, options);
 }
 
+// Called whenever a background attempt settles. A queued boundary that a
+// summary refresh was blocking used to be stranded here forever, which kept
+// the thread reporting a pending compaction until restart.
+function drainQueuedBoundary(threadId: string): void {
+  if (backgroundCompactionRunning(threadId)) return;
+  const queued = queuedBoundaries.get(threadId);
+  if (!queued) return;
+  queuedBoundaries.delete(threadId);
+  // Skip a no-op re-run if the boundary that just committed already
+  // matches what was queued — the queued request was superseded by
+  // the very commit it was waiting behind.
+  const settled = getThread(threadId);
+  const alreadySettled = queued.boundarySeq === (settled?.hot_since_seq ?? null);
+  if (!alreadySettled) runBoundaryCompaction(threadId, queued.boundarySeq, queued.options);
+}
+
 function runBoundaryCompaction(
   threadId: string,
   boundarySeq: number,
@@ -113,38 +163,26 @@ function runBoundaryCompaction(
 ): void {
   const baseThread = getThread(threadId);
   const basePinSeq = baseThread?.hot_since_seq ?? null;
-  pendingBoundaries.set(threadId, boundarySeq);
-  activeRefreshes.add(threadId);
-  queueMicrotask(() => {
-    void commitBoundaryCompaction(threadId, boundarySeq, basePinSeq, options)
-      .catch((err) => console.warn(`[context-boundary:auto] compaction failed thread=${threadId}: ${String(err)}`))
-      .finally(() => {
-        pendingBoundaries.delete(threadId);
-        activeRefreshes.delete(threadId);
-        const queued = queuedBoundaries.get(threadId);
-        if (!queued) return;
-        queuedBoundaries.delete(threadId);
-        // Skip a no-op re-run if the boundary that just committed already
-        // matches what was queued — the queued request was superseded by
-        // the very commit it was waiting behind.
-        const settled = getThread(threadId);
-        const alreadySettled = queued.boundarySeq === (settled?.hot_since_seq ?? null);
-        if (!alreadySettled) runBoundaryCompaction(threadId, queued.boundarySeq, queued.options);
-      });
-  });
+  void runTrackedCompaction(threadId, "auto", boundarySeq, async (attempt) => {
+    await Promise.resolve();
+    await commitBoundaryCompaction(threadId, boundarySeq, basePinSeq, options, attempt);
+  })
+    .catch((err) => console.warn(`[context-boundary:auto] compaction failed thread=${threadId}: ${String(err)}`))
+    .finally(() => drainQueuedBoundary(threadId));
 }
-
 async function commitBoundaryCompaction(
   threadId: string,
   boundarySeq: number,
   basePinSeq: number | null,
   options: Pick<WarmContextCompactionOptions, "autoBoundaryLockedUntilMessageCount">,
+  attempt?: CompactionAttempt,
 ): Promise<void> {
   const committed = await compactThreadWarmContext(threadId, boundarySeq, {
     expectedHotSinceSeq: basePinSeq,
     alignTopicBoundary: true,
     allowEmptySummary: true,
     ...options,
+    attempt,
   });
   if (!committed) return;
   console.info(
@@ -223,13 +261,14 @@ export async function findTopicBoundary(threadId: string, boundarySeq: number):
   }
 }
 
-export async function refreshWarmSummary(threadId: string): Promise<void> {
+export async function refreshWarmSummary(threadId: string, attempt?: CompactionAttempt): Promise<void> {
   const thread = getThread(threadId);
   if (!thread?.hot_since_seq) return;
   await compactThreadWarmContext(threadId, thread.hot_since_seq, {
     expectedHotSinceSeq: thread.hot_since_seq,
     alignTopicBoundary: false,
     allowEmptySummary: true,
+    attempt,
   });
 }
 
@@ -241,6 +280,9 @@ interface BuiltSummary {
   // Per-topic segmentation of the same range (see SummaryTopicSegment). Empty
   // when the summarizer didn't return a `jarela-topics` fence.
   topics: SummaryTopicSegment[];
+  // Topics produced by this pass only; their extracted facts get uplifted.
+  // Stored topics merged in earlier were uplifted when they were fresh.
+  freshTopics: SummaryTopicSegment[];
 }
 
 export interface CommittedWarmContext {
@@ -250,6 +292,8 @@ export interface CommittedWarmContext {
   sourceMessages: number;
   sourceChars: number;
   topics: SummaryTopicSegment[];
+  /** Per automation channel (ADR-0044), committed at the same boundary. */
+  channels: Array<{ channel: string; summary: string; sourceMessages: number }>;
 }
 
 export interface WarmContextCompactionOptions {
@@ -258,6 +302,9 @@ export interface WarmContextCompactionOptions {
   alignTopicBoundary?: boolean;
   allowEmptySummary?: boolean;
   autoBoundaryLockedUntilMessageCount?: number;
+  /** The tracked attempt this compaction runs under; once it is no longer
+   *  current (deadline passed or replaced) the result is not committed. */
+  attempt?: Pick<CompactionAttempt, "isCurrent">;
   providerOverride?: {
     provider: Pick<ModelProvider, "chat">;
     modelId: string;
@@ -289,13 +336,24 @@ export async function compactThreadWarmContext(
   if (!boundaryRow) return null;
   const boundary = boundaryRow.created_at;
   const built = await buildSummaryBefore(threadId, boundary, boundarySeq, options.providerOverride);
-  if (!built || (!built.summary && !options.allowEmptySummary)) return null;
+  if (!built) return null;
+  if (options.attempt && !options.attempt.isCurrent()) return null;
 
   const channelSummaries = await Promise.all(AUTOMATION_CHANNEL_ORDER.map(async (channel) => {
     const channelSummary = await buildAutomationChannelSummaryBefore(threadId, channel, boundarySeq, options.providerOverride);
     if (!channelSummary) throw new Error(`Could not build ${channel} warm summary`);
-    return { channel, summary: channelSummary.summary };
+    return {
+      channel,
+      summary: channelSummary.summary,
+      sourceMessages: channelSummary.sourceMessages,
+      topics: channelSummary.topics ? JSON.stringify(channelSummary.topics) : null,
+    };
   }));
+  // A thread whose only activity is automation (e.g. a bridge-only agent) has
+  // an empty chat summary but real channel recaps — that is still a result.
+  const anySummary = !!built.summary || channelSummaries.some((c) => !!c.summary);
+  if (!anySummary && !options.allowEmptySummary) return null;
+  if (options.attempt && !options.attempt.isCurrent()) return null;
 
   const committed = commitThreadWarmContext(threadId, {
     hotSince: boundary,
@@ -311,11 +369,13 @@ export async function compactThreadWarmContext(
       ? options.expectedWarmSummary
       : (baseThread.warm_summary ?? null),
     autoBoundaryLockedUntilMessageCount: options.autoBoundaryLockedUntilMessageCount,
-    channelSummaries,
+    channelSummaries: channelSummaries.map(({ channel, summary, topics }) => ({ channel, summary, topics })),
   });
   if (!committed) return null;
-  upliftTopicFacts(built.topics);
-  return { boundary, boundarySeq, ...built };
+  upliftTopicFacts(built.freshTopics);
+  const { freshTopics: _fresh, ...context } = built;
+  const channels = channelSummaries.map(({ channel, summary, sourceMessages }) => ({ channel, summary, sourceMessages }));
+  return { boundary, boundarySeq, ...context, channels };
 }
 
 /**
@@ -351,40 +411,55 @@ async function buildSummaryBefore(
     ? providerParams.context_window_tokens
     : 32768;
   const summaryInputChars = Math.max(4000, Math.min(120000, Math.round(contextTokens * 3)));
-  const eligibleRows = takeRecentWarmMessages(rows.filter((m) => m.seq < boundarySeq), agent.warm_summary_limit);
-  const selectedRows: typeof eligibleRows = [];
-  const selectedTranscript: string[] = [];
-  let selectedTranscriptChars = 0;
-  for (let index = eligibleRows.length - 1; index >= 0; index -= 1) {
-    const row = eligibleRows[index];
-    const formatted = `[seq=${row.seq}] [${row.created_at}] ${row.role === "user" ? "User" : "Assistant"}: ${transcriptText(row.content)}`;
-    const addedChars = formatted.length + (selectedTranscript.length > 0 ? 2 : 0);
-    if (selectedTranscriptChars + addedChars > summaryInputChars) break;
-    selectedRows.unshift(row);
-    selectedTranscript.unshift(formatted);
-    selectedTranscriptChars += addedChars;
+  const provider = providerOverride?.provider ?? getProvider(modelCfg.provider);
+  const modelId = providerOverride?.modelId ?? modelCfg.model_id;
+  const summaryParams = providerParams.max_tokens
+    ? providerParams
+    : { ...providerParams, max_tokens: 1024 };
+
+  const outcome = await runTopicCompaction({
+    threadId,
+    source: "chat",
+    rows,
+    storedTopics: parseStoredTopics(thread.warm_summary_topics),
+    storedBeforeSeq: thread.warm_summary_before_seq,
+    boundarySeq,
+    warmSummaryLimit: agent.warm_summary_limit,
+    summaryInputChars,
+    provider,
+    modelId,
+    params: summaryParams,
+  });
+  if (outcome.status === "empty") {
+    return { summary: "", sourceMessages: outcome.sourceMessages, sourceChars: outcome.sourceChars, topics: [], freshTopics: [] };
   }
+  if (outcome.status === "topics") {
+    return {
+      summary: wrapTopicSummary(outcome.topics),
+      sourceMessages: outcome.sourceMessages,
+      sourceChars: outcome.sourceChars,
+      topics: outcome.topics,
+      freshTopics: outcome.freshTopics,
+    };
+  }
+  console.warn(`[warm-summary] thread=${threadId} compaction pipeline failed validation; using single-call summary`);
+
+  const eligibleRows = takeRecentWarmMessages(rows.filter((m) => m.seq < boundarySeq), agent.warm_summary_limit);
+  const { selectedRows, transcript } = selectTranscriptRows(eligibleRows, summaryInputChars);
   const selectedSourceChars = selectedRows.reduce((total, row) => total + transcriptText(row.content).length, 0);
   if (selectedSourceChars < 24 || selectedRows.length < 2) {
-    return { summary: "", sourceMessages: selectedRows.length, sourceChars: selectedSourceChars, topics: [] };
+    return { summary: "", sourceMessages: selectedRows.length, sourceChars: selectedSourceChars, topics: [], freshTopics: [] };
   }
 
-  const transcript = selectedTranscript.join("\n\n").trim();
   if (!transcript) return null;
 
-  const provider = providerOverride?.provider ?? getProvider(modelCfg.provider);
-  const modelId = providerOverride?.modelId ?? modelCfg.model_id;
-  const summaryParams = providerParams.max_tokens
-    ? providerParams
-    : { ...providerParams, max_tokens: 1024 };
-
   const raw = (await summarizeTranscript(provider, modelId, summaryParams, transcript)).trim();
   if (!raw) return null;
   const { body, topics } = extractTopicSegments(raw);
-  const validatedTopics = validateTopicSegments(topics, rows, selectedRows, {
+  const validatedTopics = finalizeFreshTopics(validateTopicSegments(topics, rows, selectedRows, {
     boundarySeq,
     allowPartialStart: true,
-  });
+  }), selectedRows);
   const summarizedSeqs = new Set(validatedTopics.flatMap((topic) =>
     selectedRows
       .filter((row) => row.seq >= topic.start_seq! && row.seq <= topic.end_seq!)
@@ -393,31 +468,119 @@ async function buildSummaryBefore(
   const summarizedRows = validatedTopics.length > 0
     ? selectedRows.filter((row) => summarizedSeqs.has(row.seq))
     : selectedRows;
-  const summary = validatedTopics.length > 0
-    ? renderTopicRecaps(validatedTopics)
-    : body;
-  if (!summary) return null;
+  if (validatedTopics.length === 0 && !body) return null;
   const sourceMessages = summarizedRows.length;
   const sourceChars = summarizedRows.reduce((total, row) => total + transcriptText(row.content).length, 0);
 
   return {
-    summary: [
-      "--- Warm context summary ---",
-      "Compressed recap of recent messages immediately before the hot window:",
-      summary,
-    ].join("\n"),
+    summary: validatedTopics.length > 0 ? wrapTopicSummary(validatedTopics) : wrapTopicSummary(null, body),
     sourceMessages,
     sourceChars,
     topics: validatedTopics,
+    freshTopics: validatedTopics,
+  };
+}
+
+type TopicCompactionOutcome =
+  | { status: "empty"; sourceMessages: number; sourceChars: number }
+  | { status: "topics"; topics: SummaryTopicSegment[]; freshTopics: SummaryTopicSegment[]; sourceMessages: number; sourceChars: number }
+  | { status: "failed" };
+
+interface TopicCompactionInput<T extends PipelineSourceRow> {
+  threadId: string;
+  source: CompactionSource;
+  /** Every row of this message stream, ascending by seq. */
+  rows: readonly T[];
+  storedTopics: SummaryTopicSegment[] | null;
+  storedBeforeSeq: number | null | undefined;
+  boundarySeq: number;
+  warmSummaryLimit: number | null | undefined;
+  summaryInputChars: number;
+  provider: Pick<ModelProvider, "chat">;
+  modelId: string;
+  params: ProviderParams;
+}
+
+/**
+ * Shared by chat and every automation channel: run the compaction pipeline
+ * (lib/agents/compaction-pipeline.ts) over one message stream. Incremental
+ * when the stored topics can be extended — only rows that aged out of hot
+ * since the last pass are folded in; otherwise the recent warm window is
+ * regrouped from scratch. "failed" tells the caller to use its single-call
+ * fallback.
+ */
+async function runTopicCompaction<T extends PipelineSourceRow>(input: TopicCompactionInput<T>): Promise<TopicCompactionOutcome> {
+  const { threadId, source, rows, storedTopics, storedBeforeSeq, boundarySeq } = input;
+  const messageLimit = warmSummaryMessageLimit(input.warmSummaryLimit);
+  const incremental = messageLimit > 0 && canMergeIntoTopics(storedTopics, storedBeforeSeq, boundarySeq);
+  const priorTopics = incremental ? storedTopics! : [];
+  const candidates = incremental
+    ? rows.filter((m) => m.seq >= storedBeforeSeq! && m.seq < boundarySeq)
+    : takeRecentWarmMessages(rows.filter((m) => m.seq < boundarySeq), input.warmSummaryLimit);
+  const { selectedRows } = selectTranscriptRows(candidates, input.summaryInputChars);
+  if (incremental && selectedRows.length === 0) {
+    const kept = mergeWarmTopics(priorTopics, [], messageLimit);
+    return { status: "topics", topics: kept.topics, freshTopics: [], sourceMessages: kept.sourceMessages, sourceChars: kept.sourceChars };
+  }
+  const selectedChars = selectedRows.reduce((total, row) => total + transcriptText(row.content).length, 0);
+  if (!incremental && (selectedChars < 24 || selectedRows.length < 2)) {
+    return { status: "empty", sourceMessages: selectedRows.length, sourceChars: selectedChars };
+  }
+  const firstSeq = selectedRows[0]?.seq ?? boundarySeq;
+  const label = `[warm-summary] thread=${threadId} source=${source} ${incremental ? "merge" : "rebuild"}`;
+  const pipeline = await runCompactionPipeline({
+    provider: input.provider,
+    modelId: input.modelId,
+    params: input.params,
+    rows: selectedRows,
+    priorTopics,
+    messageLimit: messageLimit > 0 ? messageLimit : selectedRows.length,
+    partialStart: !incremental && rows.some((m) => m.seq < firstSeq),
+    source,
+    log: (message) => console.info(`${label} ${message}`),
+  }).catch((err: unknown) => {
+    console.warn(`${label} compaction pipeline threw:`, err);
+    return null;
+  });
+  if (!pipeline) return { status: "failed" };
+  return {
+    status: "topics",
+    topics: pipeline.topics,
+    freshTopics: pipeline.freshTopics,
+    sourceMessages: pipeline.sourceMessages,
+    sourceChars: pipeline.sourceChars,
   };
 }
 
-function renderTopicRecaps(topics: readonly SummaryTopicSegment[]): string {
-  return topics.map((topic) =>
-    `### ${topic.title}${topic.partial_start ? " (partial; earlier messages omitted)" : ""}\n${topic.recap}`,
-  ).join("\n\n");
+function selectTranscriptRows<T extends { seq: number; created_at: string; role: string; content: string }>(
+  rows: readonly T[],
+  budgetChars: number,
+): { selectedRows: T[]; transcript: string } {
+  // Newest first, so a budget overflow drops the oldest messages.
+  const selectedRows: T[] = [];
+  const parts: string[] = [];
+  let chars = 0;
+  for (let index = rows.length - 1; index >= 0; index -= 1) {
+    const row = rows[index];
+    const formatted = formatTranscriptRow(row);
+    const added = formatted.length + (parts.length > 0 ? 2 : 0);
+    if (chars + added > budgetChars) break;
+    selectedRows.unshift(row);
+    parts.unshift(formatted);
+    chars += added;
+  }
+  return { selectedRows, transcript: parts.join("\n\n").trim() };
+}
+
+function wrapTopicSummary(topics: readonly SummaryTopicSegment[] | null, body = ""): string {
+  return [
+    "--- Warm context summary ---",
+    "Compressed recap of recent messages immediately before the hot window:",
+    topics ? renderTopicRecaps(topics) : body,
+  ].join("\n");
 }
 
+
 // Batched uplift (once per compaction pass, covering every topic segment
 // together — not fired per-segment as each is identified). Direct writes,
 // same as the agent-facing memory_upsert tool: background compaction has
@@ -428,7 +591,9 @@ export function upliftTopicFacts(topics: readonly SummaryTopicSegment[]): void {
   const seenKeys = new Set<string>();
   for (const topic of topics) {
     for (const fact of topic.facts) {
-      const key = slugifyForMemoryKey(fact.subject);
+      // The agent already saved this one during the turn; don't overwrite it.
+      if (fact.origin === "agent") continue;
+      const key = fact.key?.startsWith("facts/") ? fact.key.slice("facts/".length) : slugifyForMemoryKey(fact.subject);
       if (!key || seenKeys.has(key)) continue;
       seenKeys.add(key);
       putMemory("facts", key, {
@@ -449,34 +614,45 @@ export function upliftTopicFacts(topics: readonly SummaryTopicSegment[]): void {
   }
 }
 
-function slugifyForMemoryKey(subject: string): string {
-  return subject
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, 80);
-}
-
 export interface BuiltChannelSummary {
   /** "" when there was too little automation activity to summarise. */
   summary: string;
   sourceMessages: number;
   sourceChars: number;
+  /** Stored topics when the compaction pipeline produced them; null for the single-call fallback. */
+  topics: SummaryTopicSegment[] | null;
+}
+
+const AUTOMATION_COMPACTION_SOURCES: readonly CompactionSource[] = ["scheduled_task", "watcher", "bridge"];
+
+function automationCompactionSource(channel: string): CompactionSource {
+  return (AUTOMATION_COMPACTION_SOURCES as readonly string[]).includes(channel) ? channel as CompactionSource : "scheduled_task";
+}
+
+// ADR-0044 channels never uplift facts to memory, so the only facts a channel
+// topic keeps are memory the agent itself saved there (verified in code).
+function keepSavedFactsOnly(topics: readonly SummaryTopicSegment[]): SummaryTopicSegment[] {
+  return topics.map((topic) => ({ ...topic, facts: topic.facts.filter((fact) => fact.origin === "agent") }));
+}
+
+function wrapChannelSummary(channel: string, body: string): string {
+  return [
+    `--- ${channel} activity summary ---`,
+    "Compressed recap of automation activity outside the hot window:",
+    body,
+  ].join("\n");
 }
 
 // ADR-0044 — the automation-channel counterpart to buildSummaryBefore. Chat
-// keeps using buildSummaryBefore/compactThreadWarmContext unchanged (the
-// legacy threads.warm_summary* columns ARE the "chat" channel's summary,
-// per the ADR's fallback design); this covers scheduled_task/watcher/bridge,
-// each cached in its own thread_channel_summaries row.
+// keeps using buildSummaryBefore/compactThreadWarmContext (the legacy
+// threads.warm_summary* columns ARE the "chat" channel's summary, per the
+// ADR's fallback design); this covers scheduled_task/watcher/bridge, each
+// cached in its own thread_channel_summaries row.
 //
-// Deliberately simpler than buildSummaryBefore: no extend-prior-summary
-// optimisation (thread_channel_summaries has no source_messages/source_chars
-// columns to carry a running count across calls) and no topic-fact uplift —
-// automation activity logs are far lower volume than interactive chat and
-// far less likely to carry durable personal facts worth extracting. Every
-// call re-summarises the full channel history below the boundary from
-// scratch; acceptable given the expected message counts.
+// Same compaction pipeline as chat (group -> recap -> merge, incremental into
+// the channel's stored topics), with source-specific prompt wording. Unlike
+// chat there is no topic-fact uplift: automation logs rarely carry durable
+// personal facts, so channel topics only keep memory the agent saved itself.
 async function buildAutomationChannelSummaryBefore(
   threadId: string,
   channel: string,
@@ -497,43 +673,52 @@ async function buildAutomationChannelSummaryBefore(
   const providerParams = tier ? { ...baseParams, context_tier_proportions: tier } : baseParams;
 
   const rows = getMessagesByAutomationCategory(threadId, channel);
-  const eligibleRows = rows.filter((m) => m.seq < boundarySeq);
-  const warmRows = takeRecentWarmMessages(
-    eligibleRows,
-    agent.warm_summary_limit,
-  );
-
   const contextTokens = typeof providerParams.context_window_tokens === "number"
     ? providerParams.context_window_tokens
     : 32768;
   const summaryInputChars = Math.max(4000, Math.min(120000, Math.round(contextTokens * 3)));
+  const provider = providerOverride?.provider ?? getProvider(modelCfg.provider);
+  const modelId = providerOverride?.modelId ?? modelCfg.model_id;
+  const summaryParams = providerParams.max_tokens
+    ? providerParams
+    : { ...providerParams, max_tokens: 1024 };
 
-  const selectedRows: typeof warmRows = [];
-  const selectedTranscript: string[] = [];
-  let selectedTranscriptChars = 0;
-  for (let index = warmRows.length - 1; index >= 0; index -= 1) {
-    const row = warmRows[index];
-    const formatted = `[seq=${row.seq}] [${row.created_at}] ${row.role === "user" ? "User" : "Assistant"}: ${transcriptText(row.content)}`;
-    const addedChars = formatted.length + (selectedTranscript.length > 0 ? 2 : 0);
-    if (selectedTranscriptChars + addedChars > summaryInputChars) break;
-    selectedRows.unshift(row);
-    selectedTranscript.unshift(formatted);
-    selectedTranscriptChars += addedChars;
+  const stored = getThreadChannelSummary(threadId, channel);
+  const outcome = await runTopicCompaction({
+    threadId,
+    source: automationCompactionSource(channel),
+    rows,
+    storedTopics: parseStoredTopics(stored?.topics ?? null),
+    storedBeforeSeq: stored?.summary_before_seq,
+    boundarySeq,
+    warmSummaryLimit: agent.warm_summary_limit,
+    summaryInputChars,
+    provider,
+    modelId,
+    params: summaryParams,
+  });
+  if (outcome.status === "empty") {
+    return { summary: "", sourceMessages: outcome.sourceMessages, sourceChars: outcome.sourceChars, topics: null };
+  }
+  if (outcome.status === "topics") {
+    const topics = keepSavedFactsOnly(outcome.topics);
+    return {
+      summary: topics.length > 0 ? wrapChannelSummary(channel, renderTopicRecaps(topics)) : "",
+      sourceMessages: outcome.sourceMessages,
+      sourceChars: outcome.sourceChars,
+      topics,
+    };
   }
+  console.warn(`[warm-summary] thread=${threadId} ${channel} compaction pipeline failed validation; using single-call summary`);
+
+  const eligibleRows = takeRecentWarmMessages(rows.filter((m) => m.seq < boundarySeq), agent.warm_summary_limit);
+  const { selectedRows, transcript } = selectTranscriptRows(eligibleRows, summaryInputChars);
   const sourceChars = selectedRows.reduce((total, row) => total + transcriptText(row.content).length, 0);
   if (sourceChars < 24 || selectedRows.length < 2) {
-    return { summary: "", sourceMessages: selectedRows.length, sourceChars };
+    return { summary: "", sourceMessages: selectedRows.length, sourceChars, topics: null };
   }
-
-  const transcript = selectedTranscript.join("\n\n").trim();
   if (!transcript) return null;
 
-  const provider = providerOverride?.provider ?? getProvider(modelCfg.provider);
-  const modelId = providerOverride?.modelId ?? modelCfg.model_id;
-  const summaryParams = providerParams.max_tokens
-    ? providerParams
-    : { ...providerParams, max_tokens: 1024 };
-
   const raw = (await summarizeTranscript(provider, modelId, summaryParams, transcript)).trim();
   if (!raw) return null;
   const { body, topics } = extractTopicSegments(raw);
@@ -542,7 +727,7 @@ async function buildAutomationChannelSummaryBefore(
     allowPartialStart: true,
   });
   const summary = validatedTopics.length > 0
-    ? renderTopicRecaps(validatedTopics)
+    ? renderTopicRecaps(validatedTopics.map((topic) => ({ ...topic, facts: [] })))
     : body;
   if (!summary) return null;
   const summarizedSeqs = new Set(validatedTopics.flatMap((topic) =>
@@ -556,13 +741,10 @@ async function buildAutomationChannelSummaryBefore(
   const summarizedChars = summarizedRows.reduce((total, row) => total + transcriptText(row.content).length, 0);
 
   return {
-    summary: [
-      `--- ${channel} activity summary ---`,
-      "Compressed recap of automation activity outside the hot window:",
-      summary,
-    ].join("\n"),
+    summary: wrapChannelSummary(channel, summary),
     sourceMessages: summarizedRows.length,
     sourceChars: summarizedChars,
+    topics: null,
   };
 }
 
@@ -586,6 +768,7 @@ export async function compactAutomationChannelWarmContext(
     summary: built.summary,
     summaryBefore: boundary,
     summaryBeforeSeq: boundarySeq,
+    topics: built.topics ? JSON.stringify(built.topics) : null,
   });
   return built;
 }