@saadnvd1/agent-os 0.3.501 → 0.3.503

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/Pane/DesktopTabBar.tsx

@@ -1,5 +1,6 @@
 "use client";
 
+import { SessionPrStage } from "@/components/PrStageBadge";
 import { ViewSwitch } from "@/components/Chat/ViewSwitch";
 import { ContextMeter } from "@/components/Chat/ContextMeter";
 import { Button } from "@/components/ui/button";
@@ -155,6 +156,7 @@ export function DesktopTabBar({
       <div className="flex shrink-0 items-center gap-1.5">
         <HostBadge hostId={session?.host_id} />
         <ContextMeter sessionId={session?.id} />
+        <SessionPrStage sessionId={session?.id} />
         <ViewSwitch session={session} />
         {session?.working_directory && (
           <PaneViewToggle

package/components/Pane/MobileTabBar.tsx

@@ -1,5 +1,6 @@
 "use client";
 
+import { SessionPrStage } from "@/components/PrStageBadge";
 import { ViewSwitch } from "@/components/Chat/ViewSwitch";
 import { paletteActions } from "@/stores/palette";
 import { newDraft } from "@/stores/drafts";
@@ -317,6 +318,7 @@ export function MobileTabBar({
       >
         <Plus className="h-4 w-4" />
       </Button>
+      <SessionPrStage sessionId={session?.id} />
       <ViewSwitch session={session} />
 
       {/* View mode toggle */}

package/components/PrStageBadge.tsx

@@ -0,0 +1,69 @@
+"use client";
+
+import { useQuery } from "@tanstack/react-query";
+import { Loader2 } from "lucide-react";
+import { statusKeys } from "@/data/sessions/keys";
+import {
+  PR_STAGE_BUSY,
+  prStageText,
+  type PrStage,
+  type PrStageName,
+} from "@/lib/tasks/pr-stage";
+import { cn } from "@/lib/utils";
+
+const TONE: Record<PrStageName, string> = {
+  merged: "bg-purple-500/15 text-purple-700 dark:text-purple-400",
+  conflicts: "bg-amber-500/15 text-amber-700 dark:text-amber-400",
+  "ci-failed": "bg-red-500/15 text-red-700 dark:text-red-400",
+  "ci-running": "bg-blue-500/15 text-blue-700 dark:text-blue-400",
+  "ci-settling": "bg-blue-500/15 text-blue-700 dark:text-blue-400",
+  "review-running": "bg-blue-500/15 text-blue-700 dark:text-blue-400",
+  "review-blocked": "bg-red-500/15 text-red-700 dark:text-red-400",
+  waiting: "bg-amber-500/15 text-amber-700 dark:text-amber-400",
+  armed: "bg-green-500/15 text-green-700 dark:text-green-400",
+  open: "bg-muted text-muted-foreground",
+};
+
+// Where a task's PR is in the gates, linking to the PR. `compact` drops the
+// "PR #n" for the sidebar row's tight space (the number stays in the title).
+export function PrStageBadge({
+  stage,
+  compact = false,
+}: {
+  stage?: PrStage;
+  compact?: boolean;
+}) {
+  if (!stage) return null;
+  const text = prStageText(stage);
+  return (
+    <a
+      href={stage.url}
+      target="_blank"
+      rel="noreferrer"
+      title={`${text}${stage.sha ? ` · ${stage.sha}` : ""}`}
+      aria-label={text}
+      onClick={(e) => e.stopPropagation()}
+      className={cn(
+        "inline-flex shrink-0 items-center gap-1 rounded-md px-1.5 py-0.5 text-[11px] font-semibold whitespace-nowrap hover:underline",
+        TONE[stage.stage]
+      )}
+    >
+      {PR_STAGE_BUSY.has(stage.stage) && (
+        <Loader2 className="h-3 w-3 animate-spin" aria-hidden />
+      )}
+      {compact ? text.replace("PR ", "") : text}
+    </a>
+  );
+}
+
+// The badge for one session, read from the status the sidebar already holds.
+export function SessionPrStage({ sessionId }: { sessionId?: string | null }) {
+  const { data } = useQuery<{
+    statuses: Record<string, { prStage?: PrStage }>;
+  }>({ queryKey: statusKeys.all, enabled: false });
+  return (
+    <PrStageBadge
+      stage={sessionId ? data?.statuses[sessionId]?.prStage : undefined}
+    />
+  );
+}

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

@@ -1,3 +1,4 @@
+import type { PrStage } from "@/lib/tasks/pr-stage";
 import type { SessionNeed } from "@/lib/sidebar/shelves";
 
 export interface SessionStatus {
@@ -10,6 +11,8 @@ export interface SessionStatus {
   need?: SessionNeed | null;
   unread?: boolean;
   stalled?: boolean;
+  compacting?: { since: number; before?: number };
+  prStage?: PrStage;
 }
 
 export interface SessionListProps {

package/components/SessionList/SessionRow.tsx

@@ -12,6 +12,7 @@ import { QuickChangeRow } from "./QuickChangeRow";
 import { useRowContext } from "./RowContext";
 import { SessionRowMenu } from "./SessionRowMenu";
 import { RowShell, type RowMenuKind } from "./RowShell";
+import { PrStageBadge } from "@/components/PrStageBadge";
 import { RowBadge, RowDot, RowRename } from "./RowParts";
 import { RowSubtitle } from "./RowSubtitle";
 import { OrchestratorAsks } from "./OrchestratorAsks";
@@ -96,6 +97,7 @@ export const SessionRow = memo(function SessionRow({
         trailing={
           <>
             <RowBadge row={row} />
+            {!row.need && <PrStageBadge stage={row.status?.prStage} compact />}
             {!row.need && <TimeAgo at={session.updated_at} />}
           </>
         }

package/components/views/types.ts

@@ -1,3 +1,4 @@
+import type { PrStage } from "@/lib/tasks/pr-stage";
 import type { SessionNeed } from "@/lib/sidebar/shelves";
 import type { Session } from "@/lib/db";
 import type { ProjectWithDevServers } from "@/lib/projects";
@@ -13,6 +14,9 @@ export interface SessionStatus {
   asks?: number;
   need?: SessionNeed | null;
   unread?: boolean;
+  // A chat summarising its context; status stays "running".
+  compacting?: { since: number; before?: number };
+  prStage?: PrStage;
   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/armed.ts

@@ -12,6 +12,7 @@
  * database, so it survives a restart.
  */
 
+import { notifyStatusChanged } from "../status/hub";
 import { db, type Session } from "../db";
 import type { TaskPR } from "../tasks/state";
 import { latestApproval } from "./ask-approvals";
@@ -37,6 +38,7 @@ export function setArmed(sessionId: string, armed: boolean): void {
        merge_armed_seen = NULL WHERE id = ?`
   ).run(sessionId);
   looked.delete(sessionId);
+  notifyStatusChanged();
 }
 
 // The workspace a task's PR merges through when armed: its project's, with

package/lib/orchestrator/checks.ts

@@ -5,6 +5,7 @@
  */
 
 import { db } from "../db";
+import { notifyStatusChanged } from "../status/hub";
 
 // ci: when the check count on a commit last changed, for settling.
 export type CheckKind = "review" | "scope" | "ci";
@@ -57,6 +58,7 @@ export function putCheck(row: {
     row.status,
     row.detail ?? null
   );
+  notifyStatusChanged();
   return getCheck(row.sessionId, row.sha, row.kind)!;
 }
 

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.
@@ -198,6 +200,7 @@ export async function statusOf(s: Session): Promise<{
 
 // A commit's time never changes: read once per sha.
 const committed = new Map<string, number>();
+export const knownCommitTime = (sha: string) => committed.get(sha) ?? 0;
 
 export async function settleIn(
   workspaceId: string,
@@ -274,6 +277,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/orchestrator/task-state.ts

@@ -114,6 +114,20 @@ async function peerChatWaiting(
 // check has registered on it for 2 minutes. Seconds still to wait.
 export const SETTLE_S = 120;
 
+// When the check count last changed, as ciSettleIn stored it.
+const lastSeen = (detail: string | null | undefined) =>
+  detail ? (JSON.parse(detail) as { count: number; at: number }) : null;
+
+const settleLeft = (
+  last: { count: number; at: number } | null,
+  checkCount: number,
+  committedAt: number,
+  now: number
+) => {
+  const changedAt = last && last.count === checkCount ? last.at : now;
+  return Math.max(0, Math.max(committedAt, changedAt) + SETTLE_S - now);
+};
+
 export function ciSettleIn(input: {
   workspaceId: string;
   taskId: string;
@@ -123,11 +137,7 @@ export function ciSettleIn(input: {
   now?: number;
 }): number {
   const now = Math.floor((input.now ?? Date.now()) / 1000);
-  const seen = getCheck(input.taskId, input.sha, "ci");
-  const last = seen?.detail
-    ? (JSON.parse(seen.detail) as { count: number; at: number })
-    : null;
-  const changedAt = last && last.count === input.checkCount ? last.at : now;
+  const last = lastSeen(getCheck(input.taskId, input.sha, "ci")?.detail);
   if (!last || last.count !== input.checkCount)
     putCheck({
       workspaceId: input.workspaceId,
@@ -137,8 +147,21 @@ export function ciSettleIn(input: {
       status: "pass",
       detail: JSON.stringify({ count: input.checkCount, at: now }),
     });
-  const settledAt = Math.max(input.committedAt, changedAt) + SETTLE_S;
-  return Math.max(0, settledAt - now);
+  return settleLeft(last, input.checkCount, input.committedAt, now);
+}
+
+// The same answer from what ciSettleIn stored, writing nothing: for a
+// status that only looks.
+export function ciSettleLeft(input: {
+  taskId: string;
+  sha: string;
+  checkCount: number;
+  committedAt: number;
+  now?: number;
+}): number {
+  const now = Math.floor((input.now ?? Date.now()) / 1000);
+  const last = lastSeen(getCheck(input.taskId, input.sha, "ci")?.detail);
+  return settleLeft(last, input.checkCount, input.committedAt, now);
 }
 
 // A head with no checks for this long after its PR became mergeable, in a

package/lib/sidebar/shelves.ts

@@ -2,6 +2,7 @@
 // orchestrator, Pinned, Needs you, Working, then Done. Client-safe: no database.
 import type { Session } from "@/lib/db/types";
 import { fromSqliteTime } from "@/lib/session-meta";
+import type { PrStage } from "@/lib/tasks/pr-stage";
 import type { TaskState } from "@/lib/tasks/state";
 
 // Why a session is blocked on you.
@@ -30,7 +31,10 @@ 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;
+  prStage?: PrStage;
   // A program's own message (OSC 7501): untrusted, plain text only.
   detail?: string | null;
 }
@@ -41,6 +45,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 +126,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,7 +263,12 @@ 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.prStage?.stage ?? null) === (b.prStage?.stage ?? null) &&
+    (a.prStage?.number ?? null) === (b.prStage?.number ?? null) &&
+    (a.prStage?.sha ?? null) === (b.prStage?.sha ?? null) &&
     (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,9 @@ import {
   terminalStatus,
 } from "../needs-you";
 import type { SessionNeed } from "../sidebar/shelves";
+import type { PrStage } from "../tasks/pr-stage";
+import { addPrStages } from "./pr-stages";
+import type { Compacting } from "../chat/events";
 import { openAskCount } from "../orchestrator/asks";
 import { lastUserTask } from "../chat/store";
 import { hostExecFile, isRemoteHost } from "../hosts";
@@ -62,6 +65,10 @@ 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;
+  // Where a task's PR is in the gates (lib/tasks/pr-stage.ts).
+  prStage?: PrStage;
   // A program's own message (OSC 7501): untrusted, plain text only.
   detail?: string | null;
   progress?: number | null;
@@ -467,10 +474,15 @@ 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 }),
     };
   }
 
+  addPrStages(statusMap);
+
   // Cleanup old trackers
   statusDetector.cleanup();
 

package/lib/status/pr-stages.ts

@@ -0,0 +1,55 @@
+// A task's PR stage for the sidebar, from state AgentOS already holds: the
+// PR as the last poll saw it, the stored review and CI checks, escalations,
+// asks and the armed flag. Nothing here asks GitHub.
+import { db, type Session } from "../db";
+import { cachedPR, storedPR } from "../tasks/session";
+import { derivePrStage } from "../tasks/pr-stage";
+import { getCheck } from "../orchestrator/checks";
+import { holdingEscalations } from "../orchestrator/gates";
+import { openBySubject, workSubject } from "../orchestrator/asks";
+import { ciSettleLeft } from "../orchestrator/task-state";
+import { knownCommitTime } from "../orchestrator/facts";
+import type { SessionStatusResponse } from "./collect";
+
+type TaskRow = Session & { workspace_id: string };
+
+export function addPrStages(
+  statuses: Record<string, SessionStatusResponse>
+): void {
+  const tasks = db
+    .prepare(
+      `SELECT s.*, p.workspace_id FROM sessions s
+         JOIN projects p ON p.id = s.project_id
+        WHERE s.task_status = 'running' AND s.pr_number IS NOT NULL
+          AND s.archived_at IS NULL`
+    )
+    .all() as TaskRow[];
+  for (const t of tasks) {
+    const status = statuses[t.id];
+    if (!status) continue;
+    try {
+      const pr = cachedPR(t.id) ?? storedPR(t);
+      const head = pr?.head;
+      const stage = derivePrStage({
+        pr,
+        settleIn:
+          pr?.checks === "pass" && head
+            ? ciSettleLeft({
+                taskId: t.id,
+                sha: head,
+                checkCount: pr.checkCount ?? 0,
+                committedAt: knownCommitTime(head),
+              })
+            : 0,
+        review: head ? (getCheck(t.id, head, "review")?.status ?? null) : null,
+        held:
+          holdingEscalations(t.id).length > 0 ||
+          !!openBySubject(t.workspace_id, workSubject(t.id)),
+        armed: !!t.merge_armed_at,
+      });
+      if (stage) status.prStage = stage;
+    } catch (error) {
+      console.error(`[status] PR stage of ${t.id.slice(0, 8)}:`, error);
+    }
+  }
+}

package/lib/tasks/pr-stage.ts

@@ -0,0 +1,92 @@
+// Where a task's PR is in the gates, as one word for the UI. Pure: the
+// inputs are what AgentOS already tracks for the PR (tasks/state.ts,
+// orchestrator/checks.ts), so nothing here asks GitHub or a model.
+
+export const PR_STAGES = [
+  "merged",
+  "conflicts",
+  "ci-failed",
+  "ci-running",
+  "ci-settling",
+  "review-running",
+  "review-blocked",
+  "waiting",
+  "armed",
+  "open",
+] as const;
+
+export type PrStageName = (typeof PR_STAGES)[number];
+
+export interface PrStage {
+  stage: PrStageName;
+  number: number;
+  url: string;
+  // The PR's head, 7 characters.
+  sha?: string;
+}
+
+export interface PrStageInput {
+  pr: {
+    number: number;
+    url: string;
+    state: "OPEN" | "MERGED" | "CLOSED";
+    checks: "pass" | "fail" | "pending" | "none";
+    head?: string;
+    mergeable?: "MERGEABLE" | "CONFLICTING" | "UNKNOWN";
+  } | null;
+  // Seconds until CI on the head counts as settled (0 or unset: settled).
+  settleIn?: number;
+  // The newest review of the head commit.
+  review?: "running" | "pass" | "block" | "error" | null;
+  // Escalated to Saad, or an ask of his open on it.
+  held?: boolean;
+  armed?: boolean;
+}
+
+// In priority order: the first that applies wins, so a conflict hides the
+// CI behind it and a failed CI hides a review that would be moot.
+export function derivePrStage(input: PrStageInput): PrStage | null {
+  const { pr } = input;
+  if (!pr || pr.state === "CLOSED") return null;
+  const base = {
+    number: pr.number,
+    url: pr.url,
+    ...(pr.head && { sha: pr.head.slice(0, 7) }),
+  };
+  const at = (stage: PrStageName): PrStage => ({ stage, ...base });
+  if (pr.state === "MERGED") return at("merged");
+  if (pr.mergeable === "CONFLICTING") return at("conflicts");
+  if (pr.checks === "fail") return at("ci-failed");
+  if (pr.checks === "pending") return at("ci-running");
+  if (pr.checks === "pass" && (input.settleIn ?? 0) > 0)
+    return at("ci-settling");
+  if (input.review === "running") return at("review-running");
+  if (input.review === "block") return at("review-blocked");
+  if (input.held) return at("waiting");
+  if (input.armed) return at("armed");
+  return at("open");
+}
+
+// Stages still moving on their own: the badge spins for these.
+export const PR_STAGE_BUSY: ReadonlySet<PrStageName> = new Set([
+  "conflicts",
+  "ci-running",
+  "ci-settling",
+  "review-running",
+]);
+
+export const PR_STAGE_LABEL: Record<PrStageName, string> = {
+  merged: "merged",
+  conflicts: "rebasing",
+  "ci-failed": "CI failed",
+  "ci-running": "CI running",
+  "ci-settling": "CI settling",
+  "review-running": "reviewing",
+  "review-blocked": "review blocked",
+  waiting: "waiting on you",
+  armed: "armed",
+  open: "open",
+};
+
+export const prStageText = (s: Pick<PrStage, "stage" | "number">) =>
+  `PR #${s.number} · ${PR_STAGE_LABEL[s.stage]}`;

package/lib/tasks/session.ts

@@ -9,6 +9,7 @@ import { getProject } from "../projects";
 import { findPRStrict } from "./gh";
 import { currentBranch, git } from "../git-exec";
 import { lookupPR } from "./pr-poll";
+import { notifyStatusChanged } from "../status/hub";
 import type { TaskPR } from "./state";
 
 export const expandHome = (p: string) => p.replace(/^~/, os.homedir());
@@ -128,6 +129,15 @@ export const isoUTC = (t: string) =>
 
 const prCache = new Map<string, { at: number; pr: TaskPR | null }>();
 
+const prSignature = (pr: TaskPR | null | undefined) =>
+  pr
+    ? `${pr.number}|${pr.state}|${pr.checks}|${pr.head}|${pr.mergeable}|${pr.checkCount}`
+    : "";
+
+// The PR as the last poll saw it, with no gh call; undefined before one.
+export const cachedPR = (sessionId: string): TaskPR | null | undefined =>
+  prCache.get(sessionId)?.pr;
+
 // strict: a gh failure throws instead of reading as "no PR".
 export async function prFor(
   session: Session,
@@ -167,7 +177,10 @@ export async function prFor(
     }
   }
   if (renamed && !refused) moveBranch(session, renamed);
+  const before = prCache.get(session.id)?.pr;
   prCache.set(session.id, { at: Date.now(), pr });
+  // A PR whose stage inputs moved is news for the sidebar's badge.
+  if (prSignature(before) !== prSignature(pr)) notifyStatusChanged();
   if (pr) {
     db.prepare(
       `UPDATE sessions SET pr_url = ?, pr_number = ?, pr_status = ? WHERE id = ?`

package/package.json

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