@circuitwall/jarela 2.2.1 → 2.3.0

package/components/chat/useThreadData.ts

@@ -1,8 +1,8 @@
 "use client";
 import { useCallback, useEffect, useRef, useState } from "react";
 import { api } from "@/api/client";
-import type { Message, SummaryTopicSegment } from "@/api/types";
-import { applyThreadMeta, type SystemNotice, type ThreadMetaApplier } from "./chat-helpers";
+import type { Message, SummaryTopicSegment, WarmChannelSummary } from "@/api/types";
+import { applyThreadMeta, type ThreadMetaApplier } from "./chat-helpers";
 
 interface Params {
   threadId: string | null;
@@ -13,9 +13,6 @@ export interface ThreadDataApi {
   messages: Message[];
   setMessages: React.Dispatch<React.SetStateAction<Message[]>>;
   messagesRef: React.MutableRefObject<Message[]>;
-  notices: SystemNotice[];
-  setNotices: React.Dispatch<React.SetStateAction<SystemNotice[]>>;
-  addNotice: (text: string) => void;
   hasMore: boolean;
   setHasMore: React.Dispatch<React.SetStateAction<boolean>>;
   loadingMore: boolean;
@@ -30,8 +27,10 @@ export interface ThreadDataApi {
   warmSummarySourceMessages: number | null;
   warmSummarySourceChars: number | null;
   warmSummaryTopics: SummaryTopicSegment[] | null;
+  warmChannelSummaries: WarmChannelSummary[];
   warmSummaryPending: boolean;
   compactionPending: boolean;
+  manualCompactionPending: boolean;
   contextWindowTokens: number | null;
   metaApplier: ThreadMetaApplier;
   loadOlder: () => Promise<void>;
@@ -40,7 +39,6 @@ export interface ThreadDataApi {
 
 export function useThreadData({ threadId, attach }: Params): ThreadDataApi {
   const [messages, setMessages] = useState<Message[]>([]);
-  const [notices, setNotices] = useState<SystemNotice[]>([]);
   const [hasMore, setHasMore] = useState(false);
   const [loadingMore, setLoadingMore] = useState(false);
   const [messagesLoading, setMessagesLoading] = useState(false);
@@ -54,8 +52,10 @@ export function useThreadData({ threadId, attach }: Params): ThreadDataApi {
   const [warmSummarySourceMessages, setWarmSummarySourceMessages] = useState<number | null>(null);
   const [warmSummarySourceChars, setWarmSummarySourceChars] = useState<number | null>(null);
   const [warmSummaryTopics, setWarmSummaryTopics] = useState<SummaryTopicSegment[] | null>(null);
+  const [warmChannelSummaries, setWarmChannelSummaries] = useState<WarmChannelSummary[]>([]);
   const [warmSummaryPending, setWarmSummaryPending] = useState(false);
   const [compactionPending, setCompactionPending] = useState(false);
+  const [manualCompactionPending, setManualCompactionPending] = useState(false);
   const [contextWindowTokens, setContextWindowTokens] = useState<number | null>(null);
 
   const messagesRef = useRef<Message[]>([]);
@@ -66,18 +66,13 @@ export function useThreadData({ threadId, attach }: Params): ThreadDataApi {
     setHotSince, setHotSinceSeq, setWarmSummary, setWarmSummaryBefore, setWarmSummaryBeforeSeq,
     setWarmSummaryComputedAt, setWarmSummarySourceMessages,
     setWarmSummarySourceChars, setContextWindowTokens, setWarmSummaryPending,
-    setCompactionPending, setWarmSummaryTopics,
+    setCompactionPending, setManualCompactionPending, setWarmSummaryTopics, setWarmChannelSummaries,
   };
 
-  const addNotice = useCallback((text: string) => {
-    setNotices((p) => [...p, { id: `notice-${Date.now()}`, text }]);
-  }, []);
-
   useEffect(() => {
     if (!threadId) {
       setMetadataThreadId(null);
       setMessages([]);
-      setNotices([]);
       setHasMore(false);
       setMessagesLoading(false);
       setHotSince(null);
@@ -89,8 +84,10 @@ export function useThreadData({ threadId, attach }: Params): ThreadDataApi {
       setWarmSummarySourceMessages(null);
       setWarmSummarySourceChars(null);
       setWarmSummaryTopics(null);
+      setWarmChannelSummaries([]);
       setWarmSummaryPending(false);
       setCompactionPending(false);
+      setManualCompactionPending(false);
       setContextWindowTokens(null);
       return;
     }
@@ -108,8 +105,10 @@ export function useThreadData({ threadId, attach }: Params): ThreadDataApi {
     setWarmSummarySourceMessages(null);
     setWarmSummarySourceChars(null);
     setWarmSummaryTopics(null);
+    setWarmChannelSummaries([]);
     setWarmSummaryPending(false);
     setCompactionPending(false);
+    setManualCompactionPending(false);
     setContextWindowTokens(null);
     api.threads.get(threadId).then((d) => {
       if (cancelled) return;
@@ -150,6 +149,7 @@ export function useThreadData({ threadId, attach }: Params): ThreadDataApi {
       setWarmSummarySourceMessages(updated.warm_summary_source_messages);
       setWarmSummarySourceChars(updated.warm_summary_source_chars);
       setWarmSummaryTopics(updated.warm_summary_topics);
+      setWarmChannelSummaries(updated.warm_channel_summaries ?? []);
       setCompactionPending(updated.pending_hot_since_seq != null);
       const summaryFresh = updated.hot_since_seq != null
         && updated.warm_summary_before_seq === updated.hot_since_seq;
@@ -167,7 +167,7 @@ export function useThreadData({ threadId, attach }: Params): ThreadDataApi {
     if (!threadId) return;
     const summaryFresh = hotSinceSeq !== null && warmSummaryBeforeSeq === hotSinceSeq;
     const summaryStale = warmSummaryPending && hotSinceSeq !== null && !summaryFresh;
-    if (!summaryStale && !compactionPending) {
+    if (!summaryStale && !compactionPending && !manualCompactionPending) {
       if (warmSummaryPending && hotSinceSeq !== null && summaryFresh) setWarmSummaryPending(false);
       return;
     }
@@ -190,7 +190,7 @@ export function useThreadData({ threadId, attach }: Params): ThreadDataApi {
       window.clearInterval(timer);
     };
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [threadId, warmSummaryPending, compactionPending, hotSince, hotSinceSeq, warmSummaryBefore, warmSummaryBeforeSeq]);
+  }, [threadId, warmSummaryPending, compactionPending, manualCompactionPending, hotSince, hotSinceSeq, warmSummaryBefore, warmSummaryBeforeSeq]);
 
   const loadOlder = useCallback(async () => {
     if (!threadId || loadingMore || !hasMore || messages.length === 0) return;
@@ -211,13 +211,13 @@ export function useThreadData({ threadId, attach }: Params): ThreadDataApi {
   }, [threadId, loadingMore, hasMore, messages.length]);
 
   return {
-    messages, setMessages, messagesRef, notices, setNotices, addNotice,
+    messages, setMessages, messagesRef,
     hasMore, setHasMore, loadingMore, messagesLoading,
     hotSince: metadataMatchesThread ? hotSince : null,
     hotSinceSeq: metadataMatchesThread ? hotSinceSeq : null,
     hotSinceSeqForRun: metadataMatchesThread ? hotSinceSeq : undefined,
     warmSummary, warmSummaryBefore, warmSummaryBeforeSeq, warmSummaryComputedAt,
-    warmSummarySourceMessages, warmSummarySourceChars, warmSummaryTopics, warmSummaryPending, compactionPending, contextWindowTokens,
+    warmSummarySourceMessages, warmSummarySourceChars, warmSummaryTopics, warmChannelSummaries, warmSummaryPending, compactionPending, manualCompactionPending, contextWindowTokens,
     metaApplier, loadOlder, setContextPin,
   };
 }

package/components/chat/workflow-step-retry.ts

@@ -0,0 +1,25 @@
+import { createContext, useContext } from "react";
+
+export interface WorkflowStepRetryRequest {
+  workflowId: string;
+  itemId: string;
+  label: string;
+}
+
+/** Sends a retry request for one workflow step; null when the surface cannot send messages. */
+export const WorkflowStepRetryContext = createContext<((request: WorkflowStepRetryRequest) => void) | null>(null);
+
+export function useWorkflowStepRetry() {
+  return useContext(WorkflowStepRetryContext);
+}
+
+export function workflowStepRetryMessage({ workflowId, itemId, label }: WorkflowStepRetryRequest): string {
+  const progressUpdate = workflowId === "version_adoption"
+    ? `Call \`workflow_progress\` with \`workflow_id: "version_adoption"\`, \`item_id: "${itemId}"\`, and \`status: "checking"\``
+    : `Call \`workflow_progress\` for workflow \`${workflowId}\` with the complete items snapshot, setting this step to \`checking\``;
+  return [
+    `Retry workflow step "${label}" (item \`${itemId}\`) in workflow \`${workflowId}\`.`,
+    `${progressUpdate}, then redo the step from its stated input and run its validation again.`,
+    "Finally mark it `done` with newly observed `validation_evidence`, or `needs_attention` with the reason. Leave the other steps unchanged.",
+  ].join(" ");
+}

package/components/ui/BootScreen.tsx

@@ -344,6 +344,20 @@ export function BootScreen({ agents, agentsLoaded, activeAgentId, onPickAgent, s
     }
   }
 
+  async function handleAdoptionItemRetry(itemId: string) {
+    if (adoptionBusy || adoption?.status === "running") return;
+    setAdoptionBusy("retry");
+    try {
+      const next = await api.lifecycle.adoption.retryItem(itemId);
+      setAdoption(next);
+      adoptionRunStartedRef.current = null;
+    } catch {
+      setAdoption((prev) => prev ? { ...prev, error: "Could not retry that step." } : prev);
+    } finally {
+      setAdoptionBusy(null);
+    }
+  }
+
   // The agent rendered in the centered tile. During `loading` and
   // `pick` it's the default (so the user sees the same artwork as soon
   // as agents resolve). During `opening` it's whatever was picked.
@@ -539,6 +553,9 @@ export function BootScreen({ agents, agentsLoaded, activeAgentId, onPickAgent, s
               summary={adoptionLiveLabel ?? adoption.summary}
               items={adoption.checklist}
               error={adoption.error}
+              onRetryItem={(item) => void handleAdoptionItemRetry(item.id)}
+              canRetryItem={(item) => item.id !== "fetch-changes"}
+              retryDisabled={adoptionBusy !== null || adoption.status === "running"}
             >
                 {adoption.status === "done" && (
                   <p className="mt-2 rounded-lg border border-border/50 bg-surface px-2 py-1 text-[10px] leading-snug text-fg-muted">

package/components/ui/WorkflowChecklist.tsx

@@ -1,4 +1,4 @@
-import { AlertTriangle, Check, LoaderCircle, Minus } from "lucide-react";
+import { AlertTriangle, Check, LoaderCircle, Minus, RotateCcw } from "lucide-react";
 import type { ReactNode } from "react";
 
 export type WorkflowChecklistStatus = "pending" | "checking" | "done" | "needs_attention" | "skipped";
@@ -12,6 +12,8 @@ export interface WorkflowChecklistItemView {
   output?: string;
   validation?: string;
   validation_evidence?: string;
+  /** Times this step has been started; shown when greater than one. */
+  attempts?: number;
 }
 
 interface Props {
@@ -22,9 +24,25 @@ interface Props {
   items: WorkflowChecklistItemView[];
   error?: string | null;
   compact?: boolean;
+  /** Retries a single finished or failed step; omitted hides the per-step retry button. */
+  onRetryItem?: (item: WorkflowChecklistItemView) => void;
+  canRetryItem?: (item: WorkflowChecklistItemView) => boolean;
+  retryDisabled?: boolean;
   children?: ReactNode;
 }
 
+const RETRYABLE_STATUSES: ReadonlySet<WorkflowChecklistStatus> = new Set(["done", "needs_attention", "skipped"]);
+
+export function isWorkflowItemRetryable(item: WorkflowChecklistItemView): boolean {
+  return RETRYABLE_STATUSES.has(item.status);
+}
+
+function statusLabel(status: WorkflowChecklistStatus): string {
+  if (status === "done") return "verified";
+  if (status === "needs_attention") return "needs attention";
+  return status;
+}
+
 function StatusIcon({ status }: { status: WorkflowChecklistStatus }) {
   if (status === "done") return <Check className="h-3 w-3" aria-hidden />;
   if (status === "checking") return <LoaderCircle className="h-3 w-3 animate-spin" aria-hidden />;
@@ -41,12 +59,19 @@ function statusClass(status: WorkflowChecklistStatus): string {
   return "border-border/60 bg-surface text-fg-faint";
 }
 
-export function WorkflowChecklist({ eyebrow, title, phaseLabel, summary, items, error, compact = false, children }: Props) {
+function itemTooltip(item: WorkflowChecklistItemView): string {
+  const note = item.status === "done" ? item.validation_evidence : item.reason;
+  return note ? `${item.label}\n${statusLabel(item.status)}: ${note}` : item.label;
+}
+
+export function WorkflowChecklist({ eyebrow, title, phaseLabel, summary, items, error, compact = false, onRetryItem, canRetryItem, retryDisabled = false, children }: Props) {
   return (
     <div className={compact ? "flex flex-col gap-1.5" : "absolute inset-x-0 top-0 flex flex-col gap-2 transition-opacity duration-300"}>
-      <p className="text-[10px] text-fg-faint uppercase tracking-wider text-center">
-        {eyebrow}
-      </p>
+      {!compact && (
+        <p className="text-[10px] text-fg-faint uppercase tracking-wider text-center">
+          {eyebrow}
+        </p>
+      )}
       <div className={compact
         ? "w-full rounded border border-border/40 bg-surface/60 px-2 py-1.5 text-left"
         : "w-full rounded-xl border border-border/60 bg-surface-2/70 px-3 py-2 text-left shadow-lg shadow-black/5"}>
@@ -56,39 +81,52 @@ export function WorkflowChecklist({ eyebrow, title, phaseLabel, summary, items,
             {phaseLabel}
           </span>
         </div>
-        <p className="mt-1 text-[11px] leading-snug text-fg-muted line-clamp-2">
-          {summary}
-        </p>
-        <div className={compact
-          ? "mt-1.5 flex max-h-32 flex-col gap-1 overflow-y-auto pr-1"
+        {!compact && summary && (
+          <p className="mt-1 text-[11px] leading-snug text-fg-muted line-clamp-2">
+            {summary}
+          </p>
+        )}
+        <ul className={compact
+          ? "mt-1.5 flex max-h-48 flex-col gap-0.5 overflow-y-auto pr-1"
           : "mt-2 flex max-h-32 flex-col gap-1 overflow-y-auto pr-1"}>
-          {items.map((item) => (
-            <div key={item.id} className={compact
-              ? "rounded border border-border/30 bg-surface-2/40 px-1.5 py-1 text-[10px] leading-tight text-fg-muted"
-              : "text-[10px] leading-tight text-fg-muted"}>
-              <div className="flex items-start gap-1.5">
+          {items.map((item) => {
+            const retryable = !!onRetryItem && isWorkflowItemRetryable(item) && (canRetryItem ? canRetryItem(item) : true);
+            return (
+              <li key={item.id} className="group flex items-center gap-1.5 text-[10px] leading-tight text-fg-muted">
                 <span
-                  aria-label={item.status}
-                  className={["mt-0.5 flex h-4 w-4 shrink-0 items-center justify-center rounded border", statusClass(item.status)].join(" ")}
+                  role="img"
+                  aria-label={statusLabel(item.status)}
+                  className={["flex h-4 w-4 shrink-0 items-center justify-center rounded border", statusClass(item.status)].join(" ")}
                 >
                   <StatusIcon status={item.status} />
                 </span>
-                <span className={compact ? "min-w-0 flex-1 truncate" : "line-clamp-2"} title={item.label}>{item.label}</span>
-              </div>
-              {(item.input || item.output || item.validation || item.validation_evidence) && (
-                <details className="mt-1 pl-5">
-                  <summary className="cursor-pointer text-fg-faint">Step contract</summary>
-                  <dl className="mt-1 grid grid-cols-[auto_minmax(0,1fr)] gap-x-2 gap-y-1">
-                    {item.input && <><dt className="text-fg-faint">Input</dt><dd className="break-words">{item.input}</dd></>}
-                    {item.output && <><dt className="text-fg-faint">Output</dt><dd className="break-words">{item.output}</dd></>}
-                    {item.validation && <><dt className="text-fg-faint">Validation</dt><dd className="break-words">{item.validation}</dd></>}
-                    {item.validation_evidence && <><dt className="text-fg-faint">Evidence</dt><dd className="break-words">{item.validation_evidence}</dd></>}
-                  </dl>
-                </details>
-              )}
-            </div>
-          ))}
-        </div>
+                <span className={compact ? "min-w-0 flex-1 truncate" : "min-w-0 flex-1 line-clamp-2"} title={itemTooltip(item)}>
+                  {item.label}
+                </span>
+                {(item.attempts ?? 0) > 1 && (
+                  <span className="shrink-0 text-[9px] tabular-nums text-fg-faint" title={`Attempt ${item.attempts}`}>
+                    attempt {item.attempts}
+                  </span>
+                )}
+                {retryable && (
+                  <button
+                    type="button"
+                    onClick={() => onRetryItem(item)}
+                    disabled={retryDisabled}
+                    aria-label={`Retry ${item.label}`}
+                    title={`Retry ${item.label}`}
+                    className={[
+                      "flex h-4 w-4 shrink-0 items-center justify-center rounded text-fg-faint hover:bg-surface-3 hover:text-fg disabled:opacity-40",
+                      item.status === "needs_attention" ? "" : "opacity-0 focus:opacity-100 group-hover:opacity-100",
+                    ].join(" ")}
+                  >
+                    <RotateCcw className="h-3 w-3" aria-hidden />
+                  </button>
+                )}
+              </li>
+            );
+          })}
+        </ul>
         {error && (
           <p className="mt-2 text-[10px] leading-tight text-red-400">{error}</p>
         )}

package/hooks/useSSE.ts

@@ -32,6 +32,10 @@ type UseSSECommands = {
   ) => Promise<{ accepted: boolean }>;
   stop: () => void;
   attach: (threadId: string) => Promise<void>;
+  /** True from the moment start()/attach() opens a stream until it settles. */
+  isLive: () => boolean;
+  /** Epoch ms when the last stream settled (0 if none yet). */
+  lastSettledAt: () => number;
   clearStreamingContent: () => void;
   clearToolEvents: () => void;
   // ADR-0080 — arm with the steering message's id before the PATCH so a
@@ -228,6 +232,18 @@ export function useSSE(onDone?: () => void): UnifiedHookResult<UseSSEState, UseS
   // Cleared on every new start()/attach().
   const [authError, setAuthError] = useState<AuthError>(null);
   const abortRef = useRef<AbortController | null>(null);
+  // Synchronous view of whether start()/attach() owns a live stream, and when
+  // the last one settled. React's `streaming` lags a render behind, so the
+  // activity poller reads this to avoid aborting a stream that just opened
+  // or re-attaching a run whose stream has only just ended.
+  const liveRef = useRef<{ busy: boolean; settledAt: number }>({ busy: false, settledAt: 0 });
+  const markLive = useCallback(() => { liveRef.current.busy = true; }, []);
+  const markSettled = useCallback((ctrl: AbortController | null) => {
+    if (ctrl && abortRef.current !== ctrl) return;
+    liveRef.current = { busy: false, settledAt: Date.now() };
+  }, []);
+  const isLive = useCallback(() => liveRef.current.busy, []);
+  const lastSettledAt = useCallback(() => liveRef.current.settledAt, []);
   const threadIdRef = useRef<string | null>(null);
   // ADR-0080 — id of the steering message currently armed for a possible
   // continuation break, or null. Set eagerly (before the steer PATCH
@@ -379,6 +395,7 @@ export function useSSE(onDone?: () => void): UnifiedHookResult<UseSSEState, UseS
     abortRef.current?.abort();
     const ctrl = new AbortController();
     abortRef.current = ctrl;
+    markLive();
     threadIdRef.current = threadId;
     resetBuffer();
     setStreaming(true);
@@ -424,8 +441,9 @@ export function useSSE(onDone?: () => void): UnifiedHookResult<UseSSEState, UseS
       // them.
       setStreaming(false);
       closeActivity();
+      markSettled(ctrl);
     }
-  }, [closeActivity, consume, openActivity, resetBuffer]);
+  }, [closeActivity, consume, markLive, markSettled, openActivity, resetBuffer]);
 
   // Stop the active run. Three-part: (1) tell the server to abort the
   // agent stream so the LangGraph loop unwinds; (2) tear down local
@@ -448,9 +466,10 @@ export function useSSE(onDone?: () => void): UnifiedHookResult<UseSSEState, UseS
     // start()/attach() — same pattern as the `done` branch in consume().
     closeActivity();
     abortRef.current?.abort();
+    markSettled(null);
     steeredContinuationIdRef.current = null;
     onDone?.();
-  }, [closeActivity, flushPending, onDone]);
+  }, [closeActivity, flushPending, markSettled, onDone]);
 
   // Attach to an in-flight run for the given thread (server-side run kept
   // going because the user switched away, or because this is a fresh
@@ -463,6 +482,7 @@ export function useSSE(onDone?: () => void): UnifiedHookResult<UseSSEState, UseS
     abortRef.current?.abort();
     const ctrl = new AbortController();
     abortRef.current = ctrl;
+    markLive();
     threadIdRef.current = threadId;
     resetBuffer();
     setStreaming(true);
@@ -491,8 +511,9 @@ export function useSSE(onDone?: () => void): UnifiedHookResult<UseSSEState, UseS
       // hangs in the composer and the "Reconnecting…" badge never clears.
       setStreaming(false);
       closeActivity();
+      markSettled(ctrl);
     }
-  }, [closeActivity, consume, onDone, openActivity, resetBuffer]);
+  }, [closeActivity, consume, markLive, markSettled, onDone, openActivity, resetBuffer]);
 
   // Called by the consumer after a refetch lands, so the streaming bubble
   // gets swapped for the persisted assistant message in a single render.
@@ -529,6 +550,8 @@ export function useSSE(onDone?: () => void): UnifiedHookResult<UseSSEState, UseS
     start,
     stop,
     attach,
+    isLive,
+    lastSettledAt,
     clearStreamingContent,
     clearToolEvents,
     armSteeredContinuation,
@@ -549,6 +572,8 @@ export function useSSE(onDone?: () => void): UnifiedHookResult<UseSSEState, UseS
     start,
     stop,
     attach,
+    isLive,
+    lastSettledAt,
     clearStreamingContent,
     clearToolEvents,
     armSteeredContinuation,

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

@@ -0,0 +1,202 @@
+import { describe, expect, it } from "vitest";
+import {
+  assembleFreshTopics,
+  buildTopicGroupingMessages,
+  buildTopicRecapMessages,
+  runCompactionPipeline,
+  validateTopicGroups,
+  validateTopicRecap,
+  type PipelineSourceRow,
+} from "./compaction-pipeline";
+import type { SummaryTopicSegment } from "./conversation-summary";
+import type { ProviderMessage } from "@/lib/providers/types";
+
+const row = (seq: number, role = seq % 2 === 0 ? "user" : "assistant", tool_events: string | null = null): PipelineSourceRow => ({
+  seq,
+  role,
+  content: `message ${seq}`,
+  created_at: `2026-10-09T10:00:${String(seq).padStart(2, "0")}.000Z`,
+  tool_events,
+});
+
+const prior: SummaryTopicSegment[] = [{
+  title: "Release plan",
+  start_seq: 1,
+  end_seq: 4,
+  start_at: "2026-10-09T09:00:00.000Z",
+  end_at: "2026-10-09T09:00:04.000Z",
+  recap: "Planned the 2.2.2 patch.",
+  facts: [{ subject: "Release cadence", content: "Patch releases ship weekly.", tags: [], confidence: "explicit", key: "facts/release-cadence", origin: "compaction" }],
+  message_count: 4,
+  source_chars: 40,
+}];
+
+const groups = (value: unknown) => JSON.stringify({ groups: value });
+
+function scriptedProvider(script: (messages: ProviderMessage[], call: number) => string) {
+  let call = 0;
+  const calls: ProviderMessage[][] = [];
+  return {
+    calls,
+    provider: {
+      chat: async (_model: string, messages: ProviderMessage[]) => {
+        calls.push(messages);
+        const text = script(messages, call++);
+        return { stream: (async function* () { yield text; })() };
+      },
+    } as never,
+  };
+}
+
+describe("source-aware prompts", () => {
+  const group = { title: "T", continues: null, seqs: [1, 2] };
+  const sources = ["chat", "scheduled_task", "watcher", "bridge"] as const;
+
+  it("describes each message stream differently in both steps", () => {
+    const firstLines = sources.map((source) => [
+      String(buildTopicGroupingMessages("x", [], source)[0].content).split("\n")[0],
+      String(buildTopicRecapMessages(group, null, "x", source)[0].content).split("\n")[0],
+    ]);
+    expect(new Set(firstLines.map(([grouping]) => grouping)).size).toBe(sources.length);
+    expect(new Set(firstLines.map(([, recap]) => recap)).size).toBe(sources.length);
+  });
+
+  it("asks only chat to extract facts; automation channels must return an empty list", () => {
+    for (const source of sources) {
+      const system = String(buildTopicRecapMessages(group, null, "x", source)[0].content);
+      expect(system.includes('"confidence"')).toBe(source === "chat");
+      expect(system.includes('Leave "facts" as []')).toBe(source !== "chat");
+      expect(system).toMatch(/\n1\. [\s\S]*\n2\. [\s\S]*\n3\. /);
+    }
+  });
+});
+
+describe("step 1 — validateTopicGroups", () => {
+  const rows = [10, 11, 12, 13, 14, 15].map((seq) => row(seq));
+
+  it("rejects seqs that were not supplied, overlaps and unknown topic ids, so the model retries", () => {
+    expect(validateTopicGroups("not json", rows, prior)).toMatchObject({ ok: false });
+    const bad = validateTopicGroups(groups([
+      { start_seq: 9, end_seq: 12, title: "a" },
+      { start_seq: 12, end_seq: 15, continues: "t7", title: "b" },
+    ]), rows, prior);
+    expect(bad.ok).toBe(false);
+    if (!bad.ok) {
+      expect(bad.errors.join(" ")).toContain("start_seq 9 is not a supplied message seq");
+      expect(bad.errors.join(" ")).toContain('continues "t7" is not an existing topic id');
+    }
+    const overlap = validateTopicGroups(groups([
+      { start_seq: 10, end_seq: 12, title: "a" },
+      { start_seq: 12, end_seq: 15, title: "b" },
+    ]), rows, prior);
+    expect(overlap.ok).toBe(false);
+  });
+
+  it("repairs gaps, single-message groups and duplicate continuations in code", () => {
+    const result = validateTopicGroups(groups([
+      { start_seq: 10, end_seq: 11, continues: "t1", title: "" },
+      { start_seq: 13, end_seq: 13, title: "stray" },
+      { start_seq: 14, end_seq: 15, continues: "t1", title: "Release plan again" },
+    ]), rows, prior);
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    // seq 12 was ungrouped and joined the first group; the stray single folds
+    // in; the second continuation of t1 coalesces into the first.
+    expect(result.value).toEqual([{ title: "Release plan", continues: "t1", seqs: [10, 11, 12, 13, 14, 15] }]);
+    expect(result.repairs?.length).toBeGreaterThan(0);
+  });
+});
+
+describe("step 2 — validateTopicRecap", () => {
+  const group = { title: "Topic", seqs: [10, 11] };
+
+  it("requires a non-empty recap and rejects a bare sentinel", () => {
+    expect(validateTopicRecap("NO_REPLY", group).ok).toBe(false);
+    expect(validateTopicRecap(JSON.stringify({ recap: "" }), group).ok).toBe(false);
+    expect(validateTopicRecap(JSON.stringify({ recap: "x".repeat(4_001) }), group).ok).toBe(false);
+  });
+
+  it("accepts fenced JSON, defaults the title and drops malformed facts", () => {
+    const result = validateTopicRecap("```json\n" + JSON.stringify({
+      recap: "Newest first.",
+      facts: [
+        { subject: "Pref", content: "Uses pnpm.", tags: ["tooling"], confidence: "explicit" },
+        { subject: "Bad", content: "no confidence" },
+      ],
+    }) + "\n```", group);
+    expect(result).toMatchObject({ ok: true, value: { title: "Topic", recap: "Newest first.", facts: [{ subject: "Pref" }] } });
+  });
+});
+
+describe("step 3 — assembleFreshTopics", () => {
+  it("fails when a supplied message lands in no topic", () => {
+    const rows = [row(10), row(11), row(12)];
+    const result = assembleFreshTopics([{ title: "a", seqs: [10, 11] }], [{ title: "a", recap: "r", facts: [] }], rows);
+    expect(result).toMatchObject({ ok: false, errors: ["seq 12 is in no topic."] });
+  });
+});
+
+describe("runCompactionPipeline", () => {
+  const saved = JSON.stringify([
+    { id: "c1", phase: "call", name: "memory_upsert", payload: { namespace: "facts", key: "deploy-target", record: { subject: "Deploy target", content: "Deploys go to staging first.", confidence: "explicit" } } },
+    { id: "c1", phase: "result", name: "memory_upsert", payload: { kwargs: { content: JSON.stringify({ ok: true, namespace: "facts", key: "deploy-target" }) } } },
+  ]);
+  const rows = [row(10), row(11, "assistant", saved), row(12), row(13)];
+
+  it("groups, recaps each topic, and merges into the stored topics newest last", async () => {
+    const { provider, calls } = scriptedProvider((messages) => {
+      const system = String(messages[0].content);
+      if (system.includes("step 1 of 3")) {
+        return groups([
+          { start_seq: 10, end_seq: 11, continues: "t1", title: "Release plan" },
+          { start_seq: 12, end_seq: 13, continues: null, title: "Deploy" },
+        ]);
+      }
+      return String(messages[1].content).includes("Topic: Release plan")
+        ? JSON.stringify({ title: "Release plan", recap: "Tagged 2.2.2. Earlier: planned the patch.", facts: [] })
+        : JSON.stringify({ title: "Deploy", recap: "Discussed deploy.", facts: [{ subject: "Region", content: "Deploy to eu-west.", tags: [], confidence: "explicit" }] });
+    });
+
+    const result = await runCompactionPipeline({ provider, modelId: "m", params: {}, rows, priorTopics: prior, messageLimit: 50 });
+
+    expect(calls).toHaveLength(3);
+    expect(result?.topics.map((topic) => [topic.title, topic.message_count])).toEqual([["Release plan", 6], ["Deploy", 2]]);
+    const continued = result!.topics[0];
+    expect(continued.start_seq).toBe(1);
+    expect(continued.end_seq).toBe(11);
+    expect(continued.recap).toBe("Tagged 2.2.2. Earlier: planned the patch.");
+    // Prior memorized items stay; agent-saved memory is attributed by code.
+    expect(continued.facts.map((fact) => fact.key)).toEqual(["facts/release-cadence", "facts/deploy-target"]);
+    expect(result!.topics[1].facts[0]).toMatchObject({ key: "facts/region", origin: "compaction" });
+    expect(result!.freshTopics.every((topic) => !("continues" in topic))).toBe(true);
+    expect(result!.sourceMessages).toBe(8);
+  });
+
+  it("retries a step with the validation errors, then succeeds", async () => {
+    const { provider, calls } = scriptedProvider((messages, call) => {
+      if (call === 0) return groups([{ start_seq: 99, end_seq: 13, title: "x" }]);
+      if (String(messages[0].content).includes("step 1 of 3")) return groups([{ start_seq: 10, end_seq: 13, title: "All" }]);
+      return JSON.stringify({ recap: "Everything.", facts: [] });
+    });
+    const result = await runCompactionPipeline({ provider, modelId: "m", params: {}, rows, priorTopics: [], messageLimit: 50 });
+    expect(result?.topics).toHaveLength(1);
+    const retry = calls[1];
+    expect(String(retry[retry.length - 1].content)).toContain("start_seq 99 is not a supplied message seq");
+  });
+
+  it("returns null after a step fails twice, so the caller falls back", async () => {
+    const { provider, calls } = scriptedProvider(() => "no json here");
+    const result = await runCompactionPipeline({ provider, modelId: "m", params: {}, rows, priorTopics: [], messageLimit: 50 });
+    expect(result).toBeNull();
+    expect(calls).toHaveLength(2);
+  });
+
+  it("evicts the oldest topics once the merged topics exceed the message limit", async () => {
+    const { provider } = scriptedProvider((messages) => String(messages[0].content).includes("step 1 of 3")
+      ? groups([{ start_seq: 10, end_seq: 13, title: "New" }])
+      : JSON.stringify({ recap: "New work.", facts: [] }));
+    const result = await runCompactionPipeline({ provider, modelId: "m", params: {}, rows, priorTopics: prior, messageLimit: 5 });
+    expect(result?.topics.map((topic) => topic.title)).toEqual(["New"]);
+    expect(result?.evicted).toBe(1);
+  });
+});