@saadnvd1/agent-os 0.3.501 → 0.3.502

package/README.md

@@ -339,6 +339,13 @@ shows one quiet line with the context before and after. An orchestrator
 isn't compacted (a summary would lose the fence around what it read from
 tasks and CI): it starts a fresh conversation from its brief and the current
 state at its fresh-start threshold, or earlier once idle past its cache.
+While a chat compacts (any trigger, Claude, Pi or Codex) it is shown as
+compacting, not just working: a pulsing blue dot and a "Compacting" chip in
+the sidebar, and "Compacting context… 182k tokens" above the composer. The
+status API (`/api/sessions/status`) keeps `status: "running"` and adds
+`compacting: { since, before? }`; the orchestrator's `sessions` tool says
+"compacting context". It clears when the compaction ends, errors, is
+stopped, or the worker goes away.
 What survives a compaction: the summary is asked to keep the task, scope
 changes, every edited file by path, what's done, in progress and next, and
 the decisions. Right after it, AgentOS hands back a note built from its own

package/components/Chat/Activity.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest";
+import { currentActivity } from "./Activity";
+
+describe("currentActivity while compacting", () => {
+  it("says so, with the size going in and when it began", () => {
+    expect(
+      currentActivity([], "running", { since: 5, before: 182_000 })
+    ).toEqual({
+      label: "Compacting context… 182k tokens",
+      since: 5,
+      compacting: true,
+    });
+    expect(currentActivity([], "running", { since: 5 })?.label).toBe(
+      "Compacting context…"
+    );
+  });
+
+  it("is plain work without it, and nothing once the turn is over", () => {
+    expect(currentActivity([], "running")?.compacting).toBeUndefined();
+    expect(currentActivity([], "idle", { since: 5 })).toBeNull();
+  });
+});

package/components/Chat/Activity.tsx

@@ -1,7 +1,8 @@
 "use client";
 
-import { Loader2, MessageCircleQuestion, Square } from "lucide-react";
-import type { ChatItem, ChatState } from "@/lib/chat/events";
+import { Loader2, MessageCircleQuestion, Shrink, Square } from "lucide-react";
+import type { ChatItem, ChatState, Compacting } from "@/lib/chat/events";
+import { formatTokens } from "@/lib/chat/context";
 import { formatElapsed } from "@/lib/chat/elapsed";
 import { useNow } from "./useNow";
 
@@ -11,10 +12,17 @@ type Tool = Extract<ChatItem, { kind: "tool" }>;
 // running step, else whether it's writing or thinking.
 export function currentActivity(
   items: ChatItem[],
-  state: ChatState
-): { label: string; since?: number } | null {
+  state: ChatState,
+  compacting: Compacting | null = null
+): { label: string; since?: number; compacting?: boolean } | null {
   if (state === "waiting") return { label: "Waiting for your answer" };
   if (state !== "running") return null;
+  if (compacting)
+    return {
+      label: `Compacting context…${compacting.before ? ` ${formatTokens(compacting.before)} tokens` : ""}`,
+      since: compacting.since,
+      compacting: true,
+    };
   const lastUser = items.findLast((i) => i.kind === "user");
   const tool = items.findLast(
     (i): i is Tool => i.kind === "tool" && i.status === "running"
@@ -39,13 +47,15 @@ export function currentActivity(
 export function ActivityLine({
   items,
   state,
+  compacting = null,
   onStop,
 }: {
   items: ChatItem[];
   state: ChatState;
+  compacting?: Compacting | null;
   onStop: () => void;
 }) {
-  const activity = currentActivity(items, state);
+  const activity = currentActivity(items, state, compacting);
   const now = useNow(!!activity?.since);
   if (!activity) return null;
   const waiting = state === "waiting";
@@ -53,6 +63,8 @@ export function ActivityLine({
     <div className="text-muted-foreground flex min-h-9 items-center gap-2 px-2 text-xs">
       {waiting ? (
         <MessageCircleQuestion className="text-primary h-3.5 w-3.5 shrink-0" />
+      ) : activity.compacting ? (
+        <Shrink className="h-3.5 w-3.5 shrink-0 animate-pulse text-blue-600 dark:text-blue-400" />
       ) : (
         <Loader2 className="text-primary h-3.5 w-3.5 shrink-0 animate-spin" />
       )}

package/components/Chat/ChatPanel.tsx

@@ -263,6 +263,7 @@ export function ChatPanel({
     suggestion,
     requestFiles,
     search,
+    compacting,
   } = useChat(sessionId, (text) => setPrefill({ text, at: Date.now() }));
   const startFresh = useFreshStart();
   const { isMobile } = useViewport();
@@ -542,7 +543,12 @@ export function ChatPanel({
         )}
       </div>
       <div className="mx-auto w-full max-w-3xl px-3 pb-3">
-        <ActivityLine items={items} state={state} onStop={interrupt} />
+        <ActivityLine
+          items={items}
+          state={state}
+          compacting={compacting}
+          onStop={interrupt}
+        />
         <BackgroundTasks
           items={tasks}
           outputs={taskOutputs}

package/components/SessionList/RowParts.tsx

@@ -4,7 +4,8 @@ import { useEffect, useRef, useState } from "react";
 import { NEED_LABEL, type SidebarRow } from "@/lib/sidebar/shelves";
 import { cn } from "@/lib/utils";
 
-// Amber when it needs you, red when it failed, green while it works.
+// Amber when it needs you, red when it failed, green while it works, and a
+// pulsing blue while it summarises its context.
 export function RowDot({ row }: { row: SidebarRow }) {
   return (
     <span
@@ -15,9 +16,11 @@ export function RowDot({ row }: { row: SidebarRow }) {
           ? "bg-red-500"
           : row.need
             ? "bg-amber-500"
-            : row.working
-              ? "bg-green-500 ring-[3px] ring-green-500/25"
-              : "bg-muted-foreground/35"
+            : row.compacting
+              ? "animate-pulse bg-blue-500 ring-[3px] ring-blue-500/25"
+              : row.working
+                ? "bg-green-500 ring-[3px] ring-green-500/25"
+                : "bg-muted-foreground/35"
       )}
     />
   );
@@ -41,6 +44,12 @@ export function RowBadge({ row }: { row: SidebarRow }) {
       </span>
     );
   }
+  if (row.compacting)
+    return (
+      <span className="rounded-md bg-blue-500/15 px-1.5 py-0.5 text-[11px] font-semibold text-blue-700 dark:text-blue-400">
+        Compacting
+      </span>
+    );
   if (row.status?.stalled)
     return (
       <span className="rounded-md bg-amber-500/15 px-1.5 py-0.5 text-[11px] font-semibold text-amber-700 dark:text-amber-400">

package/components/SessionList/SessionList.types.ts

@@ -10,6 +10,7 @@ export interface SessionStatus {
   need?: SessionNeed | null;
   unread?: boolean;
   stalled?: boolean;
+  compacting?: { since: number; before?: number };
 }
 
 export interface SessionListProps {

package/components/views/types.ts

@@ -13,6 +13,8 @@ export interface SessionStatus {
   asks?: number;
   need?: SessionNeed | null;
   unread?: boolean;
+  // A chat summarising its context; status stays "running".
+  compacting?: { since: number; before?: number };
   claudeSessionId?: string | null;
   // From a program's OSC 7501 report: untrusted, rendered as plain text.
   detail?: string | null;

package/data/chat/useChat.ts

@@ -13,6 +13,7 @@ import type {
   ChatModel,
   ChatServerMessage,
   ChatState,
+  Compacting,
   FileSuggestion,
   QueuedMessage,
   ToolBody,
@@ -138,6 +139,7 @@ export function useChat(
     return () => void visibleBodies.current.delete(id);
   }, []);
   const [state, setState] = useState<ChatState>("idle");
+  const [compacting, setCompacting] = useState<Compacting | null>(null);
   const [connected, setConnected] = useState(false);
   const [commands, setCommands] = useState<ChatCommand[]>([]);
   const [models, setModels] = useState<ChatModel[]>([]);
@@ -218,6 +220,7 @@ export function useChat(
           setToolBodies((prev) => keptBodies(prev, before, m.items));
           setLoadingOlder(false);
           setState(m.state);
+          setCompacting(m.compacting ?? null);
           setQueue(m.queue ?? []);
           setSuggestion(m.suggestion ?? null);
         } else if (m.type === "queue") {
@@ -230,8 +233,11 @@ export function useChat(
         } else if (m.type === "search") {
           searchRequests.current.get(m.reqId)?.(m);
           searchRequests.current.delete(m.reqId);
+        } else if (m.type === "compacting") {
+          setCompacting(m.compacting);
         } else if (m.type === "state") {
           setState(m.state);
+          if (m.state === "idle" || m.state === "error") setCompacting(null);
         } else if (m.type === "capabilities") {
           setRefreshingCommands(false);
           setCommands(m.commands);
@@ -469,6 +475,7 @@ export function useChat(
     requestToolBody,
     pinToolBody,
     state,
+    compacting,
     connected,
     commands,
     refreshCommands,

package/lib/chat/activity.ts

@@ -1,4 +1,5 @@
 import type { ChatItem, ChatState } from "./events";
+import { formatTokens } from "./context";
 import { formatElapsed } from "./elapsed";
 import { registry, type Live } from "./registry";
 import { stallThresholdMs } from "./stall";
@@ -94,7 +95,13 @@ export function stallOf(
   thresholdMs: number
 ): Stall | null {
   const a = live.activity;
-  if (live.state !== "running" || thresholdMs <= 0 || a.tasks.size > 0)
+  // A compaction is silent for a while, by nature.
+  if (
+    live.state !== "running" ||
+    live.compacting ||
+    thresholdMs <= 0 ||
+    a.tasks.size > 0
+  )
     return null;
   // A foreground tool call (a long test run) says nothing while it works:
   // it gets a much longer allowance before it counts as stuck.
@@ -110,6 +117,8 @@ export function chatStall(sessionId: string): Stall | null {
   return live ? stallOf(live, Date.now(), stallThresholdMs()) : null;
 }
 
+export const COMPACTING_LABEL = "Compacting context";
+
 // One line on what a chat session is doing, for the session list and
 // notifications: the step running now and since when.
 export function chatActivity(sessionId: string): {
@@ -117,6 +126,8 @@ export function chatActivity(sessionId: string): {
   since?: number;
   background: number;
   stalled?: Stall;
+  // The context size going into a compaction under way.
+  compacting?: { before?: number };
 } | null {
   const live = registry.live.get(sessionId);
   if (!live) return null;
@@ -126,6 +137,13 @@ export function chatActivity(sessionId: string): {
     return { label: "Needs your answer", background };
   if (live.state !== "running")
     return background ? { label: "Idle", background } : null;
+  if (live.compacting)
+    return {
+      label: COMPACTING_LABEL,
+      since: live.compacting.since,
+      background,
+      compacting: { before: live.compacting.before },
+    };
   const stalled = stallOf(live, Date.now(), stallThresholdMs()) ?? undefined;
   if (stalled)
     return { label: "Stalled", since: stalled.since, background, stalled };
@@ -145,7 +163,11 @@ export function chatActivityLine(sessionId: string): string | null {
   if (a.label === "Idle") return background || null;
   if (a.stalled)
     return `Stalled · no output for ${formatElapsed(a.stalled.silentMs)} · last: ${a.stalled.last}`;
-  const parts = [a.label];
+  const parts = [
+    a.compacting?.before
+      ? `${a.label} (${formatTokens(a.compacting.before)} tokens)`
+      : a.label,
+  ];
   if (a.since) parts.push(formatElapsed(Date.now() - a.since));
   if (background) parts.push(background);
   return parts.join(" · ");

package/lib/chat/drivers/claude-mapper.ts

@@ -224,6 +224,13 @@ export class ClaudeMapper {
       case "task_progress":
       case "task_notification":
         return this.task(m);
+      case "status": {
+        // "compacting" while the context is summarised, null once it's done.
+        const status = (m as { status?: string | null }).status;
+        return status === "compacting" || status === null
+          ? [{ type: "compacting", active: status === "compacting" }]
+          : [];
+      }
       case "compact_boundary":
         return [
           {

package/lib/chat/drivers/codex-mapper.ts

@@ -69,6 +69,8 @@ export class CodexMapper {
   }
 
   private started(id: string, item: P): void {
+    if (item.type === "contextCompaction")
+      return this.emit({ type: "compacting", active: true });
     const start = toolStart(item);
     if (start) this.items.tool(id, start);
   }
@@ -82,11 +84,13 @@ export class CodexMapper {
       );
     if (item.type === "reasoning")
       return this.items.finishText(id, "reasoning");
-    if (item.type === "contextCompaction")
+    if (item.type === "contextCompaction") {
+      this.emit({ type: "compacting", active: false });
       return this.emit({
         type: "item",
         item: { id: randomUUID(), kind: "compacted", createdAt: Date.now() },
       });
+    }
     const start = toolStart(item);
     if (!start) return;
     if (!this.items.hasTool(id)) this.items.tool(id, start);

package/lib/chat/drivers/pi-mapper.ts

@@ -90,7 +90,11 @@ export class PiMapper {
           e.isError ? "error" : "done",
           resultText(e.result)
         );
+      case "compaction_start":
+        return this.emit({ type: "compacting", active: true });
       case "compaction_end":
+        // Failed or not, it's over.
+        this.emit({ type: "compacting", active: false });
         if (!e.result) return;
         return this.emit({
           type: "item",

package/lib/chat/events.ts

@@ -267,6 +267,13 @@ export interface FileSuggestion {
 // Waiting: a turn is paused on the reader (an approval or a question).
 export type ChatState = "idle" | "running" | "waiting" | "error";
 
+// A compaction in progress, alongside a "running" state: when it began and
+// the context size going in, when known.
+export interface Compacting {
+  since: number;
+  before?: number;
+}
+
 export interface UndoPreview {
   canUndo: boolean;
   error?: string;
@@ -290,7 +297,9 @@ export type DriverEvent =
   | { type: "context"; context: ChatContext } // context window use
   | { type: "turn_start" } // the agent started a turn (maybe one nobody sent)
   | { type: "at_rest" } // it has run every message it was given
-  | { type: "state"; state: ChatState };
+  | { type: "state"; state: ChatState }
+  // The agent started (true) or finished (false) compacting its context.
+  | { type: "compacting"; active: boolean };
 
 // A tool call's output and diff, loaded when it's opened.
 export interface ToolBody {
@@ -310,6 +319,7 @@ export type ChatServerMessage =
       // Background tasks from before the page, for the composer's list.
       tasks: ChatItem[];
       state: ChatState;
+      compacting?: Compacting | null;
       queue: QueuedMessage[];
       suggestion: string | null;
     }
@@ -334,6 +344,7 @@ export type ChatServerMessage =
   | { type: "item"; item: ChatItem }
   | { type: "delta"; id: string; text: string }
   | { type: "state"; state: ChatState }
+  | { type: "compacting"; compacting: Compacting | null }
   | {
       type: "capabilities";
       commands: ChatCommand[];

package/lib/chat/registry.ts

@@ -7,12 +7,15 @@ import type {
   ChatModel,
   ChatServerMessage,
   ChatState,
+  Compacting,
 } from "./events";
 
 // A conversation whose worker this server is connected to.
 export interface Live {
   worker: WorkerClient;
   state: ChatState;
+  // Set while its agent compacts the context, over a "running" state.
+  compacting?: Compacting | null;
   // Streamed items carry their latest text here, ahead of SQLite.
   streaming: Map<string, ChatItem>;
   // What the turn is doing right now, for the session list.
@@ -82,7 +85,11 @@ export function emit(sessionId: string, m: ChatServerMessage): void {
   registry.listeners.get(sessionId)?.forEach((fn) => fn(m));
   // Idle, running, waiting and back, and a finished turn (unread): the
   // sidebar hears at once.
-  if (m.type === "state" || (m.type === "item" && m.item.kind === "turn_end"))
+  if (
+    m.type === "state" ||
+    m.type === "compacting" ||
+    (m.type === "item" && m.item.kind === "turn_end")
+  )
     notifyStatusChanged();
 }
 

package/lib/chat/runner.ts

@@ -15,6 +15,7 @@ import type {
   ChatContext,
   ChatImage,
   ChatState,
+  Compacting,
   SentBy,
   UndoPreview,
 } from "./events";
@@ -159,8 +160,14 @@ function onWorkerEvent(sessionId: string, live: Live, e: WorkerEvent): void {
     const item = live.streaming.get(e.id);
     if (item && "text" in item) item.text += e.text;
     emit(sessionId, e);
+  } else if (e.type === "compacting") {
+    live.compacting = e.compacting;
+    emit(sessionId, e);
   } else if (e.type === "state") {
     live.state = e.state;
+    // Whatever ended the turn ended the compaction too.
+    if (e.state === "idle" || e.state === "error")
+      setCompacting(sessionId, live, null);
     emit(sessionId, e);
     clearTimeout(live.retiring);
     live.retiring = undefined;
@@ -187,6 +194,16 @@ function onWorkerEvent(sessionId: string, live: Live, e: WorkerEvent): void {
   }
 }
 
+function setCompacting(
+  sessionId: string,
+  live: Live,
+  compacting: Compacting | null
+): void {
+  if (!live.compacting && !compacting) return;
+  live.compacting = compacting;
+  emit(sessionId, { type: "compacting", compacting });
+}
+
 function emitQueue(sessionId: string): void {
   emit(sessionId, { type: "queue", queue: listQueue(sessionId) });
 }
@@ -236,6 +253,7 @@ async function ensureLive(sessionId: string, spawn = true): Promise<Live> {
       onClose: (detached: boolean) => {
         if (live && registry.live.get(sessionId) === live) {
           registry.live.delete(sessionId);
+          emit(sessionId, { type: "compacting", compacting: null });
           emit(sessionId, { type: "state", state: "idle" });
         }
         // It retired itself for a current worker, or ended its agent's
@@ -276,6 +294,7 @@ async function ensureLive(sessionId: string, spawn = true): Promise<Live> {
     live = {
       worker: client,
       state: hello.state,
+      compacting: hello.compacting ?? null,
       streaming: new Map(hello.streaming.map((i) => [i.id, i])),
       activity,
       build: hello.build,
@@ -299,6 +318,8 @@ async function ensureLive(sessionId: string, spawn = true): Promise<Live> {
     if (live.canPlan)
       client.command({ type: "set_plan", plan: !!saved.chat_plan });
     emit(sessionId, { type: "state", state: live.state });
+    if (live.compacting)
+      emit(sessionId, { type: "compacting", compacting: live.compacting });
     return live;
   })();
   registry.connecting.set(sessionId, connecting);
@@ -770,6 +791,8 @@ export function stopChat(sessionId: string): void {
   const live = registry.live.get(sessionId);
   if (live) {
     registry.live.delete(sessionId);
+    if (live.compacting)
+      emit(sessionId, { type: "compacting", compacting: null });
     live.worker.command({ type: "close" });
     live.worker.detach();
     return;
@@ -787,6 +810,9 @@ export async function releaseChat(sessionId: string): Promise<void> {
   await resumeQueue(sessionId);
 }
 
+export const chatCompacting = (sessionId: string): Compacting | null =>
+  registry.live.get(sessionId)?.compacting ?? null;
+
 export function chatState(sessionId: string): ChatState | null {
   return registry.live.get(sessionId)?.state ?? null;
 }
@@ -851,6 +877,7 @@ export function watchChat(
     hasMore: page.hasMore,
     tasks: present(sessionId, tasks),
     state: live?.state ?? "idle",
+    compacting: live?.compacting ?? null,
     queue: listQueue(sessionId),
     suggestion: getSession(sessionId).chat_suggestion ?? null,
   });

package/lib/chat/worker/host.ts

@@ -17,6 +17,7 @@ import type {
   ChatImage,
   ChatItem,
   ChatState,
+  Compacting,
   SentBy,
   UsageTotals,
 } from "../events";
@@ -151,6 +152,9 @@ export class ChatHost {
   private context: ChatContext | null = null;
   // A compaction run ahead of a message (compactFirst): the message waits
   // at the front of the queue until it ends.
+  // The agent compacting its context now, whoever started it: told to
+  // the server so it shows in place of plain "working".
+  compactingNow: Compacting | null = null;
   private compacting: {
     // Set when it ran because the chat was stale.
     idleMs?: number;
@@ -277,6 +281,17 @@ export class ChatHost {
     this.emit({ type: "item", item });
   }
 
+  private setCompacting(on: boolean, before?: number): void {
+    if (on === !!this.compactingNow) return;
+    this.compactingNow = on
+      ? {
+          since: Date.now(),
+          before: before ?? this.compacting?.before ?? this.context?.usedTokens,
+        }
+      : null;
+    this.emit({ type: "compacting", compacting: this.compactingNow });
+  }
+
   private setState(state: ChatState): void {
     this.state = state;
     this.emit({ type: "state", state });
@@ -301,6 +316,8 @@ export class ChatHost {
           // a failed one printed still shows.
           if (this.compacting?.done && e.item.kind === "command_output")
             continue;
+          if (e.item.kind === "compacted" || e.item.kind === "error")
+            this.setCompacting(false);
           if (e.item.kind === "compacted") {
             if (this.compacting) e.item = this.compactedItem(e.item);
             else this.logCompacted(e.item, e.item.trigger ?? "manual");
@@ -383,7 +400,12 @@ export class ChatHost {
             this.currentTurn = null;
             this.setState("running");
           }
+        } else if (e.type === "compacting") {
+          this.setCompacting(e.active);
         } else if (e.type === "state") {
+          // A stop, an error or the end of the turn ends a compaction too.
+          if (e.state === "idle" || e.state === "error")
+            this.setCompacting(false);
           if (e.state === "idle") {
             flushItems();
             // A turn cut off mid-sentence (Esc, Stop) keeps what it streamed.
@@ -435,6 +457,7 @@ export class ChatHost {
         createdAt: Date.now(),
       });
     } finally {
+      this.setCompacting(false);
       this.settleStreaming();
       this.closeTools();
       this.showHandedOver();
@@ -502,6 +525,7 @@ export class ChatHost {
         `UPDATE sessions SET chat_restarted = 0, chat_tools_digest = ? WHERE id = ?`
       ).run(this.toolsDigest, this.session.id);
     }
+    if (/^\/compact\b/.test(m.text.trimStart())) this.setCompacting(true);
     const checkpoint = now
       ? this.conversation.send(text, m.images, { now })
       : this.conversation.send(text, m.images);
@@ -807,6 +831,7 @@ export class ChatHost {
     this.currentTurn = null;
     this.stopping = null;
     this.conversation.send(`/compact ${COMPACT_INSTRUCTIONS}`);
+    this.setCompacting(true, stale.tokens);
     this.setState("running");
     console.error(
       `${new Date().toISOString()} compacting ${this.session.id} before a message: ${stale.stale ? `idle ${Math.round(stale.idleMs / 60_000)}m, ` : ""}${stale.tokens} tokens`
@@ -931,6 +956,7 @@ export class ChatHost {
     clearTimeout(this.retireTimer);
     clearTimeout(this.restTimer);
     this.closed = true;
+    this.setCompacting(false);
     flushItems();
     this.onClose();
     this.conversation.close();

package/lib/chat/worker/main.ts

@@ -74,6 +74,7 @@ async function main(sessionId: string) {
         version: PROTOCOL_VERSION,
         build: buildId(),
         state: host.state,
+        compacting: host.compactingNow,
         streaming: [...host.streaming.values()],
         caps: ["plan", "queue", "retire", "fresh"],
       } satisfies WorkerEvent)}\n`

package/lib/chat/worker/protocol.ts

@@ -12,6 +12,7 @@ import type {
   ChatImage,
   ChatItem,
   ChatState,
+  Compacting,
   DriverEvent,
   FileSuggestion,
   ChatOrigin,
@@ -72,6 +73,8 @@ export type WorkerEvent =
       // The build of the server that started it (lib/build).
       build?: string;
       state: ChatState;
+      // A compaction under way (an older worker never says: not compacting).
+      compacting?: Compacting | null;
       streaming: ChatItem[];
       // Commands it understands beyond the first protocol ("plan"), so the
       // server never trusts a worker from an older build with one it drops.
@@ -87,9 +90,12 @@ export type WorkerEvent =
           | "call_usage"
           | "rate_limit"
           | "suggestion"
-          | "at_rest";
+          | "at_rest"
+          | "compacting";
       }
     >
+  // Compacting began (with when, and the size going in) or ended (null).
+  | { type: "compacting"; compacting: Compacting | null }
   // The agent's guess at the next message, or null once it's stale.
   | { type: "suggestion"; text: string | null }
   | { type: "undo_result"; reqId: string; result?: UndoResult; error?: string }

package/lib/orchestrator/describe.ts

@@ -25,7 +25,7 @@ export function ciWord(pr: TaskPR): string {
 export const shortId = (id: string) => id.slice(0, 8);
 
 function sessionLine(f: SessionFacts): string {
-  const head = `- ${f.name} (${f.project ?? "no project"}, ${f.quick ? "your quick change" : f.view}, id ${shortId(f.id)}): ${STATUS_WORD[f.status]}`;
+  const head = `- ${f.name} (${f.project ?? "no project"}, ${f.quick ? "your quick change" : f.view}, id ${shortId(f.id)}): ${f.compacting ? "compacting context" : STATUS_WORD[f.status]}`;
   const parts = [
     f.activity ? `${head}, ${untrusted(f.name, f.activity)}` : head,
   ];

package/lib/orchestrator/facts.ts

@@ -9,7 +9,7 @@ import { db, type Session, type StackItemStatus } from "../db";
 import { statusDetector } from "../status-detector";
 import { hostLink } from "../hosts/remote-api";
 import { peerStatus } from "../hosts/peer-sessions";
-import { chatState } from "../chat/runner";
+import { chatCompacting, chatState } from "../chat/runner";
 import { chatActivityLine, chatStall, type Stall } from "../chat/activity";
 import { lastUserTask } from "../chat/store";
 import { needsYou } from "../needs-you";
@@ -35,6 +35,8 @@ export interface SessionFacts {
   needsInput: boolean;
   // A chat turn silent past the stall threshold (lib/chat/stall).
   stalled?: Stall | null;
+  // Its agent is summarising the context: not stuck, not plain work.
+  compacting?: boolean;
   // Last sign of life, in ms.
   lastActive: number;
   // Work that should end in a PR: a task, or a session on its own branch.
@@ -274,6 +276,8 @@ export async function sessionFacts(
         needsInput,
         stalled:
           s.view === "chat" && !hostLink(s.host_id) ? chatStall(s.id) : null,
+        compacting:
+          s.view === "chat" && !hostLink(s.host_id) && !!chatCompacting(s.id),
         lastActive: Math.max(
           sqliteMs(s.updated_at),
           statusDetector.getTimestamp(s.tmux_name) * 1000,

package/lib/sidebar/shelves.ts

@@ -30,6 +30,8 @@ export interface RowStatus {
   need?: SessionNeed | null;
   unread?: boolean;
   stalled?: boolean;
+  // A chat summarising its context (status stays "running").
+  compacting?: { since: number; before?: number };
   asks?: number;
   // A program's own message (OSC 7501): untrusted, plain text only.
   detail?: string | null;
@@ -41,6 +43,8 @@ export interface SidebarRow {
   need: SessionNeed | null;
   unread: boolean;
   working: boolean;
+  // Working, but summarising its context, not on the task.
+  compacting?: boolean;
   // Orchestration workers, nested under their conductor.
   workers: SidebarRow[];
   // Its task's state, when it's a task.
@@ -120,6 +124,7 @@ function toRow(input: ShelfInput, session: Session): SidebarRow {
     need: needOf(session, status, input.tasks[session.id]),
     unread: !!status?.unread,
     working: status?.status === "running",
+    compacting: !!status?.compacting,
     workers: [],
     task: input.tasks[session.id],
     quick: [],
@@ -256,6 +261,8 @@ function sameStatus(a: RowStatus | undefined, b: RowStatus | undefined) {
     (a.need ?? null) === (b.need ?? null) &&
     !!a.unread === !!b.unread &&
     !!a.stalled === !!b.stalled &&
+    (a.compacting?.since ?? null) === (b.compacting?.since ?? null) &&
+    (a.compacting?.before ?? null) === (b.compacting?.before ?? null) &&
     a.asks === b.asks &&
     (a.detail ?? null) === (b.detail ?? null)
   );

package/lib/status/collect.ts

@@ -20,7 +20,7 @@ import {
   getSessionIdFromName,
 } from "../providers/registry";
 import { getDb, type Session } from "../db";
-import { chatState } from "../chat/runner";
+import { chatCompacting, chatState } from "../chat/runner";
 import { chatActivityLine, chatStall } from "../chat/activity";
 import {
   chatNeed,
@@ -30,6 +30,7 @@ import {
   terminalStatus,
 } from "../needs-you";
 import type { SessionNeed } from "../sidebar/shelves";
+import type { Compacting } from "../chat/events";
 import { openAskCount } from "../orchestrator/asks";
 import { lastUserTask } from "../chat/store";
 import { hostExecFile, isRemoteHost } from "../hosts";
@@ -62,6 +63,8 @@ export interface SessionStatusResponse {
   unread?: boolean;
   // A chat turn silent past the stall threshold (lib/chat/stall).
   stalled?: boolean;
+  // A chat whose agent is summarising its context ("status" stays running).
+  compacting?: Compacting;
   // A program's own message (OSC 7501): untrusted, plain text only.
   detail?: string | null;
   progress?: number | null;
@@ -467,6 +470,9 @@ async function collect(): Promise<StatusSnapshot> {
       need: chatNeed(session, state, asks),
       unread: isUnread(session, state),
       ...(chatStall(session.id) && { stalled: true }),
+      ...(chatCompacting(session.id) && {
+        compacting: chatCompacting(session.id)!,
+      }),
       ...(session.role === "orchestrator" && { asks }),
     };
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.501",
+  "version": "0.3.502",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"