@circuitwall/jarela 2.2.1 → 2.4.0

package/app/api/v1/threads/[thread_id]/context-pin/route.ts

@@ -2,7 +2,7 @@ import { NextRequest, NextResponse } from "next/server";
 import { z } from "zod";
 import { getThread, getThreadMessageBySeq } from "@/lib/stores/threads";
 import { moveThreadContextBoundary } from "@/lib/agents/context-boundary";
-import { pendingCompactionBoundary, pendingCompactionBoundarySeq } from "@/lib/agents/warm-summary-background";
+import { currentChannelSummaries, pendingCompactionBoundary, pendingCompactionBoundarySeq } from "@/lib/agents/warm-summary-background";
 import { parseStoredTopics } from "@/lib/agents/conversation-summary";
 
 type Params = { params: Promise<{ thread_id: string }> };
@@ -43,6 +43,7 @@ export async function PATCH(req: NextRequest, { params }: Params) {
     warm_summary_source_messages: updated?.warm_summary_source_messages ?? null,
     warm_summary_source_chars: updated?.warm_summary_source_chars ?? null,
     warm_summary_topics: parseStoredTopics(updated?.warm_summary_topics),
+    warm_channel_summaries: currentChannelSummaries(thread_id, updated?.hot_since_seq),
     pending_hot_since: pendingCompactionBoundary(thread_id),
     pending_hot_since_seq: pendingCompactionBoundarySeq(thread_id),
   });

package/app/api/v1/threads/[thread_id]/route.ts

@@ -18,8 +18,9 @@ import { getMessageUsageByIds } from "@/lib/stores/message-usage";
 import { getAgentConfig } from "@/lib/stores/agent-configs";
 import { getModelConfig, getModelParams } from "@/lib/stores/model-config";
 import { messageToResponse, resolveContextWindowTokens } from "@/lib/api/serializers";
-import { pendingCompactionBoundary, pendingCompactionBoundarySeq } from "@/lib/agents/warm-summary-background";
+import { currentChannelSummaries, isManualCompactionRunning, pendingCompactionBoundary, pendingCompactionBoundarySeq } from "@/lib/agents/warm-summary-background";
 import { parseStoredTopics } from "@/lib/agents/conversation-summary";
+import { getThreadActivity } from "@/lib/agents/thread-activity";
 import { getCheckpointer } from "@/lib/agents/checkpointer";
 import { errorMessage } from "@/lib/utils/error";
 
@@ -84,9 +85,12 @@ export async function GET(req: NextRequest, { params }: Params) {
   return NextResponse.json({
     ...thread,
     warm_summary_topics: parseStoredTopics(thread.warm_summary_topics),
+    warm_channel_summaries: currentChannelSummaries(thread_id, thread.hot_since_seq),
     context_window_tokens: contextWindowTokens,
     pending_hot_since: pendingCompactionBoundary(thread_id),
     pending_hot_since_seq: pendingCompactionBoundarySeq(thread_id),
+    manual_compaction_pending: isManualCompactionRunning(thread_id),
+    activity: getThreadActivity(thread_id),
     // No server-side filtering: clients receive every message with its
     // `category` tag and apply the chat-panel filter toolbar on the
     // render side. Keeping the raw transcript over the wire means audit

package/app/api/v1/threads/[thread_id]/run/route.ts

@@ -189,7 +189,6 @@ export async function POST(req: NextRequest, { params }: Params) {
           _pinned_model_config_name: pinnedModelConfigName,
           _onCompacting: () => broadcast(active, { type: "status", data: { phase: "compacting", label: "Compacting earlier messages…" } }),
           _user_message_persisted: true,
-          _message_count_before_user: admittedTurn.messageCountBefore,
           _idle_ms_before_user: admittedTurn.idleMsBefore,
         });
         prepDurationMs = Date.now() - prepStartedAt;

package/components/chat/ChatView.tsx

@@ -6,15 +6,18 @@ import { useSSE } from "@/hooks/useSSE";
 import { useMessageFilters } from "@/hooks/useMessageFilters";
 import { useAppContext } from "@/contexts/AppContext";
 import { useTrackLoading, useActivityWhile } from "@/lib/ui/loading";
+import { pushToast } from "@/lib/ui/toasts";
+import { pushErrorToast } from "@/lib/ui/error-report";
 import { ApprovalsBanner } from "@/components/proposals/ApprovalsBanner";
 import { AuthErrorBanner } from "./AuthErrorBanner";
 import { InputBar } from "./InputBar";
 import { MessageList } from "./MessageList";
-import { applyThreadMeta, makeQueuedId, parseWarmSummaryTopics } from "./chat-helpers";
+import { applyThreadMeta, compactionOutcomeToast, makeQueuedId, parseWarmSummaryTopics, type CompactionOutcome } from "./chat-helpers";
 import { useChatErrorReporting } from "./useChatErrorReporting";
 import { useChatQueue, type ChatQueueApi } from "./useChatQueue";
 import { useThreadCrossDeviceSync } from "./useThreadCrossDeviceSync";
 import { useThreadData } from "./useThreadData";
+import { useThreadActivity } from "./useThreadActivity";
 import { useUserProfileAndAgent } from "./useUserProfileAndAgent";
 import { composerPlaceholder, finalizeRunFromServer } from "./chat-run-utils";
 import { useChatSubmitHandlers } from "./useChatSubmitHandlers";
@@ -84,11 +87,27 @@ export function ChatView({ threadId, agentId, sessionLoading, sessionError, onMe
   attachRef.current = sse.attach;
   clearStreamingRef.current = sse.clearStreamingContent;
   clearToolEventsRef.current = sse.clearToolEvents;
+  // `compacting` lives in this component, which remounts per agent; the
+  // server flag keeps a /compact started before an agent switch visible.
+  const sessionCompacting = compacting || thread.manualCompactionPending;
+
+  const activity = useThreadActivity({
+    threadId,
+    attach: stableAttach,
+    isLive: sse.isLive,
+    lastSettledAt: sse.lastSettledAt,
+    metaApplier: thread.metaApplier,
+  });
+  // Run phases come through the attached stream; background compaction
+  // outside a run has no stream, so label it from the polled activity.
+  const backgroundCompaction = !sse.streaming && !sessionCompacting ? activity?.compaction?.kind ?? null : null;
 
   useChatErrorReporting({ sessionError, streamError: sse.error, authError: sse.authError, agentId, threadId });
 
   const streamingRef = useRef(false);
   streamingRef.current = sse.streaming;
+  const currentThreadIdRef = useRef(threadId);
+  currentThreadIdRef.current = threadId;
 
   // Auto compaction starts server-side during a run; poll so the banner shows live.
   useEffect(() => {
@@ -117,11 +136,14 @@ export function ChatView({ threadId, agentId, sessionLoading, sessionError, onMe
 
   useTrackLoading(!!sessionLoading);
   useTrackLoading(sse.streaming);
-  useTrackLoading(compacting);
+  useTrackLoading(sessionCompacting);
   useTrackLoading(thread.loadingMore);
   useTrackLoading(thread.messagesLoading);
   useTrackLoading(agentConfigLoading);
 
+  useActivityWhile(sessionCompacting, "Compacting session…");
+  useActivityWhile(backgroundCompaction === "auto", "Compacting earlier messages…");
+  useActivityWhile(backgroundCompaction === "refresh", "Updating summary…");
   useActivityWhile(thread.messagesLoading, "Loading chat history…");
   useActivityWhile(agentConfigLoading, "Loading agent…");
   useActivityWhile(profileLoading, "Loading profile…");
@@ -197,16 +219,32 @@ export function ChatView({ threadId, agentId, sessionLoading, sessionError, onMe
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [threadId]);
 
-  const queue = useChatQueue({ threadId, streaming: sse.streaming, compacting, launchRun });
+  const queue = useChatQueue({ threadId, streaming: sse.streaming, compacting: sessionCompacting, launchRun });
   queueApiRef.current = queue;
   drainQueueRef.current = queue.drainQueueRef.current;
 
   async function handleCompact() {
     if (!agentId) return;
+    const notifyCompaction = (result: CompactionOutcome) => {
+      const toast = compactionOutcomeToast(result);
+      pushToast({
+        ...toast,
+        source: "system",
+        sourceLabel: "Chat",
+        agent_id: agentId,
+        thread_id: threadId,
+        ttl: 5000,
+        dedupeKey: `compact:${agentId}`,
+      });
+    };
     setCompacting(true);
     try {
       const result = await api.agents.compact(agentId, { resetContext: true });
-      if (result.compacted) {
+      // The thread may have changed while compaction ran; never apply its
+      // result to a different thread's view.
+      const compactedThreadId = threadId;
+      const stillCurrent = () => compactedThreadId !== null && currentThreadIdRef.current === compactedThreadId;
+      if (result.compacted && compactedThreadId !== null && stillCurrent()) {
         // Server moved the hot/warm pin to just after the last existing
         // message and persisted the warm summary. Mirror that in-place so
         // the warm card shows the fresh summary without wiping the visible
@@ -218,16 +256,19 @@ export function ChatView({ threadId, agentId, sessionLoading, sessionError, onMe
         thread.metaApplier.setWarmSummary(result.warm_summary ?? null);
         thread.metaApplier.setWarmSummaryBefore(result.warm_summary_before ?? null);
         thread.metaApplier.setWarmSummaryBeforeSeq(result.warm_summary_before_seq ?? null);
-        thread.metaApplier.setWarmSummaryBeforeSeq(result.warm_summary_before_seq ?? null);
         thread.metaApplier.setWarmSummaryComputedAt(result.warm_summary_computed_at ?? null);
         thread.metaApplier.setWarmSummarySourceMessages(result.warm_summary_source_messages ?? null);
         thread.metaApplier.setWarmSummarySourceChars(result.warm_summary_source_chars ?? null);
         thread.metaApplier.setWarmSummaryTopics?.(parseWarmSummaryTopics(result.warm_summary_topics));
-      } else {
-        thread.addNotice("Nothing to compact yet — send some messages first.");
+        // The compact response carries only the chat recap; channel recaps
+        // (bridge, watcher, scheduled task) come with the thread metadata.
+        void api.threads.get(compactedThreadId, { limit: 1 })
+          .then((d) => { if (stillCurrent()) applyThreadMeta(thread.metaApplier, d); })
+          .catch(() => { /* best-effort */ });
       }
+      notifyCompaction(result);
     } catch (err) {
-      thread.addNotice(`Compaction failed: ${String(err)}`);
+      pushErrorToast({ title: "Compaction failed", error: err, context: { panel: "chat", action: "compact", agent_id: agentId } });
     } finally {
       setCompacting(false);
       queue.drainQueueRef.current();
@@ -260,7 +301,6 @@ export function ChatView({ threadId, agentId, sessionLoading, sessionError, onMe
         threadId={threadId}
         messages={thread.messages}
         steeredSegments={sse.steeredSegments}
-        notices={thread.notices}
         agentConfig={agentConfig}
         userProfile={userProfile}
         // streamingContent stays visible past `streaming=false` so the bubble
@@ -287,8 +327,9 @@ export function ChatView({ threadId, agentId, sessionLoading, sessionError, onMe
         warmSummarySourceMessages={thread.warmSummarySourceMessages}
         warmSummarySourceChars={thread.warmSummarySourceChars}
         warmSummaryTopics={thread.warmSummaryTopics}
+        warmChannelSummaries={thread.warmChannelSummaries}
         warmSummaryPending={thread.warmSummaryPending}
-        compactionPending={thread.compactionPending || compacting}
+        compactionPending={thread.compactionPending || sessionCompacting}
         onSetContextPin={thread.setContextPin}
         streaming={sse.streaming}
         contextWindowTokens={thread.contextWindowTokens}
@@ -313,7 +354,7 @@ export function ChatView({ threadId, agentId, sessionLoading, sessionError, onMe
         onVoiceTranscript={handleVoiceTranscript}
         disabled={!agentId}
         placeholder={composerPlaceholder({
-          compacting,
+          compacting: sessionCompacting,
           sessionLoading: !!sessionLoading,
           streaming: sse.streaming,
         })}

package/components/chat/ContextBoundary.test.tsx

@@ -1,7 +1,7 @@
 // @vitest-environment jsdom
 import { describe, expect, it } from "vitest";
 import { fireEvent, render, screen } from "@testing-library/react";
-import { WarmSummaryCard } from "./ContextBoundary";
+import { topicsFromSummarySections, WarmSummaryCard } from "./ContextBoundary";
 import type { SummaryTopicSegment } from "@/api/types";
 
 const topics: SummaryTopicSegment[] = [
@@ -66,4 +66,71 @@ describe("WarmSummaryCard topic preview", () => {
     expect(screen.getByText("Flat prose fallback.")).toBeTruthy();
     expect(screen.queryByRole("button", { name: /Pricing extraction/ })).toBeNull();
   });
+
+  it("groups a sectioned summary without stored topics into collapsed topic rows", () => {
+    const legacy = [
+      "<!-- jarela:warm-scope=foreground -->",
+      "--- Warm context summary ---",
+      "Compressed recap of recent messages immediately before the hot window:",
+      "## Context",
+      "Weighing **three offers** against each other.",
+      "## User facts & preferences",
+      "- Will not relocate",
+      "- Wants numerical answers",
+    ].join("\n");
+    render(<WarmSummaryCard olderCount={46} summary={legacy} summaryBeforeSeq={10} hotSinceSeq={10} computedAt={null} streaming={false} topics={null} />);
+
+    expect(screen.queryByText(/jarela:warm-scope/)).toBeNull();
+    expect(screen.queryByText(/Warm context summary/)).toBeNull();
+    const context = screen.getByRole("button", { name: /^Context/ });
+    expect(context.getAttribute("aria-expanded")).toBe("false");
+    expect(screen.getByRole("button", { name: /User facts & preferences/ })).toBeTruthy();
+    expect(screen.getByText("three offers").tagName).toBe("STRONG");
+    expect(screen.queryByRole("button", { name: /Show more/ })).toBeNull();
+
+    fireEvent.click(screen.getByRole("button", { name: /User facts & preferences/ }));
+    expect(screen.getAllByText("Will not relocate")).toHaveLength(1);
+  });
+});
+
+describe("WarmSummaryCard automation-only boundary", () => {
+  const bridgeRecap = {
+    channel: "bridge",
+    summary: "<!-- jarela:warm-scope=bridge -->\nRelayed **deployment alerts** from the ops channel.",
+    computed_at: "2026-10-14T09:30:00.000Z",
+    topics: null,
+  };
+
+  it("shows the bridge recap instead of a never-arriving chat summary", () => {
+    render(<WarmSummaryCard olderCount={50} summary="" summaryBeforeSeq={10} hotSinceSeq={10} computedAt="2026-10-14T09:30:00.000Z" streaming={false} topics={null} channelSummaries={[bridgeRecap]} />);
+
+    expect(screen.getByText("Bridge")).toBeTruthy();
+    expect(screen.getByRole("button", { name: /Recap/ }).getAttribute("aria-expanded")).toBe("false");
+    expect(screen.getByText("deployment alerts").tagName).toBe("STRONG");
+    expect(screen.queryByText(/jarela:warm-scope/)).toBeNull();
+    expect(screen.queryByText(/Summary will appear/)).toBeNull();
+  });
+
+  it("says nothing needed summarising when the committed boundary has no recaps at all", () => {
+    render(<WarmSummaryCard olderCount={3} summary="" summaryBeforeSeq={10} hotSinceSeq={10} computedAt="2026-10-14T09:30:00.000Z" streaming={false} topics={null} />);
+    expect(screen.getByText("No earlier chat messages needed summarising.")).toBeTruthy();
+    expect(screen.queryByText(/Summary will appear/)).toBeNull();
+  });
+
+  it("keeps the placeholder while the boundary has no committed summary yet", () => {
+    render(<WarmSummaryCard olderCount={3} summary={null} summaryBeforeSeq={null} hotSinceSeq={10} computedAt={null} streaming={false} topics={null} />);
+    expect(screen.getByText("Summary will appear after your next reply.")).toBeTruthy();
+  });
+});
+
+describe("topicsFromSummarySections", () => {
+  it("keeps unstructured or single-section summaries as prose", () => {
+    expect(topicsFromSummarySections("Just a short recap.")).toBeNull();
+    expect(topicsFromSummarySections("## Only\nOne section.")).toBeNull();
+  });
+
+  it("keeps intro text before the first heading as an overview section", () => {
+    const sections = topicsFromSummarySections("Intro line.\n## Decisions\n- Chose A");
+    expect(sections?.map((s) => [s.title, s.recap])).toEqual([["Overview", "Intro line."], ["Decisions", "- Chose A"]]);
+  });
 });

package/components/chat/ContextBoundary.tsx

@@ -11,7 +11,7 @@ import ReactMarkdown from "react-markdown";
 import { StatusDot } from "@/components/ui/StatusDot";
 import { MetaRow } from "@/components/ui/MetaRow";
 import { CollapseChevron } from "@/components/ui/CollapseChevron";
-import type { SummaryTopicSegment } from "@/api/types";
+import type { SummaryTopicSegment, WarmChannelSummary } from "@/api/types";
 
 interface WarmSummaryCardProps {
   /** Number of messages older than the boundary that the summary covers. */
@@ -26,8 +26,16 @@ interface WarmSummaryCardProps {
   streaming: boolean;
   /** Per-topic segmentation of the same warm range, if the summarizer returned one. */
   topics?: SummaryTopicSegment[] | null;
+  /** Automation-channel recaps (bridge, watcher, scheduled task) at this boundary. */
+  channelSummaries?: WarmChannelSummary[];
 }
 
+const CHANNEL_LABELS: Record<string, string> = {
+  bridge: "Bridge",
+  watcher: "Watchers",
+  scheduled_task: "Scheduled tasks",
+};
+
 export function WarmSummaryCard({
   olderCount,
   summary,
@@ -36,19 +44,25 @@ export function WarmSummaryCard({
   computedAt,
   streaming,
   topics,
+  channelSummaries = [],
 }: WarmSummaryCardProps) {
   const [expanded, setExpanded] = useState(false);
-  const fresh = !!summary && hotSinceSeq != null && summaryBeforeSeq === hotSinceSeq;
+  const committed = hotSinceSeq != null && summaryBeforeSeq === hotSinceSeq;
+  const fresh = !!summary && committed;
   const stale = !!summary && !fresh;
   const computing = stale && streaming;
-  const summaryTopics = summary && topics && topics.length > 0 ? topics : null;
+  // Summaries stored before topic segmentation still read as topics: their
+  // markdown sections render through the same collapsible rows.
+  const summaryTopics = summary
+    ? (topics && topics.length > 0 ? topics : topicsFromSummarySections(summary))
+    : null;
 
   return (
     <div
       className={[
         "relative my-4 rounded-2xl border bg-gradient-to-br shadow-sm",
         "from-accent/[0.06] via-surface-2 to-surface-2",
-        fresh ? "border-accent/30" : "border-border",
+        fresh || committed ? "border-accent/30" : "border-border",
       ].join(" ")}
     >
       <div className="flex items-center gap-2 px-4 pt-3 pb-1.5">
@@ -82,6 +96,10 @@ export function WarmSummaryCard({
           >
             <ReactMarkdown>{stripWarmHeader(summary!)}</ReactMarkdown>
           </div>
+        ) : !summary && committed ? (
+          channelSummaries.length === 0 && (
+            <div className="text-xs text-fg-faint italic">No earlier chat messages needed summarising.</div>
+          )
         ) : !summary ? (
           <div className="flex items-center gap-2 text-xs text-fg-faint italic">
             {computing && (
@@ -95,6 +113,10 @@ export function WarmSummaryCard({
           </div>
         ) : null}
 
+        {channelSummaries.map((channel) => (
+          <ChannelSummarySection key={channel.channel} channel={channel} />
+        ))}
+
         {stale && (
           <div className="mt-2 inline-flex items-center gap-2 text-[11px] text-fg-faint">
             {computing ? <StatusDot tone="accent" size="sm" pulse /> : <StatusDot tone="neutral" size="sm" />}
@@ -121,6 +143,25 @@ export function WarmSummaryCard({
   );
 }
 
+function ChannelSummarySection({ channel }: { channel: WarmChannelSummary }) {
+  const topics = channel.topics && channel.topics.length > 0
+    ? channel.topics
+    : topicsFromSummarySections(channel.summary)
+      ?? [{ title: "Recap", start_at: "", end_at: "", recap: stripWarmHeader(channel.summary), facts: [] }];
+  return (
+    <div className="mt-2">
+      <div className="mb-1 text-[9px] uppercase tracking-wide text-fg-faint">
+        {CHANNEL_LABELS[channel.channel] ?? channel.channel}
+      </div>
+      <div className="flex flex-col gap-1">
+        {topics.map((topic, i) => (
+          <TopicSegmentRow key={`${channel.channel}-${topic.title}-${i}`} topic={topic} />
+        ))}
+      </div>
+    </div>
+  );
+}
+
 function TopicSegmentRow({ topic }: { topic: SummaryTopicSegment }) {
   const [open, setOpen] = useState(false);
   const range = formatTopicRange(topic.start_at, topic.end_at);
@@ -130,9 +171,14 @@ function TopicSegmentRow({ topic }: { topic: SummaryTopicSegment }) {
         <CollapseChevron open={open} size={9} />
         <span className="font-medium text-fg-muted truncate">{topic.title}</span>
         {range && <span className="text-fg-faint shrink-0">· {range}</span>}
+        {typeof topic.message_count === "number" && topic.message_count > 0 && (
+          <span className="text-fg-faint shrink-0">
+            · {topic.message_count} {topic.message_count === 1 ? "msg" : "msgs"}
+          </span>
+        )}
         {topic.facts.length > 0 && (
           <span className="ml-auto shrink-0 text-[9px] uppercase tracking-wide text-accent">
-            {topic.facts.length} {topic.facts.length === 1 ? "fact" : "facts"} saved
+            {topic.facts.length} memorized
           </span>
         )}
       </MetaRow>
@@ -149,13 +195,17 @@ function TopicSegmentRow({ topic }: { topic: SummaryTopicSegment }) {
             </div>
           )}
           {topic.facts.length > 0 && (
-            <ul className="space-y-0.5">
-              {topic.facts.map((fact, i) => (
-                <li key={`${fact.subject}-${i}`} className="text-[11px] text-fg-faint">
-                  <span className="font-medium text-fg-muted">{fact.subject}:</span> {fact.content}
-                </li>
-              ))}
-            </ul>
+            <div>
+              <div className="text-[9px] uppercase tracking-wide text-fg-faint">Memorized</div>
+              <ul className="space-y-0.5">
+                {topic.facts.map((fact, i) => (
+                  <li key={`${fact.key ?? fact.subject}-${i}`} className="text-[11px] text-fg-faint">
+                    <span className="font-medium text-fg-muted">{fact.subject}:</span> {fact.content}
+                    {fact.key && <code className="ml-1 text-[10px] text-fg-faint">{fact.key}</code>}
+                  </li>
+                ))}
+              </ul>
+            </div>
           )}
         </div>
       )}
@@ -313,11 +363,40 @@ function formatBytes(n: number): string {
 // awkwardly inside a card that already has its own header. Strip them.
 function stripWarmHeader(raw: string): string {
   return raw
+    .replace(/\r\n/g, "\n")
+    .replace(/^\s*(<!--[\s\S]*?-->\s*)+/, "")
     .replace(/^--- Warm context summary ---\n/, "")
-    .replace(/^Compressed recap of earlier messages outside the hot window:\n/, "")
+    .replace(/^Compressed recap of [^\n]*:\n/, "")
     .trimStart();
 }
 
+/**
+ * Splits a markdown summary into topic segments at its headings. Returns
+ * null when there are fewer than two sections, so short or unstructured
+ * summaries keep the plain prose rendering.
+ */
+export function topicsFromSummarySections(raw: string): SummaryTopicSegment[] | null {
+  const sections: SummaryTopicSegment[] = [];
+  let title: string | null = null;
+  let body: string[] = [];
+  const flush = () => {
+    const recap = body.join("\n").trim();
+    if (title !== null || recap) sections.push({ title: title ?? "Overview", start_at: "", end_at: "", recap, facts: [] });
+  };
+  for (const line of stripWarmHeader(raw).split("\n")) {
+    const heading = /^#{1,3}\s+(.+?)\s*#*\s*$/.exec(line);
+    if (heading) {
+      flush();
+      title = heading[1];
+      body = [];
+    } else {
+      body.push(line);
+    }
+  }
+  flush();
+  return sections.length >= 2 ? sections : null;
+}
+
 function summaryLong(raw: string): boolean {
   // Heuristic: more than 6 lines or > 600 chars after the header strip.
   const stripped = stripWarmHeader(raw);

package/components/chat/MessageBubble.tsx

@@ -849,6 +849,18 @@ function BridgeMessageCard({ ctx, activity }: {
           {activity.occurrence_count > 1 ? ` · ${activity.occurrence_count} checks` : ""}
         </span>
       ) : null}
+      {ctx.chatLink ? (
+        <a
+          href={ctx.chatLink}
+          target="_blank"
+          rel="noopener noreferrer"
+          className="inline-flex items-center gap-1 px-1.5 py-0.5 rounded-full bg-white/15 hover:bg-white/25 text-[9.5px] shrink-0"
+          title={`Open this chat (${ctx.chatLink})`}
+        >
+          <ExternalLink size={9} />
+          open chat
+        </a>
+      ) : null}
     </>
   );
   const sections: Array<{ label: string; content: ReactNode; defaultOpen?: boolean; hint?: string }> = [

package/components/chat/MessageList.test.tsx

@@ -584,4 +584,35 @@ describe("MessageList conversation focus", () => {
     fireEvent.click(enabledButton);
     expect(scrollIntoView).toHaveBeenCalled();
   });
+
+  it("keeps a near-bottom boundary locate from snapping back to the bottom", () => {
+    const messages = [
+      mkMessage("m1", "user", "older", "2026-08-09T10:00:00.000Z"),
+      mkMessage("m2", "assistant", "newer", "2026-08-09T10:00:01.000Z"),
+      mkMessage("m3", "assistant", "latest", "2026-08-09T10:00:02.000Z"),
+    ];
+    const props = { threadId: "thread-1", onSetContextPin: vi.fn(), hotSinceSeq: 2 };
+    const { container, rerender } = render(<MessageList {...props} messages={messages} />);
+
+    const scroller = container.querySelector(".panel-scrollbar") as HTMLDivElement;
+    Object.defineProperty(scroller, "scrollHeight", { configurable: true, value: 2000 });
+    Object.defineProperty(scroller, "clientHeight", { configurable: true, value: 500 });
+    Object.defineProperty(scroller, "scrollTop", { configurable: true, writable: true, value: 1500 });
+    fireEvent.scroll(scroller);
+
+    // Simulate the first smooth-scroll frame: still within 100px of the bottom.
+    const boundaryEl = document.querySelector("[data-focus-boundary='1']") as HTMLElement;
+    boundaryEl.scrollIntoView = vi.fn(() => {
+      scroller.scrollTop = 1450;
+      fireEvent.scroll(scroller);
+    });
+
+    fireEvent.click(screen.getByRole("button", { name: /filters & focus/i }));
+    fireEvent.click(screen.getByRole("button", { name: "Locate boundary line" }));
+    expect(boundaryEl.scrollIntoView).toHaveBeenCalledWith({ behavior: "smooth", block: "center" });
+    expect(boundaryEl.classList.contains("jarela-deep-link-flash")).toBe(true);
+
+    rerender(<MessageList {...props} messages={[...messages]} />);
+    expect(scroller.scrollTop).toBe(1450);
+  });
 });