@circuitwall/jarela 2.2.0 → 2.3.0

package/lib/agents/run-thread.retry.test.ts

@@ -918,4 +918,70 @@ describe("prepareThreadRun transient retry", () => {
     expect(chunkTypes).toContain("text_delta");
     expect(collected.assistantContent).toBe("I patched the file to fix the bug.");
   });
-});
+
+  describe("workflow step contract auto-retry", () => {
+    const done = (id: string): StreamChunk => ({
+      type: "done",
+      data: { message_id: id, usage: { input_tokens: 1, output_tokens: 1, source: "estimate" }, provider: "openai", model_id: "gpt-4o-mini", model_config_name: "default" },
+    });
+    const step = (status: string, evidence?: string) => ({
+      id: "run-tests", label: "Run tests", input: "Diff", output: "Results", validation: "Run the suite", status,
+      ...(evidence ? { validation_evidence: evidence } : {}),
+    });
+    const rejectedTurn = (n: number) => chunks(
+      { type: "tool_call", data: { id: `wf-${n}`, name: "workflow_progress", arguments: { workflow_id: "release_check", items: [step("done")] } } },
+      { type: "tool_result", data: { id: `wf-${n}`, name: "workflow_progress", result: JSON.stringify({ ok: false, workflow_id: "release_check", error: "Every completed workflow item requires observed validation_evidence." }) } },
+      { type: "text_delta", data: { delta: `Turn ${n}.` } },
+      done(`done-wf-${n}`),
+    );
+    const setup = async (agentId: string) => {
+      upsertModelConfig("default", "openai", "gpt-4o-mini", { api_key: "sk-test" }, true);
+      upsertAgentConfig({ id: agentId, name: "Workflow Agent", identity: "helper", instructions: "Be helpful.", tools: ["workflow_progress"], model_config_name: null });
+      const thread = createThread(agentId);
+      return prepareThreadRun({
+        thread_id: thread.thread_id,
+        message: "Check the release",
+        context_profile: { include_hot: true, include_warm: false, include_facts: false, include_recall: false },
+      });
+    };
+    const lastUserText = (callIndex: number) => {
+      const messages = streamWithConfigMock.mock.calls[callIndex][1] as Array<{ role?: string; content?: unknown }>;
+      return JSON.stringify(messages[messages.length - 1]);
+    };
+
+    it("retries a step whose update was rejected and stops once the contract is met", async () => {
+      streamWithConfigMock
+        .mockImplementationOnce(() => rejectedTurn(1))
+        .mockImplementationOnce(() => chunks(
+          { type: "tool_call", data: { id: "wf-2", name: "workflow_progress", arguments: { workflow_id: "release_check", items: [step("done", "npm test: 120 passed")] } } },
+          { type: "tool_result", data: { id: "wf-2", name: "workflow_progress", result: JSON.stringify({ ok: true, workflow_id: "release_check", state: { phase: null, summary: "", error: null, checklist: [step("done", "npm test: 120 passed")] } }) } },
+          { type: "text_delta", data: { delta: "Verified." } },
+          done("done-wf-2"),
+        ));
+
+      const collected = await collectStream((await setup("agent-workflow-retry")).stream);
+
+      expect(collected.terminal).toBe("done");
+      expect(streamWithConfigMock).toHaveBeenCalledTimes(2);
+      expect(lastUserText(1)).toContain("attempt 2 of 3");
+      expect(lastUserText(1)).toContain("Run tests");
+      expect(collected.assistantContent).toContain("Turn 1.");
+      expect(collected.assistantContent).toContain("Verified.");
+    });
+
+    it("gives up after three attempts and tells the user the step still fails", async () => {
+      streamWithConfigMock
+        .mockImplementationOnce(() => rejectedTurn(1))
+        .mockImplementationOnce(() => rejectedTurn(2))
+        .mockImplementationOnce(() => rejectedTurn(3))
+        .mockImplementationOnce(() => rejectedTurn(4));
+
+      const collected = await collectStream((await setup("agent-workflow-retry-exhausted")).stream);
+
+      expect(collected.terminal).toBe("done");
+      expect(streamWithConfigMock).toHaveBeenCalledTimes(3);
+      expect(lastUserText(2)).toContain("attempt 3 of 3");
+      expect(collected.assistantContent).toContain("still failing the step contract after automatic retries");
+    });
+  });
+});

package/lib/agents/run-thread.ts

@@ -22,7 +22,15 @@ import { startScheduler } from "@/lib/scheduler";
 import { recall, type RecalledMemory } from "@/lib/embeddings";
 import { getMemoryPolicy } from "@/lib/stores/app-settings";
 import { validateAssistantOutput } from "@/lib/agents/output-validator";
-import { getDefaultModelConfig, getModelConfig, getModelParams, listModelConfigs } from "@/lib/stores/model-config";
+import {
+  buildWorkflowStepRetryNudge,
+  collectWorkflowContractFailures,
+  planWorkflowStepRetries,
+  WORKFLOW_TURN_AUTO_RETRY_LIMIT,
+  workflowProgressArgs,
+  type WorkflowProgressObservation,
+} from "@/lib/agents/workflow-step-retry";
+import { getDefaultModelConfig, getModelConfig, getModelParams, isModelConfigEnabled, listEnabledModelConfigs } from "@/lib/stores/model-config";
 import {
   buildHistoryWindow,
   buildSystemPrompt,
@@ -425,9 +433,11 @@ export function snapshotThreadModelConfigName(thread_id: string): string | null
   const agentCfg = getAgentConfig(thread.agent_id);
   if (!agentCfg) return null;
 
-  if (agentCfg.model_config_name) return agentCfg.model_config_name;
+  if (agentCfg.model_config_name && isModelConfigEnabled(getModelConfig(agentCfg.model_config_name))) {
+    return agentCfg.model_config_name;
+  }
   if (getConfig().modelRouterMode !== "off") return null;
-  return agentCfg.model_config_name ?? getDefaultModelConfig()?.name ?? null;
+  return getDefaultModelConfig()?.name ?? null;
 }
 
 export function appendHistoryMessage(
@@ -578,7 +588,9 @@ export async function prepareThreadRun(req: ThreadRunRequest): Promise<PreparedT
   let modelConfigName = req._pinned_model_config_name
     ?? agentCfg.model_config_name
     ?? null;
-  if (modelConfigName && !getModelConfig(modelConfigName)) {
+  // Missing or disabled configs fall through to routing / the default; a
+  // disabled agent override is kept so re-enabling the model restores it.
+  if (modelConfigName && !isModelConfigEnabled(getModelConfig(modelConfigName))) {
     modelConfigName = null;
   }
   let routeDecision: RouteDecisionMetadata | null = null;
@@ -607,13 +619,14 @@ export async function prepareThreadRun(req: ThreadRunRequest): Promise<PreparedT
   if (!modelConfigName && useRouter) {
     const pricingTables = getPricingTables();
     const routed = routeTurnModel({
-      models: listModelConfigs().map((cfg) => ({
+      models: listEnabledModelConfigs().map((cfg) => ({
         name: cfg.name,
         provider: cfg.provider,
         model_id: cfg.model_id,
         params: getModelParams(cfg),
         credential_id: cfg.credential_id ?? null,
         is_default: cfg.is_default === 1,
+        enabled: true,
         created_at: cfg.created_at,
         updated_at: cfg.updated_at,
       })),
@@ -1130,6 +1143,10 @@ async function* stallRetryStream(
   // turns where the model's claimed action didn't actually happen.
   const toolCallIds = new Map<string, string>();
   const failedProxyCallIds = new Set<string>();
+  // workflow_progress calls (direct or proxied) awaiting their result, so the
+  // step contract can be checked from observed tool output at turn end.
+  const pendingWorkflowArgs = new Map<string, Record<string, unknown>>();
+  const workflowObservations: WorkflowProgressObservation[] = [];
   let loopedToolName: string | null = null;
   let doneChunk: StreamChunk | null = null;
   let sawError = false;
@@ -1148,7 +1165,11 @@ async function* stallRetryStream(
       const name = unwrapInvokedToolName(rawName, args);
       if (name) {
         toolNames.push(name);
-        if (typeof data?.id === "string") toolCallIds.set(data.id, name);
+        if (typeof data?.id === "string") {
+          toolCallIds.set(data.id, name);
+          const workflowArgs = workflowProgressArgs(rawName, args);
+          if (workflowArgs) pendingWorkflowArgs.set(data.id, workflowArgs);
+        }
         const sig = toolCallSignature(rawName, args);
         const count = (signatureCounts.get(sig) ?? 0) + 1;
         signatureCounts.set(sig, count);
@@ -1178,6 +1199,10 @@ async function* stallRetryStream(
           failedProxyCallIds.add(data.id);
         }
       }
+      if (typeof data?.id === "string" && pendingWorkflowArgs.has(data.id)) {
+        workflowObservations.push({ args: pendingWorkflowArgs.get(data.id), result: data.result });
+        pendingWorkflowArgs.delete(data.id);
+      }
       const summary = summarizeRetryValue(data?.result).trim();
       if (summary) {
         const clipped = summary.length > 240 ? `${summary.slice(0, 237)}...` : summary;
@@ -1317,6 +1342,10 @@ async function* stallRetryStream(
   const citationFail = uncitedHighClaims.length > 0;
 
   if (!stalled && !looped && fabrication.ok && !citationFail) {
+    if (!sawError && workflowObservations.length > 0) {
+      yield* workflowStepRetryStream(workflowObservations, originalReq, retriesLeft, attemptAbort, doneChunk, textBuf, toolNames, toolResultSummaries);
+      return;
+    }
     if (doneChunk) yield doneChunk;
     return;
   }
@@ -1444,6 +1473,67 @@ async function* stallRetryStream(
   }
 }
 
+// Workflow step contract auto-retry. Runs only after every other quality
+// gate passed, and has its own per-step budget (WORKFLOW_STEP_MAX_ATTEMPTS)
+// so a stall retry earlier in the turn never starves it. The retry is an
+// append-mode continuation: the turn's work stays visible, followed by the
+// model redoing only the failed steps.
+async function* workflowStepRetryStream(
+  observations: readonly WorkflowProgressObservation[],
+  originalReq: ThreadRunRequest,
+  stallRetriesLeft: number,
+  attemptAbort: AbortController,
+  doneChunk: StreamChunk | null,
+  textBuf: string,
+  toolNames: readonly string[],
+  toolResultSummaries: readonly string[],
+): AsyncGenerator<StreamChunk> {
+  const spent = originalReq._workflow_step_retries ?? {};
+  const failures = collectWorkflowContractFailures(observations);
+  const { retry, exhausted } = planWorkflowStepRetries(failures, spent);
+  const spentTotal = Object.values(spent).reduce((sum, n) => sum + n, 0);
+
+  if (retry.length === 0 || spentTotal >= WORKFLOW_TURN_AUTO_RETRY_LIMIT) {
+    const unresolved = [...exhausted, ...retry];
+    if (unresolved.length > 0) {
+      console.warn(
+        `[workflow-retry] contract still failing after auto-retry: ${unresolved.map((f) => f.key).join(", ")} thread=${originalReq.thread_id}`,
+      );
+      yield {
+        type: "text_delta",
+        data: {
+          delta: `\n\n*⚠️ Workflow step${unresolved.length === 1 ? "" : "s"} still failing the step contract after automatic retries: ${unresolved.slice(0, 4).map((f) => `"${f.label}"`).join(", ")}. Use the step's retry button or review it manually.*`,
+        },
+      };
+    }
+    if (doneChunk) yield doneChunk;
+    return;
+  }
+
+  console.warn(
+    `[workflow-retry] retrying ${retry.map((f) => `${f.key}#${f.attempt}`).join(", ")} thread=${originalReq.thread_id}`,
+  );
+  yield { type: "text_delta", data: { delta: "\n\n↻ " } };
+  const nudge = buildWorkflowStepRetryNudge(retry);
+  const retryContext = buildRetryContextSummary(textBuf, [...toolNames], [...toolResultSummaries]);
+  const nudgeWithContext = retryContext ? `${nudge}\n\n${retryContext}` : nudge;
+  const nextSpent: Record<string, number> = { ...spent };
+  for (const failure of retry) nextSpent[failure.key] = (nextSpent[failure.key] ?? 0) + 1;
+
+  attemptAbort.abort("workflow_step_retry");
+  const next = await prepareThreadRun({
+    ...originalReq,
+    message: nudgeWithContext,
+    attachments: undefined,
+    _stall_retries_left: stallRetriesLeft,
+    _workflow_step_retries: nextSpent,
+    _retry_count: (originalReq._retry_count ?? 0) + 1,
+    _skip_persist_message: true,
+    _history_append_message: nudgeWithContext,
+  });
+  for await (const chunk of next.stream) yield chunk;
+}
+
 export interface AssistantUsageSnapshot {
   input_tokens: number;
   output_tokens: number;

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

@@ -0,0 +1,31 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { finishRun, startRun } from "./run-registry";
+import { __resetCompactionAttemptsForTests, runTrackedCompaction } from "./thread-compaction-state";
+import { getThreadActivity } from "./thread-activity";
+
+describe("getThreadActivity", () => {
+  afterEach(() => __resetCompactionAttemptsForTests());
+
+  it("is idle for a thread with nothing running", () => {
+    expect(getThreadActivity(`idle-${Date.now()}`)).toEqual({ run: null, queue_depth: 0, compaction: null, busy: false });
+  });
+
+  it("reports the live run phase and drops it once the run finishes", () => {
+    const tid = `run-${Date.now()}`;
+    const run = startRun(tid, "agent-1");
+    const live = getThreadActivity(tid);
+    expect(live.busy).toBe(true);
+    expect(live.run).toMatchObject({ phase: "starting", label: "Starting…", agent_id: "agent-1" });
+    finishRun(run, "done");
+    expect(getThreadActivity(tid).run).toBeNull();
+  });
+
+  it("reports a compaction with no run as busy", () => {
+    const tid = `compact-${Date.now()}`;
+    void runTrackedCompaction(tid, "auto", 7, () => new Promise<void>(() => {}), 60_000);
+    const snapshot = getThreadActivity(tid);
+    expect(snapshot.busy).toBe(true);
+    expect(snapshot.run).toBeNull();
+    expect(snapshot.compaction).toMatchObject({ kind: "auto", boundary_seq: 7 });
+  });
+});

package/lib/agents/thread-activity.ts

@@ -0,0 +1,27 @@
+import { getRun } from "@/lib/agents/run-registry";
+import { getQueueDepth } from "@/lib/agents/run-queue";
+import { currentCompaction, type CompactionKind } from "@/lib/agents/thread-compaction-state";
+
+/** What a thread is doing right now, as one snapshot the UI can poll. */
+export interface ThreadActivity {
+  /** The live agent turn, if one is running. */
+  run: { phase: string; label: string; started_at: number; agent_id: string | null } | null;
+  /** Turns held in the per-thread queue, including one about to start. */
+  queue_depth: number;
+  /** The most significant compaction running on the thread, if any. */
+  compaction: { kind: CompactionKind; boundary_seq: number | null; started_at: number; deadline_at: number } | null;
+  busy: boolean;
+}
+
+export function getThreadActivity(threadId: string): ThreadActivity {
+  const active = getRun(threadId);
+  const run = active && active.status === "running"
+    ? { phase: active.phase, label: active.phase_label, started_at: active.started_at, agent_id: active.agent_id }
+    : null;
+  const queue_depth = getQueueDepth(threadId);
+  const attempt = currentCompaction(threadId);
+  const compaction = attempt
+    ? { kind: attempt.kind, boundary_seq: attempt.boundarySeq, started_at: attempt.startedAt, deadline_at: attempt.deadlineAt }
+    : null;
+  return { run, queue_depth, compaction, busy: run !== null || queue_depth > 0 || compaction !== null };
+}

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

@@ -0,0 +1,82 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("@/lib/env/config", () => ({ getConfig: () => ({ compactionTimeoutMs: 60_000 }) }));
+
+import {
+  CompactionTimeoutError,
+  __resetCompactionAttemptsForTests,
+  currentCompaction,
+  getCompactionAttempt,
+  isCompactionRunning,
+  runTrackedCompaction,
+  type CompactionAttempt,
+} from "./thread-compaction-state";
+
+function deferred<T>() {
+  let resolve!: (v: T) => void;
+  const promise = new Promise<T>((r) => { resolve = r; });
+  return { promise, resolve };
+}
+
+describe("thread-compaction-state", () => {
+  beforeEach(() => __resetCompactionAttemptsForTests());
+  afterEach(() => vi.useRealTimers());
+
+  it("registers the attempt synchronously and releases it when it settles", async () => {
+    const gate = deferred<string>();
+    const run = runTrackedCompaction("t1", "manual", 5, () => gate.promise);
+    expect(isCompactionRunning("t1")).toBe(true);
+    expect(isCompactionRunning("t1", "manual")).toBe(true);
+    expect(getCompactionAttempt("t1", "manual")?.boundarySeq).toBe(5);
+    gate.resolve("ok");
+    await expect(run).resolves.toBe("ok");
+    expect(isCompactionRunning("t1")).toBe(false);
+  });
+
+  it("releases the attempt when the run throws", async () => {
+    await expect(runTrackedCompaction("t1", "auto", 1, async () => { throw new Error("boom"); })).rejects.toThrow("boom");
+    expect(isCompactionRunning("t1")).toBe(false);
+  });
+
+  it("times out, rejects, and stops the attempt from being current", async () => {
+    vi.useFakeTimers();
+    let seen: CompactionAttempt | null = null;
+    const run = runTrackedCompaction("t1", "refresh", null, (a) => { seen = a; return new Promise<void>(() => {}); }, 1_000);
+    const settled = expect(run).rejects.toBeInstanceOf(CompactionTimeoutError);
+    expect(seen!.isCurrent()).toBe(true);
+    await vi.advanceTimersByTimeAsync(1_000);
+    await settled;
+    expect(seen!.isCurrent()).toBe(false);
+    expect(isCompactionRunning("t1")).toBe(false);
+  });
+
+  it("reports the most significant compaction first", () => {
+    const hold = () => new Promise<void>(() => {});
+    void runTrackedCompaction("t1", "refresh", null, hold);
+    void runTrackedCompaction("t1", "auto", 3, hold);
+    expect(currentCompaction("t1")?.kind).toBe("auto");
+    void runTrackedCompaction("t1", "manual", 4, hold);
+    expect(currentCompaction("t1")?.kind).toBe("manual");
+    expect(currentCompaction("t2")).toBeNull();
+  });
+
+  it("invalidates an attempt replaced by a newer one of the same kind", async () => {
+    let first: CompactionAttempt | null = null;
+    const gate = deferred<void>();
+    const a = runTrackedCompaction("t1", "auto", 1, (att) => { first = att; return gate.promise; });
+    const b = runTrackedCompaction("t1", "auto", 2, () => new Promise<void>(() => {}));
+    expect(first!.isCurrent()).toBe(false);
+    gate.resolve();
+    await a;
+    // Settling the stale attempt must not release the newer one.
+    expect(getCompactionAttempt("t1", "auto")?.boundarySeq).toBe(2);
+    void b;
+  });
+
+  it("shares state across module instances", async () => {
+    void runTrackedCompaction("t1", "manual", 9, () => new Promise<void>(() => {}));
+    vi.resetModules();
+    const fresh = await import("./thread-compaction-state");
+    expect(fresh.isCompactionRunning("t1", "manual")).toBe(true);
+  });
+});

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

@@ -0,0 +1,121 @@
+import { getConfig } from "@/lib/env/config";
+import { getOrCreateGlobal } from "@/lib/utils/global-state";
+
+// Every compaction is bound to its thread: one attempt per kind per thread,
+// held in process-global state so each route bundle sees the same attempts
+// (the compact route and the thread GET route must agree on "compacting"),
+// and bounded by a deadline so a stalled provider can't leave a thread
+// "compacting" until the next restart.
+
+export type CompactionKind = "manual" | "auto" | "refresh";
+
+export interface CompactionAttempt {
+  readonly threadId: string;
+  readonly kind: CompactionKind;
+  readonly boundarySeq: number | null;
+  readonly startedAt: number;
+  readonly deadlineAt: number;
+  /** False once the attempt timed out or was replaced; it must not commit. */
+  isCurrent(): boolean;
+}
+
+export class CompactionTimeoutError extends Error {
+  constructor(threadId: string, kind: CompactionKind, timeoutMs: number) {
+    super(`${kind} compaction for thread ${threadId} timed out after ${timeoutMs} ms`);
+    this.name = "CompactionTimeoutError";
+  }
+}
+
+const attempts = getOrCreateGlobal(
+  "__jarela_thread_compaction_attempts",
+  () => new Map<string, Map<CompactionKind, CompactionAttempt>>(),
+);
+
+function slotFor(threadId: string): Map<CompactionKind, CompactionAttempt> {
+  let slot = attempts.get(threadId);
+  if (!slot) { slot = new Map(); attempts.set(threadId, slot); }
+  return slot;
+}
+
+function release(attempt: CompactionAttempt): void {
+  const slot = attempts.get(attempt.threadId);
+  if (slot?.get(attempt.kind) !== attempt) return;
+  slot.delete(attempt.kind);
+  if (slot.size === 0) attempts.delete(attempt.threadId);
+}
+
+export function getCompactionAttempt(threadId: string, kind: CompactionKind): CompactionAttempt | null {
+  return attempts.get(threadId)?.get(kind) ?? null;
+}
+
+export function isCompactionRunning(threadId: string, kind?: CompactionKind): boolean {
+  const slot = attempts.get(threadId);
+  if (!slot) return false;
+  return kind ? slot.has(kind) : slot.size > 0;
+}
+
+const KIND_PRIORITY: readonly CompactionKind[] = ["manual", "auto", "refresh"];
+
+/** The most significant compaction running on the thread, if any. */
+export function currentCompaction(threadId: string): CompactionAttempt | null {
+  const slot = attempts.get(threadId);
+  if (!slot) return null;
+  for (const kind of KIND_PRIORITY) {
+    const attempt = slot.get(kind);
+    if (attempt) return attempt;
+  }
+  return null;
+}
+
+/**
+ * Register a compaction on the thread synchronously, run it, and release it
+ * when it settles or its deadline passes. On timeout the attempt stops being
+ * current — pass it to compactThreadWarmContext so a late result is dropped
+ * instead of committed — and the promise rejects with CompactionTimeoutError.
+ * A newer attempt of the same kind replaces (and invalidates) an older one.
+ */
+export function runTrackedCompaction<T>(
+  threadId: string,
+  kind: CompactionKind,
+  boundarySeq: number | null,
+  run: (attempt: CompactionAttempt) => Promise<T>,
+  timeoutMs: number = getConfig().compactionTimeoutMs,
+): Promise<T> {
+  const startedAt = Date.now();
+  let current = true;
+  const attempt: CompactionAttempt = {
+    threadId,
+    kind,
+    boundarySeq,
+    startedAt,
+    deadlineAt: startedAt + timeoutMs,
+    isCurrent: () => current && attempts.get(threadId)?.get(kind) === attempt,
+  };
+  slotFor(threadId).set(kind, attempt);
+
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  const deadline = new Promise<never>((_, reject) => {
+    timer = setTimeout(() => {
+      current = false;
+      release(attempt);
+      reject(new CompactionTimeoutError(threadId, kind, timeoutMs));
+    }, timeoutMs);
+    (timer as { unref?: () => void }).unref?.();
+  });
+
+  let work: Promise<T>;
+  try {
+    work = run(attempt);
+  } catch (err) {
+    work = Promise.reject(err);
+  }
+  return Promise.race([work, deadline]).finally(() => {
+    if (timer) clearTimeout(timer);
+    current = false;
+    release(attempt);
+  });
+}
+
+export function __resetCompactionAttemptsForTests(): void {
+  attempts.clear();
+}

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;
+    }
+  });
+});