@circuitwall/jarela 2.3.0 → 2.4.0

package/lib/agents/proposals.test.ts

@@ -395,3 +395,79 @@ describe("applyAction(update_agent) instructions_append", () => {
     expect(String(result.detail)).toMatch(/one instructions mode only/);
   });
 });
+
+describe("applyAction(update_agent) edge cases", () => {
+  function seedTunedAgent(id: string) {
+    upsertAgentConfig({
+      id,
+      name: id,
+      identity: "test agent",
+      instructions: "be helpful",
+      tools: ["web_search"],
+      hot_turn_limit: 12,
+      adaptive_persona_enabled: true,
+      adaptive_mbti: "ENFP",
+      adaptive_persona_strength: 91,
+      adaptive_empathy: 7,
+      adaptive_expressiveness: 88,
+      adaptive_verbosity: 3,
+      never_reply: true,
+    });
+  }
+
+  it("applies hot_turn_limit, which the propose tool advertises", async () => {
+    seedTunedAgent("agent-hot-turns");
+    const result = await applyAction("update_agent", { agent_id: "agent-hot-turns", hot_turn_limit: 4 });
+    expect(result.ok).toBe(true);
+    expect(getAgentConfig("agent-hot-turns")!.hot_turn_limit).toBe(4);
+  });
+
+  it.each([
+    ["hot_turn_limit", -1],
+    ["hot_turn_limit", 2.5],
+    ["history_limit", 1.5],
+    ["history_limit", -5],
+    ["history_window_hours", -1],
+  ])("rejects %s=%s without writing", async (field, value) => {
+    seedTunedAgent(`agent-bad-${field}`);
+    const before = getAgentConfig(`agent-bad-${field}`)!;
+    const result = await applyAction("update_agent", { agent_id: `agent-bad-${field}`, [field]: value });
+    expect(result.ok).toBe(false);
+    expect(String(result.detail)).toContain(field);
+    expect(getAgentConfig(`agent-bad-${field}`)).toEqual(before);
+  });
+
+  it("keeps settings the proposal did not mention, including tuned persona sliders", async () => {
+    seedTunedAgent("agent-keep");
+    const before = getAgentConfig("agent-keep")!;
+    expect((await applyAction("update_agent", { agent_id: "agent-keep", identity: "renamed" })).ok).toBe(true);
+    const after = getAgentConfig("agent-keep")!;
+    expect(after.identity).toBe("renamed");
+    expect(after).toMatchObject({
+      adaptive_mbti: before.adaptive_mbti,
+      adaptive_persona_strength: 91,
+      adaptive_empathy: 7,
+      adaptive_expressiveness: 88,
+      adaptive_verbosity: 3,
+      never_reply: before.never_reply,
+      hot_turn_limit: 12,
+    });
+  });
+
+  it("keeps tuned persona sliders when only tools change", async () => {
+    seedTunedAgent("agent-keep-tools");
+    expect((await applyAction("update_agent_tools", { agent_id: "agent-keep-tools", tools: ["memory_write"] })).ok).toBe(true);
+    expect(getAgentConfig("agent-keep-tools")).toMatchObject({ adaptive_persona_strength: 91, adaptive_verbosity: 3 });
+  });
+
+  it("drops non-string tool names instead of storing them", async () => {
+    seedTunedAgent("agent-tool-junk");
+    const result = await applyAction("update_agent_tools", {
+      agent_id: "agent-tool-junk",
+      tools: ["memory_write", 42, null, "", " memory_write "],
+      mode: "replace",
+    });
+    expect(result.ok).toBe(true);
+    expect(JSON.parse(getAgentConfig("agent-tool-junk")!.tools)).toEqual(["memory_write"]);
+  });
+});

package/lib/agents/proposals.ts

@@ -130,9 +130,13 @@ function applyUpdateAgentTools(payload: unknown): ApplyResult {
   const before = getAgentTools(existing);
   const mode = p.mode ?? "add";
   if (mode !== "add" && mode !== "replace") return { ok: false, detail: "mode must be add or replace" };
+  const requested = (p.tools as unknown[])
+    .filter((tool): tool is string => typeof tool === "string")
+    .map((tool) => tool.trim())
+    .filter(Boolean);
   const nextTools = mode === "replace"
-    ? [...new Set(p.tools)]
-    : [...new Set([...before, ...p.tools])];
+    ? [...new Set(requested)]
+    : [...new Set([...before, ...requested])];
   upsertAgentConfig({
     id: existing.id,
     name: existing.name,
@@ -154,13 +158,16 @@ function applyUpdateAgent(payload: unknown): ApplyResult {
     instructions_edits?: unknown;
     history_limit?: number;
     history_window_hours?: number;
+    hot_turn_limit?: number;
     warm_summary_limit?: number;
     harness_id?: string | null;
   };
   if (!p.agent_id) return { ok: false, detail: "agent_id required" };
-  if (p.warm_summary_limit !== undefined
-    && (!Number.isInteger(p.warm_summary_limit) || p.warm_summary_limit < 0)) {
-    return { ok: false, detail: "warm_summary_limit must be a nonnegative integer" };
+  for (const field of ["warm_summary_limit", "hot_turn_limit", "history_limit", "history_window_hours"] as const) {
+    const value = p[field];
+    if (value !== undefined && (!Number.isInteger(value) || value < 0)) {
+      return { ok: false, detail: `${field} must be a nonnegative integer` };
+    }
   }
   const editModes = [
     p.instructions !== undefined,
@@ -209,6 +216,7 @@ function applyUpdateAgent(payload: unknown): ApplyResult {
     model_config_name: existing.model_config_name,
     history_limit: p.history_limit ?? existing.history_limit,
     history_window_hours: p.history_window_hours ?? existing.history_window_hours,
+    hot_turn_limit: p.hot_turn_limit,
     warm_summary_limit: p.warm_summary_limit ?? existing.warm_summary_limit,
     harness_id: p.harness_id,
   });

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

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

package/lib/agents/run-thread.ts

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

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

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

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

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